11 changed files with 149 additions and 374 deletions
--- a/.DS_Store
+++ b/.DS_Store
--- a/config/main.go
+++ b/config/main.go
@ -23,14 +23,20 @@ type Window struct {
 }

 type Configuration struct {
-	SessionName   string   `yaml:"name"`
-	EditorCommand string   `yaml:"editor"`
-	WorkingDir    string   `yaml:"root"`
-	Windows       []Window `yaml:"windows"`
-	LastOpened    time.Time
-	Attach        bool   `yaml:"attach"`
-	StartupWindow string `yaml:"startup_window"`
-	StartupPane   int    `yaml:"startup_pane"`
+	SessionName         string   `yaml:"name"`
+	EditorCommand       string   `yaml:"editor"`
+	WorkingDir          string   `yaml:"root"`
+	Windows             []Window `yaml:"windows"`
+	LastOpened          time.Time
+	Attach              bool   `yaml:"attach"`
+	StartupWindow       string `yaml:"startup_window"`
+	StartupPane         int    `yaml:"startup_pane"`
+	OnProjectStart      string `yaml:"on_project_start"`
+	OnProjectFirstStart string `yaml:"on_project_first_start"`
+	OnProjectRestart    string `yaml:"on_project_restart"`
+	OnProjectExit       string `yaml:"on_project_exit"`
+	OnProjectStop       string `yaml:"on_project_stop"`
+	SocketName          string `yaml:"socket_name"`
 }

 var configDir string
--- a/controller/screen.go
+++ b/controller/screen.go
@ -1,107 +0,0 @@
-package controller
-
-import (
-	"fmt"
-	"os/exec"
-	"strings"
-
-	"github.com/charmbracelet/log"
-	projectconfig "github.com/xrehpicx/pee/config"
-)
-
-// RunShellCommand executes a shell command and logs it.
-func RunShellCommand(cmd *exec.Cmd) error {
-	log.Debug("Running command:", "command", cmd.String())
-	output, err := cmd.CombinedOutput()
-	if err != nil {
-		log.Error("Error running command:", "command", cmd.String(), "error", err)
-		log.Info("Command output:", "output", string(output))
-		return err
-	}
-	return nil
-}
-
-// CreateScreenSession creates a new screen session based on the given Configuration.
-func CreateScreenSession(config *projectconfig.Configuration) error {
-	sessionName := config.SessionName
-
-	// Check if the session already exists
-	checkSessionCmd := exec.Command("screen", "-S", sessionName, "-Q", "windows")
-	_, err := checkSessionCmd.CombinedOutput()
-	if err == nil {
-		// If it exists, attach to the session
-		attachSessionCmd := exec.Command("screen", "-d", "-r", sessionName)
-		RunShellCommand(attachSessionCmd)
-	} else {
-		// If it doesn't exist, create the session
-		createSessionCmd := exec.Command("screen", "-S", sessionName, "-d", "-m")
-		RunShellCommand(createSessionCmd)
-
-		// Create and run commands for windows
-		for i, window := range config.Windows {
-			windowName := fmt.Sprintf("%s-%d", sessionName, i+1)
-
-			// Create a new window within the session
-			createWindowCmd := exec.Command("screen", "-S", sessionName, "-X", "screen", "-t", windowName)
-			RunShellCommand(createWindowCmd)
-
-			// Change the working directory for the window
-			changeDirCmd := exec.Command("screen", "-S", sessionName, "-p", fmt.Sprint(i), "-X", "chdir", config.WorkingDir)
-			RunShellCommand(changeDirCmd)
-
-			// Send commands to the window
-			sendCommandsCmd := exec.Command("screen", "-S", sessionName, "-p", fmt.Sprint(i), "-X", "stuff", strings.Join(window.Panes[0].ShellCommand, " && ")+"\n")
-			RunShellCommand(sendCommandsCmd)
-
-			// Rename the window to the specified name
-			renameWindowCmd := exec.Command("screen", "-S", sessionName, "-p", fmt.Sprint(i), "-X", "title", window.WindowName)
-			RunShellCommand(renameWindowCmd)
-
-			// warn user of compatibility issues using more than one pane with screen
-			if len(window.Panes) > 1 {
-				log.Warn("Screen does not support multiple panes. Only the first pane will be used.")
-			}
-
-			// Create and run commands for additional panes in the window
-			for _, pane := range window.Panes[1:] {
-				// Split the window vertically
-				splitPaneCmd := exec.Command("screen", "-S", sessionName, "-p", fmt.Sprint(i), "-X", "split")
-				RunShellCommand(splitPaneCmd)
-
-				// Select the new pane
-				selectPaneCmd := exec.Command("screen", "-S", sessionName, "-p", fmt.Sprint(i+1)) // Select the next pane
-				RunShellCommand(selectPaneCmd)
-
-				// Send commands to the new pane
-				sendCommandsCmd := exec.Command("screen", "-S", sessionName, "-X", "stuff", strings.Join(pane.ShellCommand, " && ")+"\n")
-				RunShellCommand(sendCommandsCmd)
-			}
-
-			if window.Layout != "" {
-				layoutCmd := exec.Command("screen", "-S", sessionName, "-p", fmt.Sprint(i), "-X", "layout", window.Layout)
-				RunShellCommand(layoutCmd)
-			}
-		}
-
-		if config.Attach {
-			// Attach to the session
-			attachSessionCmd := exec.Command("screen", "-d", "-r", sessionName)
-			RunShellCommand(attachSessionCmd)
-		}
-	}
-
-	return nil
-}
-
-// KillScreenSession kills a screen session by name.
-func KillScreenSession(sessionName string) error {
-	// Kill the screen session
-	killSessionCmd := exec.Command("screen", "-S", sessionName, "-X", "quit")
-	err := killSessionCmd.Run()
-	if err != nil {
-		log.Error("Error killing screen session:", "sessionName", sessionName, "error", err)
-		return err
-	}
-	log.Info("Killed screen session:", "sessionName", sessionName)
-	return nil
-}
--- a/controller/tmux.go
+++ b/controller/tmux.go
@ -26,8 +26,7 @@ func CreateTmuxSession(config *projectconfig.Configuration) error {
 		log.Debug("Ran command", "command", switchSessionCmd.String())
 	} else {
 		// If it doesn't exist, create the session
-		createSessionCmd := exec.Command("tmux", "new-session", "-d", "-s", sessionName, "-c", config.WorkingDir)
-		// createSessionCmd := exec.Command("tmux", "new-session", "-d", "-s", sessionName)
+		createSessionCmd := exec.Command("tmux", "new-session", "-d", "-s", sessionName)
 		if err := createSessionCmd.Run(); err != nil {
 			return err
 		}
@ -77,13 +76,6 @@ func CreateTmuxSession(config *projectconfig.Configuration) error {
 			}
 			log.Debug("Ran command", "command", selectPaneCmd.String())

-			// Change the working directory
-			changeDirCmd := exec.Command("tmux", "send-keys", "-t", paneName, "cd "+config.WorkingDir, "Enter")
-			if err := changeDirCmd.Run(); err != nil {
-				return err
-			}
-			log.Debug("Ran command", "command", changeDirCmd.String())
-
 			// Send commands to the pane
 			sendCommandsCmd := exec.Command("tmux", "send-keys", "-t", paneName, strings.Join(pane.ShellCommand, " && "), "Enter")
 			if err := sendCommandsCmd.Run(); err != nil {
@ -106,27 +98,12 @@ func CreateTmuxSession(config *projectconfig.Configuration) error {
 		}

 		// Select the initial window and switch to the session
-		defaultWindow := sessionName + ":1"
-		if config.StartupWindow != "" {
-			defaultWindow = config.StartupWindow
-		}
-
-		selectWindowCmd := exec.Command("tmux", "select-window", "-t", defaultWindow)
+		selectWindowCmd := exec.Command("tmux", "select-window", "-t", sessionName+":1")
 		if err := selectWindowCmd.Run(); err != nil {
 			return err
 		}
 		log.Debug("Ran command", "command", selectWindowCmd.String())

-		// Select initial pane
-		if config.StartupPane > 0 {
-			defaultPane := fmt.Sprintf("%s:%d.%d", sessionName, config.StartupPane, 1)
-			selectPaneCmd := exec.Command("tmux", "select-pane", "-t", defaultPane)
-			if err := selectPaneCmd.Run(); err != nil {
-				return err
-			}
-			log.Debug("Ran command", "command", selectPaneCmd.String())
-		}
-
 		if config.Attach {
 			switchSessionCmd := exec.Command("tmux", "switch-client", "-t", sessionName)
 			if err := switchSessionCmd.Run(); err != nil {
@ -192,13 +169,6 @@ func createWindow(config *projectconfig.Configuration, sessionName string, index
 		}
 		log.Debug("Ran command", "command", selectPaneCmd.String())

-		// Change the working directory for the pane
-		changeDirCmd := exec.Command("tmux", "send-keys", "-t", paneName, "cd "+config.WorkingDir, "Enter")
-		if err := changeDirCmd.Run(); err != nil {
-			return err
-		}
-		log.Debug("Ran command", "command", changeDirCmd.String())
-
 		// Send commands to the pane
 		sendCommandsCmd := exec.Command("tmux", "send-keys", "-t", paneName, strings.Join(pane.ShellCommand, " && "), "Enter")
 		if err := sendCommandsCmd.Run(); err != nil {
@ -218,12 +188,3 @@ func createWindow(config *projectconfig.Configuration, sessionName string, index

 	return nil
 }
-
-func KillTmuxSession(sessionName string) error {
-	killSessionCmd := exec.Command("tmux", "kill-session", "-t", sessionName)
-	if err := killSessionCmd.Run(); err != nil {
-		return err
-	}
-	log.Debug("Ran command", "command", killSessionCmd.String())
-	return nil
-}
--- a/main.go
+++ b/main.go
@ -12,7 +12,6 @@ func init() {
 	projectconfig.Init()
 	projectmanager.RootCmd.AddCommand(projectmanager.ListProjects)
 	projectmanager.RootCmd.AddCommand(projectmanager.InitCmd)
-	projectmanager.RootCmd.AddCommand(projectmanager.ScreenCmd)
 }

 func main() {
--- a/project-manager/init.go
+++ b/project-manager/init.go
@ -1,92 +0,0 @@
-package projectmanager
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/charmbracelet/log"
-	"github.com/spf13/cobra"
-	projectconfig "github.com/xrehpicx/pee/config"
-	"github.com/xrehpicx/pee/ui/filepicker"
-	"github.com/xrehpicx/pee/utils"
-)
-
-var InitCmd = &cobra.Command{
-	Use:  "init",
-	Args: cobra.ExactArgs(1),
-	Run: func(cmd *cobra.Command, args []string) {
-		projectName := args[0]
-		projectExists := projectconfig.ProjectExists(projectName)
-		if projectExists {
-			log.Warn("Project already exists", "name", projectName)
-			return
-		}
-
-		selected, err := filepicker.FilePicker("Select your project dir", "Selected Dir: ")
-		if selected == "" {
-			log.Warn("No dir selected, aborting")
-			return
-		}
-		if err != nil {
-			log.Error(err)
-			return
-		}
-		log.Debug("Selected", "work_dir", selected)
-
-		// Define the session configuration
-		workingDir := selected
-		windows := []projectconfig.Window{
-			{
-				WindowName: "editor",
-				Layout:     "8070,202x58,0,0[202x46,0,0,89,202x11,0,47,92]",
-				Panes: []projectconfig.Pane{
-					{
-						ShellCommand: []string{"echo 'command to open your editor'"},
-					},
-					{
-						ShellCommand: []string{"echo 'run dev server'"},
-					},
-				},
-			},
-			{
-				WindowName: "ssh windows",
-				ShellCommandBefore: []string{
-					"ls -lr",
-				},
-				Panes: []projectconfig.Pane{
-					{
-						ShellCommand: []string{"echo 'command to open your ssh windows'"},
-					},
-					{
-						ShellCommand: []string{"echo 'command to open your ssh windows'"},
-					},
-				},
-			},
-			{
-				WindowName: "git",
-				Panes: []projectconfig.Pane{
-					{
-						ShellCommand: []string{"echo 'command to open your git client'"},
-					},
-				},
-			},
-		}
-
-		logger := log.NewWithOptions(os.Stderr, log.Options{
-			ReportCaller:    false,
-			ReportTimestamp: false,
-		})
-
-		ppath, err := projectconfig.CreateProject(projectName, workingDir, windows)
-		if err != nil {
-			logger.Error(err)
-		} else {
-			editorCommand, err := projectconfig.GetEditorCommand(projectName)
-			if err != nil {
-				editorCommand = ""
-			}
-			utils.EditFile(ppath, editorCommand)
-			fmt.Println("Created Project, config is at:", ppath)
-		}
-	},
-}
--- a/project-manager/ls.go
+++ b/project-manager/ls.go
@ -1,54 +0,0 @@
-package projectmanager
-
-import (
-	"fmt"
-
-	btable "github.com/charmbracelet/bubbles/table"
-	"github.com/charmbracelet/log"
-	"github.com/spf13/cobra"
-	projectconfig "github.com/xrehpicx/pee/config"
-	"github.com/xrehpicx/pee/ui/table"
-	"github.com/xrehpicx/pee/utils"
-)
-
-var ListProjects = &cobra.Command{
-	Use:   "ls",
-	Short: "List all projects",
-	Run: func(cmd *cobra.Command, args []string) {
-		projects, err := projectconfig.ListProjects()
-		if err != nil {
-			fmt.Println(err)
-			return
-		}
-		columns := []btable.Column{
-			{Title: "Name", Width: 20},
-			{Title: "Session Name", Width: 20},
-			{Title: "Working Dir", Width: 50},
-			{Title: "Last Opened", Width: 20},
-		}
-		var rows []btable.Row
-
-		for projectName, config := range projects {
-			row := []string{
-				projectName,
-				config.SessionName,
-				config.WorkingDir,
-				config.LastOpened.Format("2006-01-02 15:04:05"),
-			}
-			rows = append(rows, row)
-		}
-		selectedRow, action := table.Table(columns, rows)
-		if action == "edit" {
-			// print a vim command to open the config file
-			editorCommand, err := projectconfig.GetEditorCommand(selectedRow[0])
-			if err != nil {
-				editorCommand = ""
-			}
-			utils.EditFile(projectconfig.ProjectConfigFilePath(selectedRow[0]), editorCommand)
-			log.Debug("Opened config file", "file", projectconfig.ProjectConfigFilePath(selectedRow[0]))
-		}
-		if action == "open" {
-			ExecuteProjectEnv(selectedRow[0])
-		}
-	},
-}
--- a/project-manager/main.go
+++ b/project-manager/main.go
@ -1,13 +1,62 @@
 package projectmanager

 import (
+	"fmt"
+	"os"
+
 	projectconfig "github.com/xrehpicx/pee/config"
 	"github.com/xrehpicx/pee/controller"
+	"github.com/xrehpicx/pee/ui/filepicker"
+	"github.com/xrehpicx/pee/ui/table"
+	"github.com/xrehpicx/pee/utils"

+	btable "github.com/charmbracelet/bubbles/table"
 	"github.com/charmbracelet/log"
 	"github.com/spf13/cobra"
 )

+var ListProjects = &cobra.Command{
+	Use:   "ls",
+	Short: "List all projects",
+	Run: func(cmd *cobra.Command, args []string) {
+		projects, err := projectconfig.ListProjects()
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+		columns := []btable.Column{
+			{Title: "Name", Width: 20},
+			{Title: "Session Name", Width: 20},
+			{Title: "Working Dir", Width: 50},
+			{Title: "Last Opened", Width: 20},
+		}
+		var rows []btable.Row
+
+		for projectName, config := range projects {
+			row := []string{
+				projectName,
+				config.SessionName,
+				config.WorkingDir,
+				config.LastOpened.Format("2006-01-02 15:04:05"),
+			}
+			rows = append(rows, row)
+		}
+		selectedRow, action := table.Table(columns, rows)
+		if action == "edit" {
+			// print a vim command to open the config file
+			editorCommand, err := projectconfig.GetEditorCommand(selectedRow[0])
+			if err != nil {
+				editorCommand = ""
+			}
+			utils.EditFile(projectconfig.ProjectConfigFilePath(selectedRow[0]), editorCommand)
+			log.Debug("Opened config file", "file", projectconfig.ProjectConfigFilePath(selectedRow[0]))
+		}
+		if action == "open" {
+			ExecuteProjectEnv(selectedRow[0])
+		}
+	},
+}
+
 var RootCmd = &cobra.Command{
 	Use:  "pee",
 	Args: cobra.ExactArgs(1),
@ -16,24 +65,6 @@ var RootCmd = &cobra.Command{
 	},
 }

-var KillTmuxSessionCmd = &cobra.Command{
-	Use:  "kill",
-	Args: cobra.ExactArgs(1),
-	Run: func(cmd *cobra.Command, args []string) {
-		sessionName := args[0]
-		err := controller.KillTmuxSession(sessionName)
-		if err != nil {
-			log.Error(err)
-			return
-		}
-		log.Debug("Killed tmux session", "name", sessionName)
-	},
-}
-
-func init() {
-	RootCmd.AddCommand(KillTmuxSessionCmd)
-}
-
 func ExecuteProjectEnv(projectName string) {
 	config, err := projectconfig.GetProjectConfig(projectName)
 	if err != nil {
@ -48,3 +79,83 @@ func ExecuteProjectEnv(projectName string) {
 	projectconfig.UpdateLastOpened(projectName)
 	log.Debug("Created tmux session", "name", config.SessionName)
 }
+
+var InitCmd = &cobra.Command{
+	Use:  "init",
+	Args: cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		projectName := args[0]
+		projectExists := projectconfig.ProjectExists(projectName)
+		if projectExists {
+			log.Warn("Project already exists", "name", projectName)
+			return
+		}
+
+		selected, err := filepicker.FilePicker("Select your project dir", "Selected Dir: ")
+		if selected == "" {
+			log.Warn("No dir selected, aborting")
+			return
+		}
+		if err != nil {
+			log.Error(err)
+			return
+		}
+		log.Debug("Selected", "work_dir", selected)
+
+		// Define the session configuration
+		workingDir := selected
+		windows := []projectconfig.Window{
+			{
+				WindowName: "editor",
+				Layout:     "8070,202x58,0,0[202x46,0,0,89,202x11,0,47,92]",
+				Panes: []projectconfig.Pane{
+					{
+						ShellCommand: []string{"echo 'command to open your editor'"},
+					},
+					{
+						ShellCommand: []string{"echo 'run dev server'"},
+					},
+				},
+			},
+			{
+				WindowName: "ssh windows",
+				ShellCommandBefore: []string{
+					"ls -lr",
+				},
+				Panes: []projectconfig.Pane{
+					{
+						ShellCommand: []string{"echo 'command to open your ssh windows'"},
+					},
+					{
+						ShellCommand: []string{"echo 'command to open your ssh windows'"},
+					},
+				},
+			},
+			{
+				WindowName: "git",
+				Panes: []projectconfig.Pane{
+					{
+						ShellCommand: []string{"echo 'command to open your git client'"},
+					},
+				},
+			},
+		}
+
+		logger := log.NewWithOptions(os.Stderr, log.Options{
+			ReportCaller:    false,
+			ReportTimestamp: false,
+		})
+
+		ppath, err := projectconfig.CreateProject(projectName, workingDir, windows)
+		if err != nil {
+			logger.Error(err)
+		} else {
+			editorCommand, err := projectconfig.GetEditorCommand(projectName)
+			if err != nil {
+				editorCommand = ""
+			}
+			utils.EditFile(ppath, editorCommand)
+			fmt.Println("Created Project, config is at:", ppath)
+		}
+	},
+}
--- a/project-manager/screen.go
+++ b/project-manager/screen.go
@ -1,43 +0,0 @@
-package projectmanager
-
-import (
-	"github.com/charmbracelet/log"
-	"github.com/spf13/cobra"
-	projectconfig "github.com/xrehpicx/pee/config"
-	"github.com/xrehpicx/pee/controller"
-)
-
-var KillScreenCmd = &cobra.Command{
-	Use:  "kill",
-	Args: cobra.ExactArgs(1),
-	Run: func(cmd *cobra.Command, args []string) {
-		controller.KillScreenSession(args[0])
-	},
-}
-
-var ScreenCmd = &cobra.Command{
-	Use:  "scr",
-	Args: cobra.ExactArgs(1),
-	Run: func(cmd *cobra.Command, args []string) {
-		ExecuteProjectEnvUsingScreen(args[0])
-	},
-}
-
-func ExecuteProjectEnvUsingScreen(projectName string) {
-	config, err := projectconfig.GetProjectConfig(projectName)
-	if err != nil {
-		log.Error(err)
-		return
-	}
-	err = controller.CreateScreenSession(config)
-	if err != nil {
-		log.Error(err)
-		return
-	}
-	projectconfig.UpdateLastOpened(projectName)
-	log.Debug("Created tmux session", "name", config.SessionName)
-}
-
-func init() {
-	ScreenCmd.AddCommand(KillScreenCmd)
-}
--- a/readme.md
+++ b/readme.md
@ -3,7 +3,7 @@
 Project Environment Executor, Define your project workspace as code and config.

 ## Usecase
-Creating tmux sessions with preconfigured panes layouts and commands. inspired from [tmuxinator](https://github.com/tmuxinator/tmuxinator)
+Creating a tmux session from a config file, this includes setting up working directories, setting up dev servers, and opening editors.

 ### Get Started

@ -11,7 +11,7 @@ Creating tmux sessions with preconfigured panes layouts and commands. inspired f

 #### Installation
 ```bash
-go install github.com/xrehpicx/pee.git@latest
+go install github.com/xrehpicx/pee@latest
 ```

 #### Initialize a project
@ -73,9 +73,7 @@ and select the project from table and click `<enter>` to open/create the session
 1. Supporting iTerm2
   As of now this supports only tmux windows and panes, would want to add support for iterm and other terminals if they have api's to do so.
 2. Ability to save an opened session into a config or update a config
-3. Parse cli args to config
-4. Ability to save custom layouts as named layouts that can be used across multiple projects
-5. Sync configs across devices
+3. Ability to save custom layouts as named layouts that can be used across multiple projects

 ---
 All contributions are welcome 
--- a/ui/table/main.go
+++ b/ui/table/main.go
@ -92,19 +92,15 @@ func Table(columns []table.Column, rows []table.Row) (table.Row, string) {
 	)

 	s := table.DefaultStyles()
-
-	// rounded borders
 	s.Header = s.Header.
 		BorderStyle(lipgloss.NormalBorder()).
 		BorderForeground(lipgloss.Color("240")).
 		BorderBottom(true).
 		Bold(false)
-
 	s.Selected = s.Selected.
 		Foreground(lipgloss.Color("229")).
-		Background(lipgloss.Color("240")).
+		Background(lipgloss.Color("57")).
 		Bold(false)
-
 	t.SetStyles(s)

 	m := model{t, "", help.New(), keys}