fix(isolation): detect the runtime of Windows launchers with an .exe/.cmd suffix (#1778)

## Problem

`IsolationManager.DetectRuntimeType` switches on
`filepath.Base(command)` exactly. On Windows the launchers carry an
executable suffix: `uvx.exe`, `npx.cmd`, `npm.cmd`, `yarn.cmd`,
`pip.exe`, `go.exe`. Configs often name them that way, either by full
path or because `npx.cmd` is what resolves. None of those match a case,
so they fall to the `binary` default. `python.exe` and `node.exe` only
work through the substring fallback.

With Docker isolation enabled, `binary` selects the generic image, and
`TransformCommandForContainer` passes the original command through. The
container is asked to run `npx.cmd` (or `uvx.exe`) inside a Linux image
where it doesn't exist, so the server never starts.

## Fix

Lowercase the base name and strip a `.exe`, `.cmd` or `.bat` suffix
before the switch, so `npx.cmd` maps to `npx`, `uvx.exe` to `uvx`, and
so on. Then the right image and in-container command are used.
Unsuffixed names are unchanged.

## Test

`TestDetectRuntimeType_WindowsExecutableSuffix` covers `uvx.exe`,
`npx.cmd`, `NPX.CMD`, `npm.cmd`, `yarn.cmd`, `pip.exe` and `go.exe`,
plus `uvx` and an unknown `my-tool`. On main all seven suffixed names
return `binary`; with this change they map to their runtime. `go test
-count=1 ./internal/upstream/core/` passes.

Made with [Cursor](https://cursor.com)

---------

Co-authored-by: Algis Dumbris <a.dumbris@gmail.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: 3 people

internal/diagnostics/remediation.go

@@ -68,7 +68,14 @@ func RuntimeAwareRemediation(code Code, hints ClassifierHints) string {
 // fall back to the base command name so the message still names something
 // concrete rather than a generic "interpreter".
 func detectDockerRuntimeType(command string) string {
-	cmdName := filepath.Base(command)
+	base := filepath.Base(command)
+	// Mirror core.DetectRuntimeType: case-insensitive, with a Windows
+	// launcher suffix (.exe/.cmd/.bat) stripped.
+	cmdName := strings.ToLower(base)
+	switch filepath.Ext(cmdName) {
+	case ".exe", ".cmd", ".bat":
+		cmdName = strings.TrimSuffix(cmdName, filepath.Ext(cmdName))
+	}
 	switch cmdName {
 	case "python", "python3", "python3.11", "python3.12", "python3.13":
 		return "python"
@@ -101,14 +108,13 @@ func detectDockerRuntimeType(command string) string {
 	case "composer":
 		return "composer"
 	default:
-		lower := strings.ToLower(cmdName)
-		if strings.Contains(lower, "python") {
+		if strings.Contains(cmdName, "python") {
 			return "python"
 		}
-		if strings.Contains(lower, "node") {
+		if strings.Contains(cmdName, "node") {
 			return "node"
 		}
-		return cmdName
+		return base
 	}
 }
 

internal/diagnostics/remediation_runtime_gate_test.go

@@ -72,3 +72,27 @@ func TestMirroredGitRuntimeGateMatchesConfig(t *testing.T) {
 		}
 	}
 }
+
+// The mirror has to normalise a Windows launcher name the way
+// core.DetectRuntimeType does, or a uvx.exe/npx.cmd server gets remediation
+// for a "uvx.exe" runtime and no git-dependency hint while the spawn path uses
+// the uvx image and the git-capable substitute.
+func TestDetectDockerRuntimeTypeWindowsLauncherSuffix(t *testing.T) {
+	cases := map[string]string{
+		"uvx.exe":     "uvx",
+		"npx.cmd":     "npx",
+		"Uvx.EXE":     "uvx",
+		"npm.bat":     "npm",
+		"my-tool.exe": "my-tool.exe",
+	}
+	for command, want := range cases {
+		if got := detectDockerRuntimeType(command); got != want {
+			t.Errorf("detectDockerRuntimeType(%q) = %q, want %q", command, got, want)
+		}
+	}
+
+	hints := ClassifierHints{DockerCommand: "uvx.exe", DockerArgs: []string{"git+https://x"}}
+	if !hintsHaveGitDependency(hints) {
+		t.Error("hintsHaveGitDependency(uvx.exe, git+) = false, want true")
+	}
+}

internal/upstream/core/isolation.go

@@ -220,8 +220,13 @@ func (im *IsolationManager) warnPerServerIgnoredOnce(serverName string) {
 
 // DetectRuntimeType detects the runtime type based on the command
 func (im *IsolationManager) DetectRuntimeType(command string) string {
-	// Extract just the command name without path
-	cmdName := filepath.Base(command)
+	// Extract just the command name without path or a Windows executable
+	// suffix (uvx.exe, npx.cmd), compared case-insensitively as Windows does.
+	cmdName := strings.ToLower(filepath.Base(command))
+	switch filepath.Ext(cmdName) {
+	case ".exe", ".cmd", ".bat":
+		cmdName = strings.TrimSuffix(cmdName, filepath.Ext(cmdName))
+	}
 
 	// Handle common runtime commands
 	switch cmdName {

internal/upstream/core/isolation_windows_ext_test.go

@@ -0,0 +1,30 @@
+package core
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/smart-mcp-proxy/mcpproxy-go/internal/config"
+)
+
+// Windows configs name launchers with their executable suffix (uvx.exe,
+// npx.cmd). Treating those as an unknown "binary" picks the generic image and
+// runs "npx.cmd" inside a Linux container, where it does not exist.
+func TestDetectRuntimeType_WindowsExecutableSuffix(t *testing.T) {
+	im := NewIsolationManager(config.DefaultDockerIsolationConfig())
+	cases := map[string]string{
+		"uvx.exe":  cmdUvx,
+		"npx.cmd":  cmdNpx,
+		"NPX.CMD":  cmdNpx,
+		"npm.cmd":  cmdNpm,
+		"yarn.cmd": cmdYarn,
+		"pip.exe":  cmdPip,
+		"go.exe":   cmdGo,
+		"uvx":      cmdUvx,
+		"my-tool":  "binary",
+	}
+	for cmd, want := range cases {
+		assert.Equal(t, want, im.DetectRuntimeType(cmd), cmd)
+	}
+}