refactor(terminal): address review feedback on inline terminal profile (Zoo-Code-Org#119)

- Route profile names through a dedicated allowlisted `requestTerminalProfiles`
  message instead of the generic `getVSCodeSetting` (which reads any key the
  webview supplies); the extension reads the profiles and returns only names.
- Preserve the profile's `env` (sanitized to string/null; null unsets a var),
  merged onto the base env in createTerminal.
- Clarify the setting copy (en + es) vs the 'Use Inline Terminal' description.
- Add tests: updateSettings->setTerminalProfile bridge, resolveWebviewView
  startup hydration, and profile env preservation/sanitization.

Author: proyectoauraorg

packages/types/src/vscode-extension-host.ts

@@ -63,6 +63,7 @@ export interface ExtensionMessage {
 		| "commandExecutionStatus"
 		| "mcpExecutionStatus"
 		| "vsCodeSetting"
+		| "terminalProfiles"
 		| "authenticatedUser"
 		| "condenseTaskContextStarted"
 		| "condenseTaskContextResponse"
@@ -153,6 +154,8 @@ export interface ExtensionMessage {
 	error?: string
 	setting?: string
 	value?: any // eslint-disable-line @typescript-eslint/no-explicit-any
+	/** Sanitized VS Code terminal profile names for the `terminalProfiles` message. */
+	profiles?: string[]
 	hasContent?: boolean
 	items?: MarketplaceItem[]
 	userInfo?: CloudUserInfo
@@ -455,6 +458,7 @@ export interface WebviewMessage {
 		| "updateVSCodeSetting"
 		| "getVSCodeSetting"
 		| "vsCodeSetting"
+		| "requestTerminalProfiles"
 		| "updateCondensingPrompt"
 		| "playSound"
 		| "playTts"

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

@@ -24,6 +24,7 @@ import { Task, TaskOptions } from "../../task/Task"
 import { safeWriteJson } from "../../../utils/safeWriteJson"
 
 import { ClineProvider } from "../ClineProvider"
+import { Terminal } from "../../../integrations/terminal/Terminal"
 import { MessageManager } from "../../message-manager"
 
 // Mock setup must come before imports.
@@ -471,6 +472,20 @@ describe("ClineProvider", () => {
 		expect(ClineProvider.getVisibleInstance()).toBe(provider)
 	})
 
+	test("resolveWebviewView hydrates the saved terminalProfile into the process-wide Terminal state", async () => {
+		const setTerminalProfileSpy = vi.spyOn(Terminal, "setTerminalProfile").mockImplementation(() => {})
+		// Seed the persisted setting so the real getState() returns it during hydration.
+		await (provider as any).contextProxy.setValue("terminalProfile", "Git Bash")
+
+		await provider.resolveWebviewView(mockWebviewView)
+		// The hydration runs in a getState().then(...) callback, so flush microtasks.
+		await new Promise((resolve) => setImmediate(resolve))
+
+		expect(setTerminalProfileSpy).toHaveBeenCalledWith("Git Bash")
+
+		setTerminalProfileSpy.mockRestore()
+	})
+
 	test("resolveWebviewView sets up webview correctly", async () => {
 		await provider.resolveWebviewView(mockWebviewView)
 

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

@@ -167,6 +167,7 @@ vi.mock("../../mentions/resolveImageMentions", () => ({
 }))
 
 import { resolveImageMentions } from "../../mentions/resolveImageMentions"
+import { Terminal } from "../../../integrations/terminal/Terminal"
 
 describe("webviewMessageHandler - requestLmStudioModels", () => {
 	beforeEach(() => {
@@ -860,6 +861,38 @@ describe("webviewMessageHandler - mcpEnabled", () => {
 	})
 })
 
+describe("webviewMessageHandler - terminalProfile", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("bridges a saved terminalProfile from updateSettings into the process-wide terminal state", async () => {
+		const setTerminalProfileSpy = vi.spyOn(Terminal, "setTerminalProfile").mockImplementation(() => {})
+
+		await webviewMessageHandler(mockClineProvider, {
+			type: "updateSettings",
+			updatedSettings: { terminalProfile: "Git Bash" },
+		})
+
+		expect(setTerminalProfileSpy).toHaveBeenCalledWith("Git Bash")
+
+		setTerminalProfileSpy.mockRestore()
+	})
+
+	it("clears the terminal profile when updateSettings sends undefined", async () => {
+		const setTerminalProfileSpy = vi.spyOn(Terminal, "setTerminalProfile").mockImplementation(() => {})
+
+		await webviewMessageHandler(mockClineProvider, {
+			type: "updateSettings",
+			updatedSettings: { terminalProfile: undefined },
+		})
+
+		expect(setTerminalProfileSpy).toHaveBeenCalledWith(undefined)
+
+		setTerminalProfileSpy.mockRestore()
+	})
+})
+
 describe("webviewMessageHandler - requestCommands", () => {
 	beforeEach(() => {
 		vi.clearAllMocks()

src/core/webview/webviewMessageHandler.ts

@@ -1512,6 +1512,38 @@ export const webviewMessageHandler = async (
 
 			break
 
+		case "requestTerminalProfiles": {
+			// Allowlisted request: read VS Code's terminal profiles server-side and
+			// return only the sanitized profile names. The terminal profile dropdown
+			// only needs names, so this avoids routing it through the generic
+			// `getVSCodeSetting` handler (which reads any key the webview supplies).
+			try {
+				const names = new Set<string>()
+
+				for (const platform of ["windows", "osx", "linux"] as const) {
+					const profiles = vscode.workspace
+						.getConfiguration("terminal.integrated.profiles")
+						.get<Record<string, unknown>>(platform)
+
+					if (profiles && typeof profiles === "object") {
+						for (const name of Object.keys(profiles)) {
+							names.add(name)
+						}
+					}
+				}
+
+				await provider.postMessageToWebview({
+					type: "terminalProfiles",
+					profiles: Array.from(names).sort(),
+				})
+			} catch (error) {
+				console.error("Failed to get terminal profiles:", error)
+				await provider.postMessageToWebview({ type: "terminalProfiles", profiles: [] })
+			}
+
+			break
+		}
+
 		case "mode":
 			await provider.handleModeSwitch(message.text as Mode)
 			break

src/integrations/terminal/Terminal.ts

@@ -24,7 +24,7 @@ export class Terminal extends BaseTerminal {
 			const options: vscode.TerminalOptions = { cwd, name: "Roo Code", iconPath, env }
 
 			// When the user has chosen a specific terminal profile, resolve it to a
-			// shell path/args so the inline terminal uses that shell (e.g. Git Bash
+			// shell path/args/env so the inline terminal uses that shell (e.g. Git Bash
 			// with a UTF-8 charset on Windows). When unset, we leave shellPath/shellArgs
 			// undefined so VS Code's default terminal behavior is preserved (#119).
 			const profileShell = Terminal.getProfileShell()
@@ -35,6 +35,12 @@ export class Terminal extends BaseTerminal {
 				if (profileShell.shellArgs) {
 					options.shellArgs = profileShell.shellArgs
 				}
+
+				// Merge the profile's own env on top of the base env so profile-specific
+				// variables (e.g. locale/PATH) are not lost. A `null` value unsets one.
+				if (profileShell.env) {
+					options.env = { ...env, ...profileShell.env }
+				}
 			}
 
 			this.terminal = vscode.window.createTerminal(options)
@@ -243,7 +249,7 @@ export class Terminal extends BaseTerminal {
 	 */
 	public static getProfileShell(
 		platform: NodeJS.Platform = process.platform,
-	): { shellPath: string; shellArgs?: string[] } | undefined {
+	): { shellPath: string; shellArgs?: string[]; env?: Record<string, string | null> } | undefined {
 		const profileName = Terminal.getTerminalProfile()
 
 		if (!profileName) {
@@ -257,7 +263,12 @@ export class Terminal extends BaseTerminal {
 			.get<Record<string, unknown>>(platformKey)
 
 		const profile = profiles?.[profileName] as
-			| { path?: string | string[]; args?: string | string[]; source?: string }
+			| {
+					path?: string | string[]
+					args?: string | string[]
+					source?: string
+					env?: Record<string, unknown>
+			  }
 			| null
 			| undefined
 
@@ -285,6 +296,26 @@ export class Terminal extends BaseTerminal {
 				? [profile.args]
 				: undefined
 
-		return { shellPath: pathValue, shellArgs }
+		// VS Code profiles may declare their own `env` (e.g. to set a UTF-8 locale or
+		// a custom PATH). Preserve it so the inline terminal doesn't lose environment
+		// the user configured on the profile. A `null` value unsets that variable.
+		// Values come from user `settings.json`, so sanitize to string/null only.
+		let env: Record<string, string | null> | undefined
+
+		if (profile.env && typeof profile.env === "object") {
+			const sanitized: Record<string, string | null> = {}
+
+			for (const [key, val] of Object.entries(profile.env)) {
+				if (typeof val === "string" || val === null) {
+					sanitized[key] = val
+				}
+			}
+
+			if (Object.keys(sanitized).length > 0) {
+				env = sanitized
+			}
+		}
+
+		return { shellPath: pathValue, shellArgs, env }
 	}
 }

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

@@ -97,6 +97,26 @@ describe("Terminal inline terminal profile (#119)", () => {
 			})
 		})
 
+		it("preserves the profile's env and sanitizes non-string/null values", () => {
+			stubProfiles({
+				linux: {
+					"Custom Bash": {
+						path: "/bin/bash",
+						env: { LANG: "en_US.UTF-8", UNSET_ME: null, BAD: 123 },
+					},
+				},
+			})
+
+			Terminal.setTerminalProfile("Custom Bash")
+
+			expect(Terminal.getProfileShell("linux")).toEqual({
+				shellPath: "/bin/bash",
+				shellArgs: undefined,
+				// `null` is preserved (unsets the var); the numeric `BAD` is dropped.
+				env: { LANG: "en_US.UTF-8", UNSET_ME: null },
+			})
+		})
+
 		it("uses the first path candidate when path is an array", () => {
 			stubProfiles({
 				windows: {

webview-ui/src/components/settings/TerminalSettings.tsx

@@ -45,14 +45,6 @@ type TerminalSettingsProps = HTMLAttributes<HTMLDivElement> & {
 // empty-string item value, so we map it to/from `undefined` in the handler.
 const DEFAULT_PROFILE_VALUE = "__default__"
 
-// VS Code stores terminal profiles per platform; we request all of them so the
-// profile dropdown works regardless of which OS the extension host runs on.
-const PROFILE_SETTING_KEYS = [
-	"terminal.integrated.profiles.windows",
-	"terminal.integrated.profiles.osx",
-	"terminal.integrated.profiles.linux",
-]
-
 export const TerminalSettings = ({
 	terminalOutputPreviewSize,
 	terminalShellIntegrationTimeout,
@@ -75,29 +67,23 @@ export const TerminalSettings = ({
 
 	useMount(() => {
 		vscode.postMessage({ type: "getVSCodeSetting", setting: "terminal.integrated.inheritEnv" })
-		PROFILE_SETTING_KEYS.forEach((setting) => vscode.postMessage({ type: "getVSCodeSetting", setting }))
+		// Request the terminal profile names through a dedicated, allowlisted message
+		// (the extension reads the profiles and returns only sanitized names).
+		vscode.postMessage({ type: "requestTerminalProfiles" })
 	})
 
 	const onMessage = useCallback((event: MessageEvent) => {
 		const message: ExtensionMessage = event.data
 
 		switch (message.type) {
 			case "vsCodeSetting":
-				switch (message.setting) {
-					case "terminal.integrated.inheritEnv":
-						setInheritEnv(message.value ?? true)
-						break
-					case "terminal.integrated.profiles.windows":
-					case "terminal.integrated.profiles.osx":
-					case "terminal.integrated.profiles.linux": {
-						const names = message.value && typeof message.value === "object" ? Object.keys(message.value) : []
-						setProfileNames((prev) => Array.from(new Set([...prev, ...names])).sort())
-						break
-					}
-					default:
-						break
+				if (message.setting === "terminal.integrated.inheritEnv") {
+					setInheritEnv(message.value ?? true)
 				}
 				break
+			case "terminalProfiles":
+				setProfileNames(message.profiles ?? [])
+				break
 			default:
 				break
 		}

webview-ui/src/components/settings/__tests__/TerminalSettings.profile.spec.tsx

@@ -33,11 +33,7 @@ vi.mock("@/components/ui", () => ({
 	SelectContent: ({ children }: any) => <div>{children}</div>,
 	SelectItem: ({ children, value }: any) => <div data-item-value={value}>{children}</div>,
 	Slider: ({ value, onValueChange }: any) => (
-		<input
-			type="range"
-			value={value?.[0] ?? 0}
-			onChange={(e) => onValueChange([parseFloat(e.target.value)])}
-		/>
+		<input type="range" value={value?.[0] ?? 0} onChange={(e) => onValueChange([parseFloat(e.target.value)])} />
 	),
 }))
 
@@ -88,13 +84,11 @@ describe("TerminalSettings inline terminal profile (#119)", () => {
 		return { setCachedStateField }
 	}
 
-	it("requests the VS Code terminal profile lists on mount", () => {
+	it("requests the terminal profile names on mount via the allowlisted message", () => {
 		setup()
 
-		const requested = postMessageMock.mock.calls.map((c) => c[0]?.setting)
-		expect(requested).toContain("terminal.integrated.profiles.windows")
-		expect(requested).toContain("terminal.integrated.profiles.osx")
-		expect(requested).toContain("terminal.integrated.profiles.linux")
+		const types = postMessageMock.mock.calls.map((c) => c[0]?.type)
+		expect(types).toContain("requestTerminalProfiles")
 	})
 
 	it("does not call setCachedStateField on init (only the Default option is shown)", () => {
@@ -104,18 +98,14 @@ describe("TerminalSettings inline terminal profile (#119)", () => {
 		expect(setCachedStateField).not.toHaveBeenCalled()
 	})
 
-	it("populates the dropdown from received profile lists and selecting one sets the profile name", () => {
+	it("populates the dropdown from the received profile names and selecting one sets the profile name", () => {
 		const { setCachedStateField } = setup()
 
-		// Simulate the extension responding with a Windows profile list.
+		// Simulate the extension responding with the sanitized profile names.
 		act(() => {
 			window.dispatchEvent(
 				new MessageEvent("message", {
-					data: {
-						type: "vsCodeSetting",
-						setting: "terminal.integrated.profiles.windows",
-						value: { "Git Bash": { path: "C:/Program Files/Git/bin/bash.exe" }, PowerShell: {} },
-					},
+					data: { type: "terminalProfiles", profiles: ["Git Bash", "PowerShell"] },
 				}),
 			)
 		})

webview-ui/src/i18n/locales/en/settings.json

@@ -805,7 +805,7 @@
 		"profile": {
 			"label": "Inline terminal profile",
 			"default": "Default (VS Code default shell)",
-			"description": "Choose which VS Code terminal profile the inline terminal uses. Pick a UTF-8 shell such as Git Bash if the default shell garbles non-ASCII output (e.g. on Windows with a GBK code page). Leave on Default to keep VS Code's default behavior."
+			"description": "Pick which shell the Inline Terminal launches, using a VS Code terminal profile's path and arguments. This only changes the shell binary — the Inline Terminal still bypasses shell integration, prompts, and plugins. Useful to choose a UTF-8 shell such as Git Bash when the default garbles non-ASCII output (e.g. on Windows with a GBK code page). Leave on Default to keep VS Code's default shell."
 		}
 	},
 	"advancedSettings": {