fix: normalize Windows paths in MCP variable injection (#4739)

- Use path.posix.normalize to convert backslashes to forward slashes
- Only normalize strings that contain path separators
- Ensures cross-platform compatibility and prevents JSON parsing errors
- Add comprehensive tests for Windows path normalization
- Add tests to verify non-path variables remain unchanged
- Fixes issue where ${workspaceFolder} with Windows paths caused invalid JSON

Author: daniel-lxs

src/utils/__tests__/config.spec.ts

@@ -1,7 +1,6 @@
 import { vitest, describe, it, expect, beforeEach, afterAll } from "vitest"
 import { injectEnv, injectVariables } from "../config"
 
-
 describe("injectEnv", () => {
 	const originalEnv = process.env
 
@@ -147,5 +146,109 @@ describe("injectVariables", () => {
 		expect(result).toEqual("Hello ")
 	})
 
+	it("should normalize Windows paths with backslashes to use forward slashes in JSON objects", async () => {
+		const config = {
+			command: "mcp-server",
+			args: ["${workspaceFolder}"],
+		}
+		const result = await injectVariables(config, { workspaceFolder: "C:\\Users\\project" })
+		expect(result).toEqual({
+			command: "mcp-server",
+			args: ["C:/Users/project"],
+		})
+	})
+
+	it("should handle complex Windows paths in nested objects", async () => {
+		const config = {
+			servers: {
+				git: {
+					command: "node",
+					args: ["${workspaceFolder}\\scripts\\mcp.js", "${workspaceFolder}\\data"],
+				},
+			},
+		}
+		const result = await injectVariables(config, { workspaceFolder: "C:\\Program Files\\My Project" })
+		expect(result).toEqual({
+			servers: {
+				git: {
+					command: "node",
+					args: ["C:/Program Files/My Project\\scripts\\mcp.js", "C:/Program Files/My Project\\data"],
+				},
+			},
+		})
+	})
+
+	it("should handle Windows paths when entire path is a variable", async () => {
+		const config = {
+			servers: {
+				git: {
+					command: "node",
+					args: ["${scriptPath}", "${dataPath}"],
+				},
+			},
+		}
+		const result = await injectVariables(config, {
+			scriptPath: "C:\\Program Files\\My Project\\scripts\\mcp.js",
+			dataPath: "C:\\Program Files\\My Project\\data",
+		})
+		expect(result).toEqual({
+			servers: {
+				git: {
+					command: "node",
+					args: ["C:/Program Files/My Project/scripts/mcp.js", "C:/Program Files/My Project/data"],
+				},
+			},
+		})
+	})
+
+	it("should normalize backslashes in plain string replacements", async () => {
+		const result = await injectVariables("Path: ${path}", { path: "C:\\Users\\test" })
+		expect(result).toEqual("Path: C:/Users/test")
+	})
+
+	it("should handle paths with mixed slashes", async () => {
+		const config = {
+			path: "${testPath}",
+		}
+		const result = await injectVariables(config, { testPath: "C:\\Users/test/mixed\\path" })
+		expect(result).toEqual({
+			path: "C:/Users/test/mixed/path",
+		})
+	})
+
+	it("should not affect non-path strings", async () => {
+		const config = {
+			message: "This is a string with a backslash \\ and a value: ${myValue}",
+		}
+		const result = await injectVariables(config, { myValue: "test" })
+		expect(result).toEqual({
+			message: "This is a string with a backslash \\ and a value: test",
+		})
+	})
+
+	it("should handle various non-path variables correctly", async () => {
+		const config = {
+			apiKey: "${key}",
+			url: "${endpoint}",
+			port: "${port}",
+			enabled: "${enabled}",
+			description: "${desc}",
+		}
+		const result = await injectVariables(config, {
+			key: "sk-1234567890abcdef",
+			endpoint: "https://api.example.com",
+			port: "8080",
+			enabled: "true",
+			desc: "This is a description with special chars: @#$%^&*()",
+		})
+		expect(result).toEqual({
+			apiKey: "sk-1234567890abcdef",
+			url: "https://api.example.com",
+			port: "8080",
+			enabled: "true",
+			description: "This is a description with special chars: @#$%^&*()",
+		})
+	})
+
 	// Variable maps are already tested by `injectEnv` tests above.
 })

src/utils/config.ts

@@ -10,6 +10,19 @@ export type InjectableConfigType =
 				| Array<undefined | null | boolean | number | InjectableConfigType>
 	  }
 
+/**
+ * Normalizes a path to use forward slashes consistently
+ * This ensures paths work correctly in JSON across all platforms
+ */
+function normalizePath(value: string): string {
+	// Check if the value looks like a path (contains backslashes or forward slashes)
+	if (value.includes("\\") || value.includes("/")) {
+		// Convert to forward slashes for cross-platform compatibility
+		return value.replace(/\\/g, "/")
+	}
+	return value
+}
+
 /**
  * Deeply injects environment variables into a configuration object/string/json
  *
@@ -45,14 +58,20 @@ export async function injectVariables<C extends InjectableConfigType>(
 	for (const [key, value] of Object.entries(variables)) {
 		if (value == null) continue
 
-		if (typeof value === "string") _config = _config.replace(new RegExp(`\\$\\{${key}\\}`, "g"), value)
-		else
+		if (typeof value === "string") {
+			// Normalize paths to use forward slashes for cross-platform compatibility
+			const normalizedValue = normalizePath(value)
+			_config = _config.replace(new RegExp(`\\$\\{${key}\\}`, "g"), normalizedValue)
+		} else {
 			_config = _config.replace(new RegExp(`\\$\\{${key}:([\\w]+)\\}`, "g"), (match, name) => {
 				if (value[name] == null)
 					console.warn(`[injectVariables] variable "${name}" referenced but not found in "${key}"`)
 
-				return value[name] ?? propNotFoundValue ?? match
+				const replacementValue = value[name] ?? propNotFoundValue ?? match
+				// Normalize paths if the replacement is a string
+				return typeof replacementValue === "string" ? normalizePath(replacementValue) : replacementValue
 			})
+		}
 	}
 
 	return (isObject ? JSON.parse(_config) : _config) as C extends string ? string : C