Update README.md

some configs from tmuxinator not yet supported so will remove them for now until we can support it

README.md

@@ -3,7 +3,7 @@
 Project Environment Executor, Define your project workspace as code and config.
 
 ## Usecase
-Creating a tmux session from a config file, this includes setting up working directories, setting up dev servers, and opening editors.
+Creating tmux sessions with preconfigured panes layouts and commands. inspired from [tmuxinator](https://github.com/tmuxinator/tmuxinator)
 
 ### Get Started
 
@@ -11,7 +11,7 @@ Creating a tmux session from a config file, this includes setting up working dir
 
 #### Installation
 ```bash
-go install github.com/xrehpicx/pee@latest
+go install github.com/xrehpicx/pee.git@latest
 ```
 
 #### Initialize a project
@@ -73,7 +73,9 @@ 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. Ability to save custom layouts as named layouts that can be used across multiple projects
+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
 
 ---
 All contributions are welcome 

config/main.go

@@ -23,20 +23,14 @@ type Window struct {
 }
 
 type Configuration struct {
-	SessionName         string   `yaml:"name"`
+	SessionName   string   `yaml:"name"`
-	EditorCommand       string   `yaml:"editor"`
+	EditorCommand string   `yaml:"editor"`
-	WorkingDir          string   `yaml:"root"`
+	WorkingDir    string   `yaml:"root"`
-	Windows             []Window `yaml:"windows"`
+	Windows       []Window `yaml:"windows"`
-	LastOpened          time.Time
+	LastOpened    time.Time
-	Attach              bool   `yaml:"attach"`
+	Attach        bool   `yaml:"attach"`
-	StartupWindow       string `yaml:"startup_window"`
+	StartupWindow string `yaml:"startup_window"`
-	StartupPane         int    `yaml:"startup_pane"`
+	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

controller/screen.go

@@ -0,0 +1,107 @@
+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
+}

controller/tmux.go

@@ -26,7 +26,8 @@ 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)
+		createSessionCmd := exec.Command("tmux", "new-session", "-d", "-s", sessionName, "-c", config.WorkingDir)
+		// createSessionCmd := exec.Command("tmux", "new-session", "-d", "-s", sessionName)
 		if err := createSessionCmd.Run(); err != nil {
 			return err
 		}
@@ -76,6 +77,13 @@ 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 {
@@ -98,12 +106,27 @@ func CreateTmuxSession(config *projectconfig.Configuration) error {
 		}
 
 		// Select the initial window and switch to the session
-		selectWindowCmd := exec.Command("tmux", "select-window", "-t", sessionName+":1")
+		defaultWindow := sessionName + ":1"
+		if config.StartupWindow != "" {
+			defaultWindow = config.StartupWindow
+		}
+
+		selectWindowCmd := exec.Command("tmux", "select-window", "-t", defaultWindow)
 		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 {
@@ -169,6 +192,13 @@ 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 {
@@ -188,3 +218,12 @@ 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
+}

main.go

@@ -12,6 +12,7 @@ func init() {
 	projectconfig.Init()
 	projectmanager.RootCmd.AddCommand(projectmanager.ListProjects)
 	projectmanager.RootCmd.AddCommand(projectmanager.InitCmd)
+	projectmanager.RootCmd.AddCommand(projectmanager.ScreenCmd)
 }
 
 func main() {

project-manager/init.go

@@ -0,0 +1,92 @@
+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)
+		}
+	},
+}

project-manager/ls.go

@@ -0,0 +1,54 @@
+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])
+		}
+	},
+}

project-manager/main.go

@@ -1,62 +1,13 @@
 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),
@@ -65,6 +16,24 @@ 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 {
@@ -79,83 +48,3 @@ 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)
-		}
-	},
-}

project-manager/screen.go

@@ -0,0 +1,43 @@
+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)
+}

ui/table/main.go

@@ -92,15 +92,19 @@ 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("57")).
+		Background(lipgloss.Color("240")).
 		Bold(false)
+
 	t.SetStyles(s)
 
 	m := model{t, "", help.New(), keys}