Stop untracked games by configured process name

Author: pardeike

internal/mcp/game_stop_fix_test.go

@@ -3,9 +3,12 @@ package mcp
 import (
 	"encoding/json"
 	"os"
+	"os/exec"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/pardeike/gabs/internal/config"
 	"github.com/pardeike/gabs/internal/util"
@@ -361,6 +364,69 @@ func TestGameStopFix(t *testing.T) {
 	})
 }
 
+func TestStopUntrackedGameUsesStopProcessName(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("test uses Unix process-name lookup")
+	}
+
+	tempDir, err := os.MkdirTemp("", "gabs_untracked_stop_test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	processName := "gabs-stop-fallback"
+	processPath := filepath.Join(tempDir, processName)
+	if err := os.Symlink("/bin/sleep", processPath); err != nil {
+		t.Fatalf("failed to create process-name symlink: %v", err)
+	}
+
+	cmd := exec.Command(processPath, "30")
+	if err := cmd.Start(); err != nil {
+		t.Fatalf("failed to start test process: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = cmd.Process.Kill()
+		_, _ = cmd.Process.Wait()
+	})
+
+	deadline := time.Now().Add(2 * time.Second)
+	for {
+		if out, err := exec.Command("pgrep", "-x", processName).Output(); err == nil && strings.TrimSpace(string(out)) != "" {
+			break
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("test process %q never became visible to pgrep", processName)
+		}
+		time.Sleep(25 * time.Millisecond)
+	}
+
+	logger := util.NewLogger("info")
+	server := NewServerForTesting(logger)
+	game := config.GameConfig{
+		ID:              "untracked-steam-game",
+		Name:            "Untracked Steam Game",
+		LaunchMode:      "SteamAppId",
+		Target:          "123456",
+		StopProcessName: processName,
+	}
+
+	if err := server.stopGame(game, false); err != nil {
+		t.Fatalf("expected untracked game stop to use stopProcessName, got: %v", err)
+	}
+
+	deadline = time.Now().Add(2 * time.Second)
+	for {
+		if out, err := exec.Command("pgrep", "-x", processName).Output(); err != nil || strings.TrimSpace(string(out)) == "" {
+			return
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("test process %q was still running after stopGame fallback", processName)
+		}
+		time.Sleep(25 * time.Millisecond)
+	}
+}
+
 // TestImprovedStatusReporting verifies the enhanced status descriptions
 func TestImprovedStatusReporting(t *testing.T) {
 	logger := util.NewLogger("info")

internal/mcp/stdio_server.go

@@ -2948,7 +2948,7 @@ func (s *Server) checkGameStatus(gameID string) string {
 			game := s.getGameFromController(controller)
 			if game != nil && game.StopProcessName != "" {
 				// We have tracking capability but game is not running
-				s.cleanupStoppedGame(gameID)
+				s.cleanupStoppedGameLocked(gameID)
 				return "stopped"
 			} else {
 				// We don't have tracking capability, so we can't know the real status
@@ -2966,12 +2966,12 @@ func (s *Server) checkGameStatus(gameID string) string {
 	}
 
 	// Process is dead, clean up
-	s.cleanupStoppedGame(gameID)
+	s.cleanupStoppedGameLocked(gameID)
 	return "stopped"
 }
 
-// cleanupStoppedGame centralizes the cleanup logic for stopped games
-func (s *Server) cleanupStoppedGame(gameID string) {
+// cleanupStoppedGameLocked centralizes cleanup when s.mu is already held.
+func (s *Server) cleanupStoppedGameLocked(gameID string) {
 	// Remove from games map - no need for complex cleanup in stateless approach
 	delete(s.games, gameID)
 
@@ -2984,18 +2984,16 @@ func (s *Server) cleanupStoppedGame(gameID string) {
 	s.log.Debugw("cleaned up dead game process and resources", "gameId", gameID)
 }
 
+func (s *Server) cleanupStoppedGame(gameID string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.cleanupStoppedGameLocked(gameID)
+}
+
 // startGame starts a game process using the serialized starter approach
 // This implements @pardeike's requirements for serialized, verified process starting
 func (s *Server) startGame(game config.GameConfig, gamesConfig *config.GamesConfig, backoffMin, backoffMax time.Duration) (*process.ProcessStartResult, error) {
-	// Convert GameConfig to LaunchSpec
-	launchSpec := process.LaunchSpec{
-		GameId:          game.ID,
-		Mode:            game.LaunchMode,
-		PathOrId:        game.Target,
-		Args:            game.Args,
-		WorkingDir:      game.WorkingDir,
-		StopProcessName: game.StopProcessName,
-	}
+	launchSpec := launchSpecFromGame(game)
 
 	// Create and configure controller
 	controller := process.NewController()
@@ -3304,13 +3302,24 @@ func (s *Server) exposeGABPResources(client *gabp.Client, gameID string) error {
 	return nil
 }
 
+func launchSpecFromGame(game config.GameConfig) process.LaunchSpec {
+	return process.LaunchSpec{
+		GameId:          game.ID,
+		Mode:            game.LaunchMode,
+		PathOrId:        game.Target,
+		Args:            game.Args,
+		WorkingDir:      game.WorkingDir,
+		StopProcessName: game.StopProcessName,
+	}
+}
+
 // stopGame stops a game process gracefully or by force
 func (s *Server) stopGame(game config.GameConfig, force bool) error {
 	s.mu.Lock()
 	controller, exists := s.games[game.ID]
 	if !exists {
 		s.mu.Unlock()
-		return fmt.Errorf("game %s is not running (no process tracked)", game.ID)
+		return s.stopUntrackedGame(game, force)
 	}
 
 	launchMode := controller.GetLaunchMode()
@@ -3319,6 +3328,8 @@ func (s *Server) stopGame(game config.GameConfig, force bool) error {
 	delete(s.games, game.ID)
 	s.mu.Unlock()
 
+	defer s.cleanupStoppedGame(game.ID)
+
 	// Handle different launch modes differently
 	if launchMode == "SteamAppId" || launchMode == "EpicAppId" {
 		// For Steam/Epic games, try to use stopProcessName first if available
@@ -3364,18 +3375,38 @@ func (s *Server) stopGame(game config.GameConfig, force bool) error {
 		s.log.Infow("game stopped", "gameId", game.ID, "pid", controller.GetPID())
 	}
 
-	// Cleanup GABP connections and mirrored tools when game stops
-	// This involves:
-	// 1. Disconnecting any active GABP client for this game
-	// 2. Unregistering all game-specific tools (gameId.* tools)
-	// 3. Cleaning up bridge configuration files
-	s.CleanupGABPConnection(game.ID)
-	s.CleanupGameResources(game.ID)
-	s.CleanupBridgeConfig(game.ID)
-
 	return err
 }
 
+func (s *Server) stopUntrackedGame(game config.GameConfig, force bool) error {
+	if game.StopProcessName == "" {
+		return fmt.Errorf("game %s is not running (no process tracked)", game.ID)
+	}
+
+	controller := process.NewController()
+	if err := controller.Configure(launchSpecFromGame(game)); err != nil {
+		return fmt.Errorf("failed to configure fallback stop controller for %s: %w", game.ID, err)
+	}
+
+	if !controller.IsRunning() {
+		return fmt.Errorf("game %s is not running (no process tracked; no process named %q found)", game.ID, game.StopProcessName)
+	}
+
+	var err error
+	if force {
+		err = controller.Kill()
+	} else {
+		err = controller.Stop(3 * time.Second)
+	}
+	if err != nil {
+		return err
+	}
+
+	s.log.Infow("untracked game stopped via configured process name", "gameId", game.ID, "processName", game.StopProcessName, "force", force)
+	s.cleanupStoppedGame(game.ID)
+	return nil
+}
+
 func (s *Server) ServeStdio(ctx context.Context) error {
 	return s.Serve(os.Stdin, os.Stdout)
 }