Fix cross-platform build: separate Unix and Windows process control

Author: andkirby

pkg/process/manager.go

@@ -10,7 +10,6 @@ import (
 	"sort"
 	"strconv"
 	"strings"
-	"syscall"
 	"time"
 
 	"github.com/devports/devpt/pkg/models"
@@ -60,10 +59,8 @@ func (m *Manager) Start(service *models.ManagedService) (int, error) {
 	cmd := exec.Command(argv[0], argv[1:]...)
 	cmd.Dir = service.CWD
 
-	// Set up process group to manage all child processes
-	cmd.SysProcAttr = &syscall.SysProcAttr{
-		Setpgid: true,
-	}
+	// Set up process group to manage all child processes (platform-specific)
+	setProcessGroup(cmd)
 
 	// Redirect output to log file
 	cmd.Stdout = logFile
@@ -88,34 +85,33 @@ func (m *Manager) Stop(pid int, timeout time.Duration) error {
 
 	// First attempt graceful termination. For non-child processes we cannot use Wait(),
 	// so we send signals and poll for liveness.
-	if err := syscall.Kill(-pid, syscall.SIGTERM); err != nil {
-		if err := syscall.Kill(pid, syscall.SIGTERM); err != nil {
-			return fmt.Errorf("failed to send SIGTERM: %w", err)
+	if err := terminateProcess(pid); err != nil {
+		if err := terminateProcessFallback(pid); err != nil {
+			return fmt.Errorf("failed to send termination signal: %w", err)
 		}
 	}
 
 	deadline := time.Now().Add(timeout)
 	for time.Now().Before(deadline) {
-		if !m.isAlive(pid) {
+		if !isProcessAlive(pid) {
 			return nil
 		}
 		time.Sleep(120 * time.Millisecond)
 	}
 
 	// Escalate to hard kill.
-	if err := syscall.Kill(-pid, syscall.SIGKILL); err != nil {
-		_ = syscall.Kill(pid, syscall.SIGKILL)
+	if err := killProcess(pid); err != nil {
+		_ = killProcessFallback(pid)
 	}
 	time.Sleep(200 * time.Millisecond)
-	if m.isAlive(pid) {
+	if isProcessAlive(pid) {
 		return ErrNeedSudo
 	}
 	return nil
 }
 
 func (m *Manager) isAlive(pid int) bool {
-	err := syscall.Kill(pid, syscall.Signal(0))
-	if err != nil {
+	if !isProcessAlive(pid) {
 		return false
 	}
 	if st, stateErr := m.processState(pid); stateErr == nil {

pkg/process/proc_unix.go

@@ -0,0 +1,34 @@
+//go:build !windows
+
+package process
+
+import (
+	"os/exec"
+	"syscall"
+)
+
+func setProcessGroup(cmd *exec.Cmd) {
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		Setpgid: true,
+	}
+}
+
+func terminateProcess(pid int) error {
+	return syscall.Kill(-pid, syscall.SIGTERM)
+}
+
+func terminateProcessFallback(pid int) error {
+	return syscall.Kill(pid, syscall.SIGTERM)
+}
+
+func killProcess(pid int) error {
+	return syscall.Kill(-pid, syscall.SIGKILL)
+}
+
+func killProcessFallback(pid int) error {
+	return syscall.Kill(pid, syscall.SIGKILL)
+}
+
+func isProcessAlive(pid int) bool {
+	return syscall.Kill(pid, syscall.Signal(0)) == nil
+}

pkg/process/proc_windows.go

@@ -0,0 +1,37 @@
+//go:build windows
+
+package process
+
+import (
+	"os/exec"
+	"strconv"
+)
+
+func setProcessGroup(cmd *exec.Cmd) {
+	// Windows: no special process group setup needed for basic use
+	// The process will be managed by its PID
+}
+
+func terminateProcess(pid int) error {
+	return terminateProcessFallback(pid)
+}
+
+func terminateProcessFallback(pid int) error {
+	// On Windows, use taskkill for graceful termination
+	return exec.Command("taskkill", "/PID", strconv.Itoa(pid)).Run()
+}
+
+func killProcess(pid int) error {
+	return killProcessFallback(pid)
+}
+
+func killProcessFallback(pid int) error {
+	// On Windows, use taskkill /F for forceful termination
+	return exec.Command("taskkill", "/F", "/PID", strconv.Itoa(pid)).Run()
+}
+
+func isProcessAlive(pid int) bool {
+	// Check if process exists using tasklist
+	err := exec.Command("tasklist", "/FI", "PID eq "+strconv.Itoa(pid)).Run()
+	return err == nil
+}