feat: add compose management (up, down, stop, remove, etc) and enhance logs functionality

refactor: new Keymapings for new compose management

Author: shubh-io

internal/docker/client.go

@@ -422,6 +422,117 @@ func DoAction(action, containerID string) error {
 	return cmd.Run()
 }
 
+type ComposeCommand struct {
+	Binary     string
+	SubCommand string
+}
+
+func GetComposeCommand() ComposeCommand {
+	if runtimeBin() == "docker" {
+
+		if path, err := exec.LookPath("docker"); err == nil {
+			if err := exec.Command(path, "compose", "version").Run(); err == nil {
+				return ComposeCommand{Binary: "docker", SubCommand: "compose"}
+			}
+		}
+		if path, err := exec.LookPath("docker-compose"); err == nil {
+			return ComposeCommand{Binary: path, SubCommand: ""}
+		}
+
+	} else {
+		if path, err := exec.LookPath("podman-compose"); err == nil {
+			return ComposeCommand{Binary: path, SubCommand: ""}
+		}
+
+		if path, err := exec.LookPath("podman"); err == nil {
+			return ComposeCommand{Binary: path, SubCommand: "compose"}
+		}
+	}
+
+	return ComposeCommand{Binary: "docker", SubCommand: "compose"}
+}
+
+func RunComposeAction(action, project, workingDir string) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 300*time.Second)
+	defer cancel()
+
+	cmdConfig := GetComposeCommand()
+
+	var args []string
+	if cmdConfig.SubCommand != "" {
+		args = append(args, cmdConfig.SubCommand)
+	}
+
+	if project != "" {
+		args = append(args, "-p", project)
+	}
+
+	args = append(args, action)
+
+	switch action {
+	case "up":
+		args = append(args, "-d")
+	case "logs":
+		args = append(args, "--tail", "20")
+	}
+
+	cmd := exec.CommandContext(ctx, cmdConfig.Binary, args...)
+
+	if workingDir != "" {
+		cmd.Dir = workingDir
+	}
+
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+
+		return fmt.Errorf("compose error (%s %s): %v\nOutput: %s", cmdConfig.Binary, action, err, string(output))
+	}
+
+	return nil
+}
+
+// GetComposeLogs runs `compose logs` for a given project and returns the output lines
+func GetComposeLogs(project, workingDir string) ([]string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	cmdConfig := GetComposeCommand()
+	var args []string
+	if cmdConfig.SubCommand != "" {
+		args = append(args, cmdConfig.SubCommand)
+	}
+	if project != "" {
+		args = append(args, "-p", project)
+	}
+	args = append(args, "logs", "--tail", "15")
+
+	cmd := exec.CommandContext(ctx, cmdConfig.Binary, args...)
+	if workingDir != "" {
+		cmd.Dir = workingDir
+	}
+
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		// return output even on error to give the caller something to show
+		lines := []string{}
+		for _, l := range strings.Split(string(output), "\n") {
+			if s := strings.TrimSpace(l); s != "" {
+				lines = append(lines, s)
+			}
+		}
+		return lines, fmt.Errorf("compose logs error: %v\nOutput: %s", err, string(output))
+	}
+
+	lines := []string{}
+	for _, l := range strings.Split(string(output), "\n") {
+		if s := strings.TrimSpace(l); s != "" {
+			lines = append(lines, s)
+		}
+	}
+
+	return lines, nil
+}
+
 // FetchComposeProjects fetches all Docker/Podman Compose projects with their containers
 
 func FetchComposeProjects() (map[string]*ComposeProject, error) {

internal/tui/cmds.go

@@ -45,10 +45,24 @@ func doAction(action, containerID string) tea.Cmd {
 	}
 }
 
+func composeActionCmd(action, project, workingDir string) tea.Cmd {
+	return func() tea.Msg {
+		err := docker.RunComposeAction(action, project, workingDir)
+		return actionDoneMsg{err: err}
+	}
+}
+
 // fetch logs for a container
 func fetchLogsCmd(id string) tea.Cmd {
 	return func() tea.Msg {
 		lines, err := docker.GetLogs(id)
 		return docker.LogsMsg{ID: id, Lines: lines, Err: err}
 	}
 }
+
+func fetchComposeLogsCmd(project, workingDir string) tea.Cmd {
+	return func() tea.Msg {
+		lines, err := docker.GetComposeLogs(project, workingDir)
+		return docker.LogsMsg{ID: project, Lines: lines, Err: err}
+	}
+}

internal/tui/compose-view.go

@@ -103,6 +103,9 @@ func (m model) renderTreeRow(row treeRow, selected bool, idW, nameW, memoryW, cp
 
 		// Project row style
 		projectStyle := lipgloss.NewStyle().Bold(true).Foreground(accent)
+		if selected {
+			return selectedStyle.Render(projectLabel)
+		}
 		return projectStyle.Render(projectLabel)
 	}
 
@@ -244,21 +247,8 @@ func (m *model) moveCursorUpTree() {
 		m.cursor = 0
 		return
 	}
-	i := m.cursor - 1
-	for i >= 0 && m.flatList[i].isProject {
-		i--
-	}
-	if i >= 0 {
-		m.cursor = i
-	} else {
-		// clamp to first non-project if any
-		for j := 0; j < len(m.flatList); j++ {
-			if !m.flatList[j].isProject {
-				m.cursor = j
-				return
-			}
-		}
-		m.cursor = 0
+	if m.cursor > 0 {
+		m.cursor--
 	}
 }
 
@@ -267,21 +257,8 @@ func (m *model) moveCursorDownTree() {
 		m.cursor = 0
 		return
 	}
-	i := m.cursor + 1
-	for i < len(m.flatList) && m.flatList[i].isProject {
-		i++
-	}
-	if i < len(m.flatList) {
-		m.cursor = i
-	} else {
-		// clamp to last non-project if any
-		for j := len(m.flatList) - 1; j >= 0; j-- {
-			if !m.flatList[j].isProject {
-				m.cursor = j
-				return
-			}
-		}
-		m.cursor = len(m.flatList) - 1
+	if m.cursor < len(m.flatList)-1 {
+		m.cursor++
 	}
 }
 
@@ -330,3 +307,35 @@ func (m *model) refreshInfoContainer() {
 		}
 	}
 }
+
+func (m *model) getSelectedProject() (string, string) {
+	if !m.composeViewMode || len(m.flatList) == 0 {
+		return "", ""
+	}
+	if m.cursor >= len(m.flatList) {
+		return "", ""
+	}
+	row := m.flatList[m.cursor]
+	projectName := row.projectName
+	if !row.isProject {
+		if row.container != nil {
+			projectName = row.container.ComposeProject
+		}
+	}
+
+	if projectName == "" || projectName == "Standalone Containers" {
+		return "", ""
+	}
+
+	if proj, ok := m.projects[projectName]; ok {
+		return projectName, proj.WorkingDir
+	}
+	return projectName, ""
+}
+
+func (m *model) isProjectSelected() bool {
+	if !m.composeViewMode || len(m.flatList) == 0 || m.cursor >= len(m.flatList) {
+		return false
+	}
+	return m.flatList[m.cursor].isProject
+}

internal/tui/help.go

@@ -23,8 +23,13 @@ func getHelpItems(m model) []list.Item {
 		item{"R", "Restart selected container"},
 		item{"D", "Remove selected container"},
 		item{"E", fmt.Sprintf("Open interactive shell (%s)", m.settings.Shell)},
-		item{"L", "View/Toggle container logs"},
+		item{"L", "View/Toggle logs (container or compose project)"},
 		item{"I", "View/Toggle container info"},
+		item{"U", "Compose: up / start project"},
+		item{"D", "Compose: down / stop project"},
+		item{"R", "Compose: restart project"},
+		item{"P", "Compose: pause/unpause project"},
+		item{"X", "Compose: stop all containers in project"},
 		item{"C", "Toggle compose/normal view"},
 		item{"F2", "Open settings"},
 		item{"F1", "Show this help"},

internal/tui/keymap.go

@@ -9,39 +9,49 @@ import (
 // ============================================================================
 
 type keyMap struct {
-	Up       key.Binding
-	Down     key.Binding
-	Start    key.Binding
-	Stop     key.Binding
-	Restart  key.Binding
-	Logs     key.Binding
-	Info     key.Binding
-	Exec     key.Binding
-	Remove   key.Binding
-	Refresh  key.Binding
-	PageUp   key.Binding
-	NextPage key.Binding
-	PrevPage key.Binding
-	PageDown key.Binding
-	Quit     key.Binding
-	Help     key.Binding
+	Up             key.Binding
+	Down           key.Binding
+	Start          key.Binding
+	Stop           key.Binding
+	Restart        key.Binding
+	Logs           key.Binding
+	Info           key.Binding
+	Exec           key.Binding
+	Remove         key.Binding
+	Refresh        key.Binding
+	PageUp         key.Binding
+	NextPage       key.Binding
+	PrevPage       key.Binding
+	PageDown       key.Binding
+	Quit           key.Binding
+	Help           key.Binding
+	ComposeUp      key.Binding
+	ComposeDown    key.Binding
+	ComposeRestart key.Binding
+	ComposePause   key.Binding
+	ComposeStop    key.Binding
 }
 
 var Keys = keyMap{
-	Up:       key.NewBinding(key.WithKeys("up", "k")),
-	Down:     key.NewBinding(key.WithKeys("down", "j")),
-	Start:    key.NewBinding(key.WithKeys("s", "S")),
-	Stop:     key.NewBinding(key.WithKeys("x", "X")),
-	Logs:     key.NewBinding(key.WithKeys("l", "L")),
-	Info:     key.NewBinding(key.WithKeys("i", "I")),
-	Exec:     key.NewBinding(key.WithKeys("e", "E")),
-	Restart:  key.NewBinding(key.WithKeys("r", "R")),
-	Remove:   key.NewBinding(key.WithKeys("d", "D")),
-	Refresh:  key.NewBinding(key.WithKeys("f5")),
-	PageUp:   key.NewBinding(key.WithKeys("pgup", "left")),
-	NextPage: key.NewBinding(key.WithKeys("n", "pagedown")),
-	PrevPage: key.NewBinding(key.WithKeys("p", "pageup")),
-	PageDown: key.NewBinding(key.WithKeys("pgdown", "right")),
-	Quit:     key.NewBinding(key.WithKeys("q", "Q", "ctrl+c", "f10")),
-	Help:     key.NewBinding(key.WithKeys("f1", "?")),
+	Up:             key.NewBinding(key.WithKeys("up", "k")),
+	Down:           key.NewBinding(key.WithKeys("down", "j")),
+	Start:          key.NewBinding(key.WithKeys("s", "S")),
+	Stop:           key.NewBinding(key.WithKeys("x", "X")),
+	Logs:           key.NewBinding(key.WithKeys("l")),
+	Info:           key.NewBinding(key.WithKeys("i", "I")),
+	Exec:           key.NewBinding(key.WithKeys("e", "E")),
+	Restart:        key.NewBinding(key.WithKeys("r", "R")),
+	Remove:         key.NewBinding(key.WithKeys("d", "D")),
+	Refresh:        key.NewBinding(key.WithKeys("f5")),
+	PageUp:         key.NewBinding(key.WithKeys("pgup", "left")),
+	NextPage:       key.NewBinding(key.WithKeys("n", "pagedown")),
+	PrevPage:       key.NewBinding(key.WithKeys("p", "pageup")),
+	PageDown:       key.NewBinding(key.WithKeys("pgdown", "right")),
+	Quit:           key.NewBinding(key.WithKeys("q", "Q", "ctrl+c", "f10")),
+	Help:           key.NewBinding(key.WithKeys("f1", "?")),
+	ComposeUp:      key.NewBinding(key.WithKeys("u", "U")),
+	ComposeDown:    key.NewBinding(key.WithKeys("d", "D")),
+	ComposeRestart: key.NewBinding(key.WithKeys("r", "R")),
+	ComposePause:   key.NewBinding(key.WithKeys("p", "P")),
+	ComposeStop:    key.NewBinding(key.WithKeys("x", "X")),
 }