feat: add CPU and memory metrics display for services

- Show CPU% and RAM usage for each running service in status bar
- Display totals (Σ) in "All" tab
- Add GetProcessMetrics using ps command (macOS/Linux compatible)
- Include metrics in daemon protocol and MCP status output
- Update golangci-lint config to v2 format

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: productdevbook

.golangci.yml

@@ -1,15 +1,19 @@
+version: "2"
+
 run:
   timeout: 5m
   modules-download-mode: readonly
 
 linters:
   enable:
     - errcheck
-    - gosimple
     - govet
     - ineffassign
     - staticcheck
     - unused
+
+formatters:
+  enable:
     - gofmt
     - goimports
 
@@ -23,11 +27,13 @@ linters-settings:
     disable:
       - fieldalignment
 
+formatters-settings:
   gofmt:
     simplify: true
 
   goimports:
-    local-prefixes: devir
+    local-prefixes:
+      - devir
 
 issues:
   exclude-use-default: false

internal/daemon/daemon.go

@@ -362,9 +362,16 @@ func (d *Daemon) handleStatus(c *clientConn) {
 				message = ds.Message
 			}
 
+			// Capture PID for metrics collection
+			var pid int
+			running := state.Running
+			if running && state.Cmd != nil && state.Cmd.Process != nil {
+				pid = state.Cmd.Process.Pid
+			}
+
 			s := ServiceStatus{
 				Name:     name,
-				Running:  state.Running,
+				Running:  running,
 				Port:     state.Service.Port,
 				Color:    color,
 				Icon:     icon,
@@ -381,6 +388,15 @@ func (d *Daemon) handleStatus(c *clientConn) {
 				s.NextRun = state.NextRun.Format(time.RFC3339)
 			}
 			state.Mu.Unlock()
+
+			// Collect metrics after releasing lock
+			if pid > 0 {
+				if metrics, err := runner.GetProcessMetrics(pid); err == nil {
+					s.CPU = metrics.CPU
+					s.Memory = metrics.Memory
+				}
+			}
+
 			statuses = append(statuses, s)
 		}
 	}

internal/daemon/protocol.go

@@ -18,16 +18,16 @@ const (
 	MsgKillPorts  = "kill_ports"
 
 	// Daemon → Client
-	MsgStarted         = "started"
-	MsgStopped         = "stopped"
-	MsgRestarted       = "restarted"
-	MsgStatusResponse  = "status_response"
-	MsgLogsResponse    = "logs_response"
-	MsgLogsCleared     = "logs_cleared"
-	MsgPortsResponse   = "ports_response"
-	MsgKillResponse    = "kill_response"
-	MsgLogEntry        = "log_entry" // Broadcast to all clients
-	MsgError           = "error"
+	MsgStarted        = "started"
+	MsgStopped        = "stopped"
+	MsgRestarted      = "restarted"
+	MsgStatusResponse = "status_response"
+	MsgLogsResponse   = "logs_response"
+	MsgLogsCleared    = "logs_cleared"
+	MsgPortsResponse  = "ports_response"
+	MsgKillResponse   = "kill_response"
+	MsgLogEntry       = "log_entry" // Broadcast to all clients
+	MsgError          = "error"
 )
 
 // Message is the wire format for daemon communication
@@ -98,18 +98,20 @@ type RestartedResponse struct {
 
 // ServiceStatus represents a service's current state
 type ServiceStatus struct {
-	Name     string `json:"name"`
-	Running  bool   `json:"running"`
-	Port     int    `json:"port"`
-	Color    string `json:"color"`
-	Icon     string `json:"icon"`     // custom icon/emoji
-	Type     string `json:"type"`     // service, oneshot, interval, http
-	Status   string `json:"status"`   // running, completed, failed, waiting, stopped
-	Message  string `json:"message"`  // dynamic status message
-	LastRun  string `json:"lastRun"`  // ISO timestamp
-	NextRun  string `json:"nextRun"`  // ISO timestamp (for interval)
-	ExitCode int    `json:"exitCode"` // last exit code
-	RunCount int    `json:"runCount"` // number of runs
+	Name     string  `json:"name"`
+	Running  bool    `json:"running"`
+	Port     int     `json:"port"`
+	Color    string  `json:"color"`
+	Icon     string  `json:"icon"`     // custom icon/emoji
+	Type     string  `json:"type"`     // service, oneshot, interval, http
+	Status   string  `json:"status"`   // running, completed, failed, waiting, stopped
+	Message  string  `json:"message"`  // dynamic status message
+	LastRun  string  `json:"lastRun"`  // ISO timestamp
+	NextRun  string  `json:"nextRun"`  // ISO timestamp (for interval)
+	ExitCode int     `json:"exitCode"` // last exit code
+	RunCount int     `json:"runCount"` // number of runs
+	CPU      float64 `json:"cpu"`      // CPU percentage
+	Memory   uint64  `json:"memory"`   // Memory in bytes (RSS)
 }
 
 // StatusResponse contains all service statuses

internal/mcp/mcp.go

@@ -139,15 +139,17 @@ type StopOutput struct {
 }
 
 type ServiceStatus struct {
-	Name     string `json:"name"`
-	Running  bool   `json:"running"`
-	Port     int    `json:"port"`
-	Type     string `json:"type"`     // service, oneshot, interval, http
-	Status   string `json:"status"`   // running, completed, failed, waiting, stopped
-	LastRun  string `json:"lastRun"`  // ISO timestamp
-	NextRun  string `json:"nextRun"`  // ISO timestamp (for interval)
-	ExitCode int    `json:"exitCode"` // last exit code
-	RunCount int    `json:"runCount"` // number of runs
+	Name     string  `json:"name"`
+	Running  bool    `json:"running"`
+	Port     int     `json:"port"`
+	Type     string  `json:"type"`     // service, oneshot, interval, http
+	Status   string  `json:"status"`   // running, completed, failed, waiting, stopped
+	LastRun  string  `json:"lastRun"`  // ISO timestamp
+	NextRun  string  `json:"nextRun"`  // ISO timestamp (for interval)
+	ExitCode int     `json:"exitCode"` // last exit code
+	RunCount int     `json:"runCount"` // number of runs
+	CPU      float64 `json:"cpu"`      // CPU percentage
+	Memory   uint64  `json:"memory"`   // Memory in bytes (RSS)
 }
 
 type StatusOutput struct {
@@ -270,6 +272,8 @@ func (m *Server) handleStatus(ctx context.Context, req *mcp.CallToolRequest, inp
 			NextRun:  s.NextRun,
 			ExitCode: s.ExitCode,
 			RunCount: s.RunCount,
+			CPU:      s.CPU,
+			Memory:   s.Memory,
 		})
 	}
 

internal/runner/process_unix.go

@@ -5,6 +5,7 @@ package runner
 import (
 	"fmt"
 	"os/exec"
+	"strconv"
 	"strings"
 	"syscall"
 )
@@ -56,3 +57,58 @@ func IsPortInUse(port int) bool {
 	pid, _ := GetPortPID(port)
 	return pid > 0
 }
+
+// ProcessMetrics holds CPU and memory metrics for a process
+type ProcessMetrics struct {
+	CPU    float64 // CPU percentage
+	Memory uint64  // Memory in bytes (RSS)
+}
+
+// GetProcessMetrics gets CPU and memory usage for a process and its children
+// Uses ps command which works on both macOS and Linux
+func GetProcessMetrics(pid int) (ProcessMetrics, error) {
+	if pid <= 0 {
+		return ProcessMetrics{}, nil
+	}
+
+	// Get all child PIDs using pgrep
+	pids := []int{pid}
+	pgrepCmd := exec.Command("pgrep", "-P", strconv.Itoa(pid))
+	if output, err := pgrepCmd.Output(); err == nil {
+		for _, line := range strings.Split(strings.TrimSpace(string(output)), "\n") {
+			if line != "" {
+				if childPid, err := strconv.Atoi(line); err == nil {
+					pids = append(pids, childPid)
+				}
+			}
+		}
+	}
+
+	var totalCPU float64
+	var totalMemory uint64
+
+	for _, p := range pids {
+		// ps -o %cpu=,rss= -p <pid>
+		// %cpu = CPU percentage, rss = resident set size in KB
+		cmd := exec.Command("ps", "-o", "%cpu=,rss=", "-p", strconv.Itoa(p))
+		output, err := cmd.Output()
+		if err != nil {
+			continue // Process might have exited
+		}
+
+		fields := strings.Fields(strings.TrimSpace(string(output)))
+		if len(fields) >= 2 {
+			if cpu, err := strconv.ParseFloat(fields[0], 64); err == nil {
+				totalCPU += cpu
+			}
+			if rssKB, err := strconv.ParseUint(fields[1], 10, 64); err == nil {
+				totalMemory += rssKB * 1024 // Convert KB to bytes
+			}
+		}
+	}
+
+	return ProcessMetrics{
+		CPU:    totalCPU,
+		Memory: totalMemory,
+	}, nil
+}

internal/runner/process_windows.go

@@ -68,3 +68,16 @@ func IsPortInUse(port int) bool {
 	pid, _ := GetPortPID(port)
 	return pid > 0
 }
+
+// ProcessMetrics holds CPU and memory metrics for a process
+type ProcessMetrics struct {
+	CPU    float64 // CPU percentage
+	Memory uint64  // Memory in bytes (RSS)
+}
+
+// GetProcessMetrics gets CPU and memory usage for a process
+// TODO: Implement Windows-specific metrics using Windows API
+func GetProcessMetrics(pid int) (ProcessMetrics, error) {
+	// Windows implementation not yet available
+	return ProcessMetrics{}, nil
+}

internal/runner/runner.go

@@ -769,6 +769,16 @@ func (r *Runner) GetServices() map[string]types.ServiceInfo {
 			message = ds.Message
 		}
 
+		// Collect CPU and memory metrics for running services
+		var cpu float64
+		var memory uint64
+		if state.Running && state.Cmd != nil && state.Cmd.Process != nil {
+			if metrics, err := GetProcessMetrics(state.Cmd.Process.Pid); err == nil {
+				cpu = metrics.CPU
+				memory = metrics.Memory
+			}
+		}
+
 		result[name] = types.ServiceInfo{
 			Name:     name,
 			Color:    color,
@@ -782,6 +792,8 @@ func (r *Runner) GetServices() map[string]types.ServiceInfo {
 			ExitCode: state.ExitCode,
 			RunCount: state.RunCount,
 			Message:  message,
+			CPU:      cpu,
+			Memory:   memory,
 		}
 		state.Mu.Unlock()
 	}

internal/tui/model.go

@@ -388,6 +388,28 @@ func (m *Model) GetFullServiceStatus(name string) (running bool, port int, color
 	return false, 0, "white", "", "service", "stopped"
 }
 
+// GetServiceMetrics returns CPU and memory metrics for a service
+func (m *Model) GetServiceMetrics(name string) (cpu float64, memory uint64) {
+	if m.clientMode {
+		if s, ok := m.statuses[name]; ok {
+			return s.CPU, s.Memory
+		}
+		return 0, 0
+	}
+
+	// Legacy mode - get metrics directly from the process
+	if state, ok := m.Runner.Services[name]; ok {
+		state.Mu.Lock()
+		defer state.Mu.Unlock()
+		if state.Running && state.Cmd != nil && state.Cmd.Process != nil {
+			if metrics, err := runner.GetProcessMetrics(state.Cmd.Process.Pid); err == nil {
+				return metrics.CPU, metrics.Memory
+			}
+		}
+	}
+	return 0, 0
+}
+
 func containsIgnoreCase(s, substr string) bool {
 	return len(s) >= len(substr) &&
 		(s == substr ||

internal/tui/view.go

@@ -119,9 +119,11 @@ func (m Model) renderLogs() string {
 
 func (m Model) renderStatusBar() string {
 	var parts []string
+	var totalCPU float64
+	var totalMemory uint64
 
 	for _, name := range m.services {
-		_, port, color, icon, svcType, status := m.GetFullServiceStatus(name)
+		running, port, color, icon, svcType, status := m.GetFullServiceStatus(name)
 
 		statusStr := getStyledStatus(status)
 
@@ -147,18 +149,54 @@ func (m Model) renderStatusBar() string {
 			}
 		}
 
-		parts = append(parts, fmt.Sprintf("%s %s%s", statusStr, serviceStyle.Render(displayName), portStr))
+		// Get metrics for running services
+		metricsStr := ""
+		if running {
+			cpu, memory := m.GetServiceMetrics(name)
+			totalCPU += cpu
+			totalMemory += memory
+			if cpu > 0 || memory > 0 {
+				metricsStr = fmt.Sprintf(" %s %s", formatCPU(cpu), formatMemory(memory))
+			}
+		}
+
+		parts = append(parts, fmt.Sprintf("%s %s%s%s", statusStr, serviceStyle.Render(displayName), portStr, metricsStr))
 	}
 
 	statusContent := strings.Join(parts, "  │  ")
 
+	// Add totals when on "All" tab and there are running services
+	if m.activeTab == -1 && (totalCPU > 0 || totalMemory > 0) {
+		statusContent = fmt.Sprintf("Σ %s %s  │  ", formatCPU(totalCPU), formatMemory(totalMemory)) + statusContent
+	}
+
 	if m.searchQuery != "" {
 		statusContent += fmt.Sprintf("  │  Filter: %s", m.searchQuery)
 	}
 
 	return StatusBarStyle.Width(m.width).Render(statusContent)
 }
 
+// formatCPU formats CPU percentage
+func formatCPU(cpu float64) string {
+	if cpu < 0.1 {
+		return "0%"
+	}
+	return fmt.Sprintf("%.0f%%", cpu)
+}
+
+// formatMemory formats memory in human-readable format
+func formatMemory(bytes uint64) string {
+	if bytes == 0 {
+		return "0MB"
+	}
+	mb := float64(bytes) / (1024 * 1024)
+	if mb >= 1024 {
+		return fmt.Sprintf("%.1fGB", mb/1024)
+	}
+	return fmt.Sprintf("%.0fMB", mb)
+}
+
 // getStyledStatus returns styled status symbol
 func getStyledStatus(status string) string {
 	switch status {

internal/types/types.go

@@ -51,4 +51,6 @@ type ServiceInfo struct {
 	ExitCode int           // last exit code
 	RunCount int           // number of runs (for interval)
 	Message  string        // dynamic status message from .devir-status
+	CPU      float64       // CPU percentage (0-100 per core, can exceed 100 with multiple cores)
+	Memory   uint64        // Memory in bytes (RSS)
 }