feat(terminal): allow choosing the terminal profile for inline execution (#119)

packages/types/src/global-settings.ts

@@ -176,6 +176,7 @@ export const globalSettingsSchema = z.object({
 	terminalZshOhMy: z.boolean().optional(),
 	terminalZshP10k: z.boolean().optional(),
 	terminalZdotdir: z.boolean().optional(),
+	terminalProfile: z.string().optional(),
 	execaShellPath: z.string().optional(),
 
 	diagnosticsEnabled: z.boolean().optional(),

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
@@ -276,6 +279,7 @@ export type ExtensionState = Pick<
 	| "terminalZshOhMy"
 	| "terminalZshP10k"
 	| "terminalZdotdir"
+	| "terminalProfile"
 	| "execaShellPath"
 	| "diagnosticsEnabled"
 	| "language"
@@ -454,6 +458,7 @@ export interface WebviewMessage {
 		| "updateVSCodeSetting"
 		| "getVSCodeSetting"
 		| "vsCodeSetting"
+		| "requestTerminalProfiles"
 		| "updateCondensingPrompt"
 		| "playSound"
 		| "playTts"

src/core/webview/ClineProvider.ts

@@ -746,6 +746,7 @@ export class ClineProvider
 				terminalZshP10k = false,
 				terminalPowershellCounter = false,
 				terminalZdotdir = false,
+				terminalProfile,
 				ttsEnabled,
 				ttsSpeed,
 			}) => {
@@ -757,6 +758,7 @@ export class ClineProvider
 				Terminal.setTerminalZshP10k(terminalZshP10k)
 				Terminal.setPowershellCounter(terminalPowershellCounter)
 				Terminal.setTerminalZdotdir(terminalZdotdir)
+				Terminal.setTerminalProfile(terminalProfile)
 				setTtsEnabled(ttsEnabled ?? false)
 				setTtsSpeed(ttsSpeed ?? 1)
 			},
@@ -2049,6 +2051,7 @@ export class ClineProvider
 			terminalZshOhMy,
 			terminalZshP10k,
 			terminalZdotdir,
+			terminalProfile,
 			mcpEnabled,
 			currentApiConfigName,
 			listApiConfigMeta,
@@ -2201,6 +2204,7 @@ export class ClineProvider
 			terminalZshOhMy: terminalZshOhMy ?? false,
 			terminalZshP10k: terminalZshP10k ?? false,
 			terminalZdotdir: terminalZdotdir ?? false,
+			terminalProfile,
 			mcpEnabled: mcpEnabled ?? true,
 			currentApiConfigName: currentApiConfigName ?? "default",
 			listApiConfigMeta: listApiConfigMeta ?? [],
@@ -2404,6 +2408,7 @@ export class ClineProvider
 			terminalZshOhMy: stateValues.terminalZshOhMy ?? false,
 			terminalZshP10k: stateValues.terminalZshP10k ?? false,
 			terminalZdotdir: stateValues.terminalZdotdir ?? false,
+			terminalProfile: stateValues.terminalProfile,
 			mode: stateValues.mode ?? defaultModeSlug,
 			language: stateValues.language ?? formatLanguage(vscode.env.language),
 			mcpEnabled: stateValues.mcpEnabled ?? true,

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

@@ -726,6 +726,8 @@ export const webviewMessageHandler = async (
 						if (value !== undefined) {
 							Terminal.setTerminalZdotdir(value as boolean)
 						}
+					} else if (key === "terminalProfile") {
+						Terminal.setTerminalProfile(value as string | undefined)
 					} else if (key === "execaShellPath") {
 						Terminal.setExecaShellPath(value as string | undefined)
 					} else if (key === "mcpEnabled") {
@@ -1510,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/BaseTerminal.ts

@@ -161,6 +161,7 @@ export abstract class BaseTerminal implements RooTerminal {
 	private static terminalZshOhMy: boolean = false
 	private static terminalZshP10k: boolean = false
 	private static terminalZdotdir: boolean = false
+	private static terminalProfile: string | undefined = undefined
 	private static execaShellPath: string | undefined = undefined
 
 	/**
@@ -296,6 +297,24 @@ export abstract class BaseTerminal implements RooTerminal {
 		return BaseTerminal.terminalZdotdir
 	}
 
+	/**
+	 * Sets the name of the VS Code terminal profile to use for the inline
+	 * (shell-integration) terminal. An empty/undefined value falls back to
+	 * VS Code's default terminal behavior.
+	 * @param profile The terminal profile name, or undefined for the default
+	 */
+	public static setTerminalProfile(profile: string | undefined): void {
+		BaseTerminal.terminalProfile = profile && profile.trim().length > 0 ? profile : undefined
+	}
+
+	/**
+	 * Gets the name of the VS Code terminal profile to use for the inline terminal.
+	 * @returns The terminal profile name, or undefined when the default should be used
+	 */
+	public static getTerminalProfile(): string | undefined {
+		return BaseTerminal.terminalProfile
+	}
+
 	public static setExecaShellPath(shellPath: string | undefined): void {
 		BaseTerminal.execaShellPath = shellPath
 	}

src/integrations/terminal/Terminal.ts

@@ -1,3 +1,5 @@
+import { existsSync } from "fs"
+
 import * as vscode from "vscode"
 import pWaitFor from "p-wait-for"
 
@@ -17,7 +19,34 @@ export class Terminal extends BaseTerminal {
 
 		const env = Terminal.getEnv()
 		const iconPath = new vscode.ThemeIcon("rocket")
-		this.terminal = terminal ?? vscode.window.createTerminal({ cwd, name: "Roo Code", iconPath, env })
+
+		if (terminal) {
+			this.terminal = terminal
+		} else {
+			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/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()
+
+			if (profileShell?.shellPath) {
+				options.shellPath = profileShell.shellPath
+
+				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)
+		}
 
 		if (Terminal.getTerminalZdotdir()) {
 			ShellIntegrationManager.terminalTmpDirs.set(id, env.ZDOTDIR)
@@ -191,4 +220,107 @@ export class Terminal extends BaseTerminal {
 
 		return env
 	}
+
+	/**
+	 * Returns the VS Code config section key (`windows`/`osx`/`linux`) used for
+	 * platform-specific terminal profiles.
+	 */
+	private static getPlatformProfileKey(platform: NodeJS.Platform = process.platform): "windows" | "osx" | "linux" {
+		if (platform === "win32") {
+			return "windows"
+		}
+
+		if (platform === "darwin") {
+			return "osx"
+		}
+
+		return "linux"
+	}
+
+	/**
+	 * Resolves the configured inline terminal profile (see `terminalProfile`
+	 * setting / {@link Terminal.getTerminalProfile}) into a shell path and args by
+	 * reading VS Code's `terminal.integrated.profiles.<platform>` configuration.
+	 *
+	 * This reuses VS Code's terminal profile concept so users can pick, for
+	 * example, a Git Bash profile (UTF-8) instead of the default cmd/PowerShell
+	 * (which may use a non-UTF-8 charset such as GBK) on Windows (#119).
+	 *
+	 * @returns The resolved shell path/args, or undefined when no profile is
+	 *   configured or the profile cannot be resolved (default behavior).
+	 */
+	public static getProfileShell(
+		platform: NodeJS.Platform = process.platform,
+	): { shellPath: string; shellArgs?: string[]; env?: Record<string, string | null> } | undefined {
+		const profileName = Terminal.getTerminalProfile()
+
+		if (!profileName) {
+			return undefined
+		}
+
+		const platformKey = Terminal.getPlatformProfileKey(platform)
+
+		const profiles = vscode.workspace
+			.getConfiguration("terminal.integrated.profiles")
+			.get<Record<string, unknown>>(platformKey)
+
+		const profile = profiles?.[profileName] as
+			| {
+					path?: string | string[]
+					args?: string | string[]
+					source?: string
+					env?: Record<string, unknown>
+			  }
+			| null
+			| undefined
+
+		if (!profile) {
+			console.warn(`[Terminal] Configured terminal profile "${profileName}" not found for ${platformKey}.`)
+			return undefined
+		}
+
+		// A `path` may be a single string or an array of candidate paths. VS Code
+		// picks the first candidate that exists on disk, so mirror that: prefer the
+		// first existing path, otherwise fall back to the first non-empty candidate.
+		const candidates = Array.isArray(profile.path) ? profile.path : [profile.path]
+		const nonEmpty = candidates.filter((p): p is string => typeof p === "string" && p.length > 0)
+		const pathValue = nonEmpty.find((p) => existsSync(p)) ?? nonEmpty[0]
+
+		if (!pathValue) {
+			// Profiles defined only by `source` (e.g. "PowerShell") can't be mapped to
+			// a shell path here, so we fall back to the default terminal.
+			console.warn(
+				`[Terminal] Terminal profile "${profileName}" has no resolvable "path"; using default terminal.`,
+			)
+			return undefined
+		}
+
+		const shellArgs = Array.isArray(profile.args)
+			? profile.args
+			: typeof profile.args === "string"
+				? [profile.args]
+				: undefined
+
+		// 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 }
+	}
 }