fix(terminal): scope profile config to user settings, filter shellArgs, fix PATH join

Author: edelauna

src/core/webview/__tests__/webviewMessageHandler.spec.ts

@@ -900,27 +900,14 @@ describe("webviewMessageHandler - terminalProfile", () => {
 describe("webviewMessageHandler - requestTerminalProfiles", () => {
 	beforeEach(() => {
 		vi.clearAllMocks()
-		vi.spyOn(Terminal, "resolveProfilePath").mockImplementation((profilePath) => {
-			const candidates = Array.isArray(profilePath) ? profilePath : [profilePath]
-			const value = candidates.find(
-				(candidate) =>
-					typeof candidate === "string" && candidate.trim().length > 0 && !candidate.includes("missing"),
-			)
-			return typeof value === "string" ? value.trim() : undefined
-		})
 	})
 
 	afterEach(() => {
 		vi.restoreAllMocks()
 	})
 
-	it("posts sorted path-resolvable profile names for the active platform", async () => {
-		const mockGet = vi.fn().mockReturnValue({
-			"Git Bash": { path: "C:\\Git\\bin\\bash.exe" },
-			bash: { path: "/bin/bash" },
-			PowerShell: { source: "PowerShell" }, // source-only — must be excluded
-		})
-		vi.mocked(vscode.workspace.getConfiguration).mockReturnValue({ get: mockGet } as any)
+	it("posts available profile names", async () => {
+		vi.spyOn(Terminal, "getAvailableProfileNames").mockReturnValue(["Git Bash", "bash"])
 
 		await webviewMessageHandler(mockClineProvider, { type: "requestTerminalProfiles" })
 
@@ -930,23 +917,8 @@ describe("webviewMessageHandler - requestTerminalProfiles", () => {
 		})
 	})
 
-	it("excludes source-only profiles that have no path field", async () => {
-		const mockGet = vi.fn().mockReturnValue({
-			PowerShell: { source: "PowerShell" },
-			"Windows PowerShell": { source: "PowerShell" },
-		})
-		vi.mocked(vscode.workspace.getConfiguration).mockReturnValue({ get: mockGet } as any)
-
-		await webviewMessageHandler(mockClineProvider, { type: "requestTerminalProfiles" })
-
-		expect(mockClineProvider.postMessageToWebview).toHaveBeenCalledWith({
-			type: "terminalProfiles",
-			profiles: [],
-		})
-	})
-
-	it("posts an empty array when getConfiguration throws", async () => {
-		vi.mocked(vscode.workspace.getConfiguration).mockImplementation(() => {
+	it("posts an empty array when profile discovery throws", async () => {
+		vi.spyOn(Terminal, "getAvailableProfileNames").mockImplementation(() => {
 			throw new Error("config error")
 		})
 
@@ -957,65 +929,6 @@ describe("webviewMessageHandler - requestTerminalProfiles", () => {
 			profiles: [],
 		})
 	})
-
-	it("posts an empty array when no profiles are configured", async () => {
-		const mockGet = vi.fn().mockReturnValue(undefined)
-		vi.mocked(vscode.workspace.getConfiguration).mockReturnValue({ get: mockGet } as any)
-
-		await webviewMessageHandler(mockClineProvider, { type: "requestTerminalProfiles" })
-
-		expect(mockClineProvider.postMessageToWebview).toHaveBeenCalledWith({
-			type: "terminalProfiles",
-			profiles: [],
-		})
-	})
-
-	it("excludes profiles with empty or whitespace-only path strings", async () => {
-		const mockGet = vi.fn().mockReturnValue({
-			empty: { path: "" },
-			whitespace: { path: "   " },
-			valid: { path: "/bin/bash" },
-		})
-		vi.mocked(vscode.workspace.getConfiguration).mockReturnValue({ get: mockGet } as any)
-
-		await webviewMessageHandler(mockClineProvider, { type: "requestTerminalProfiles" })
-
-		expect(mockClineProvider.postMessageToWebview).toHaveBeenCalledWith({
-			type: "terminalProfiles",
-			profiles: ["valid"],
-		})
-	})
-
-	it("excludes profiles with path arrays containing only empty or whitespace strings", async () => {
-		const mockGet = vi.fn().mockReturnValue({
-			emptyArray: { path: [] },
-			whitespaceArray: { path: ["", "   "] },
-			valid: { path: ["/bin/bash", "/usr/bin/bash"] },
-		})
-		vi.mocked(vscode.workspace.getConfiguration).mockReturnValue({ get: mockGet } as any)
-
-		await webviewMessageHandler(mockClineProvider, { type: "requestTerminalProfiles" })
-
-		expect(mockClineProvider.postMessageToWebview).toHaveBeenCalledWith({
-			type: "terminalProfiles",
-			profiles: ["valid"],
-		})
-	})
-
-	it("excludes profiles whose executable cannot be resolved", async () => {
-		const mockGet = vi.fn().mockReturnValue({
-			missing: { path: "/missing/bash" },
-			valid: { path: "/bin/bash" },
-		})
-		vi.mocked(vscode.workspace.getConfiguration).mockReturnValue({ get: mockGet } as any)
-
-		await webviewMessageHandler(mockClineProvider, { type: "requestTerminalProfiles" })
-
-		expect(mockClineProvider.postMessageToWebview).toHaveBeenCalledWith({
-			type: "terminalProfiles",
-			profiles: ["valid"],
-		})
-	})
 })
 
 describe("webviewMessageHandler - openTerminalProfilePicker", () => {

src/core/webview/webviewMessageHandler.ts

@@ -1527,32 +1527,9 @@ export const webviewMessageHandler = async (
 			// profiles (e.g. { source: "PowerShell" }) cannot be mapped to a shell
 			// binary by an extension and would silently fall back to the default.
 			try {
-				const names = new Set<string>()
-
-				const platformKey = Terminal.getPlatformProfileKey()
-				const profiles = vscode.workspace
-					.getConfiguration("terminal.integrated.profiles")
-					.get<Record<string, unknown>>(platformKey)
-
-				if (profiles && typeof profiles === "object") {
-					for (const [name, entry] of Object.entries(profiles)) {
-						if (!entry || typeof entry !== "object") {
-							continue
-						}
-
-						const { path } = entry as { path?: unknown }
-
-						// Source-only profiles and paths that cannot be found on disk or
-						// PATH are excluded because the override would fail at launch.
-						if (Terminal.resolveProfilePath(path)) {
-							names.add(name)
-						}
-					}
-				}
-
 				await provider.postMessageToWebview({
 					type: "terminalProfiles",
-					profiles: Array.from(names).sort(),
+					profiles: Terminal.getAvailableProfileNames(),
 				})
 			} catch (error) {
 				console.error("Failed to get terminal profiles:", error)

src/integrations/terminal/Terminal.ts

@@ -251,6 +251,7 @@ export class Terminal extends BaseTerminal {
 		const candidates = Array.isArray(profilePath) ? profilePath : [profilePath]
 		const pathValue = env.PATH ?? env.Path ?? env.path
 		const pathEntries = pathValue?.split(platform === "win32" ? ";" : ":") ?? []
+		const platformJoin = platform === "win32" ? path.win32.join : path.posix.join
 
 		for (const value of candidates) {
 			if (typeof value !== "string") {
@@ -280,7 +281,7 @@ export class Terminal extends BaseTerminal {
 				const directory = entry.replace(/^"(.*)"$/, "$1")
 
 				for (const extension of extensions) {
-					const resolved = path.join(directory, `${candidate}${extension}`)
+					const resolved = platformJoin(directory, `${candidate}${extension}`)
 
 					if (existsSync(resolved)) {
 						return resolved
@@ -292,6 +293,41 @@ export class Terminal extends BaseTerminal {
 		return undefined
 	}
 
+	/**
+	 * Reads profiles from trusted settings scopes only. Workspace settings are
+	 * intentionally excluded because opening a repository must not allow its
+	 * `.vscode/settings.json` to select an executable for Zoo Code to launch.
+	 */
+	public static getConfiguredProfiles(platform: NodeJS.Platform = process.platform): Record<string, unknown> {
+		const platformKey = Terminal.getPlatformProfileKey(platform)
+		const inspected = vscode.workspace
+			.getConfiguration("terminal.integrated.profiles")
+			.inspect<Record<string, unknown>>(platformKey)
+
+		return {
+			...(inspected?.defaultValue ?? {}),
+			...(inspected?.globalValue ?? {}),
+		}
+	}
+
+	public static getAvailableProfileNames(platform: NodeJS.Platform = process.platform): string[] {
+		const names = new Set<string>()
+
+		for (const [name, entry] of Object.entries(Terminal.getConfiguredProfiles(platform))) {
+			if (!entry || typeof entry !== "object") {
+				continue
+			}
+
+			const { path: profilePath } = entry as { path?: unknown }
+
+			if (Terminal.resolveProfilePath(profilePath, platform)) {
+				names.add(name)
+			}
+		}
+
+		return Array.from(names).sort()
+	}
+
 	/**
 	 * Resolves the configured VS Code terminal profile (see `terminalProfile`
 	 * setting / {@link Terminal.getTerminalProfile}) into a shell path and args by
@@ -317,9 +353,7 @@ export class Terminal extends BaseTerminal {
 
 		const platformKey = Terminal.getPlatformProfileKey(platform)
 
-		const profiles = vscode.workspace
-			.getConfiguration("terminal.integrated.profiles")
-			.get<Record<string, unknown>>(platformKey)
+		const profiles = Terminal.getConfiguredProfiles(platform)
 
 		const profile = profiles?.[profileName] as
 			| {
@@ -348,7 +382,7 @@ export class Terminal extends BaseTerminal {
 		}
 
 		const shellArgs = Array.isArray(profile.args)
-			? profile.args
+			? profile.args.filter((arg): arg is string => typeof arg === "string")
 			: typeof profile.args === "string"
 				? [profile.args]
 				: undefined

src/integrations/terminal/__tests__/TerminalProfile.spec.ts

@@ -38,11 +38,17 @@ describe("Terminal VS Code terminal profile (#277)", () => {
 		}) as any
 
 	// Helper to stub `terminal.integrated.profiles.<platform>` config reads.
-	const stubProfiles = (profilesByPlatform: Record<string, unknown>) => {
+	const stubProfiles = (
+		profilesByPlatform: Record<string, unknown>,
+		workspaceProfilesByPlatform: Record<string, unknown> = {},
+	) => {
 		getConfigurationSpy = vi.spyOn(vscode.workspace, "getConfiguration").mockImplementation((section?: string) => {
 			if (section === "terminal.integrated.profiles") {
 				return {
-					get: (platformKey: string) => profilesByPlatform[platformKey],
+					inspect: (platformKey: string) => ({
+						defaultValue: profilesByPlatform[platformKey],
+						workspaceValue: workspaceProfilesByPlatform[platformKey],
+					}),
 				} as any
 			}
 
@@ -84,6 +90,45 @@ describe("Terminal VS Code terminal profile (#277)", () => {
 		})
 	})
 
+	describe("getConfiguredProfiles / getAvailableProfileNames", () => {
+		it("merges default and global profiles while ignoring workspace profiles", () => {
+			getConfigurationSpy = vi
+				.spyOn(vscode.workspace, "getConfiguration")
+				.mockImplementation((section?: string) => {
+					if (section === "terminal.integrated.profiles") {
+						return {
+							inspect: () => ({
+								defaultValue: { bash: { path: "/bin/bash" } },
+								globalValue: { zsh: { path: "/bin/zsh" } },
+								workspaceValue: { malicious: { path: "/workspace/malicious-shell" } },
+							}),
+						} as any
+					}
+
+					return { get: (_key: string, defaultValue?: unknown) => defaultValue } as any
+				})
+
+			expect(Terminal.getConfiguredProfiles("linux")).toEqual({
+				bash: { path: "/bin/bash" },
+				zsh: { path: "/bin/zsh" },
+			})
+		})
+
+		it("returns sorted names for profiles with resolvable paths only", () => {
+			stubProfiles({
+				linux: {
+					zsh: { path: "/bin/zsh" },
+					PowerShell: { source: "PowerShell" },
+					bash: { path: "/bin/bash" },
+					missing: { path: "/missing/bash" },
+				},
+			})
+			mockedExistsSync.mockImplementation((profilePath: string) => profilePath !== "/missing/bash")
+
+			expect(Terminal.getAvailableProfileNames("linux")).toEqual(["bash", "zsh"])
+		})
+	})
+
 	describe("getProfileShell", () => {
 		it("returns undefined when no profile is configured (default behavior preserved)", () => {
 			stubProfiles({})
@@ -177,6 +222,21 @@ describe("Terminal VS Code terminal profile (#277)", () => {
 			})
 		})
 
+		it("drops non-string args array entries", () => {
+			stubProfiles({
+				linux: {
+					bash: { path: "/bin/bash", args: ["-l", 42, null] },
+				},
+			})
+
+			Terminal.setTerminalProfile("bash")
+
+			expect(Terminal.getProfileShell("linux")).toEqual({
+				shellPath: "/bin/bash",
+				shellArgs: ["-l"],
+			})
+		})
+
 		it("reads the osx profile section on darwin", () => {
 			stubProfiles({
 				osx: { zsh: { path: "/bin/zsh" } },
@@ -251,5 +311,21 @@ describe("Terminal VS Code terminal profile (#277)", () => {
 			expect(options.shellPath).toBe("/usr/bin/bash")
 			expect(options.shellArgs).toEqual(["-i"])
 		})
+
+		it("falls back to VS Code defaults when a configured profile disappears", () => {
+			stubProfiles({
+				[Terminal.getPlatformProfileKey(process.platform)]: {
+					"Git Bash": { path: "/missing/bash" },
+				},
+			})
+			mockedExistsSync.mockReturnValue(false)
+
+			Terminal.setTerminalProfile("Git Bash")
+			TerminalRegistry.createTerminal("/test/path", "vscode")
+
+			const options = createTerminalSpy.mock.calls[0][0] as vscode.TerminalOptions
+			expect(options.shellPath).toBeUndefined()
+			expect(options.shellArgs).toBeUndefined()
+		})
 	})
 })