headlesscode 1.0.2

package/src/vendor/zoo-code/src/utils/shell.ts

@@ -0,0 +1,376 @@
+import * as vscode from "../../shim/vscode"
+import { existsSync } from "fs"
+import { userInfo } from "os"
+import * as path from "path"
+
+// Security: Allowlist of approved shell executables to prevent arbitrary command execution
+const SHELL_ALLOWLIST = new Set<string>([
+	// Windows PowerShell variants
+	"C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
+	"C:\\Program Files\\PowerShell\\7\\pwsh.exe",
+	"C:\\Program Files\\PowerShell\\6\\pwsh.exe",
+	"C:\\Program Files\\PowerShell\\5\\pwsh.exe",
+
+	// Windows Command Prompt
+	"C:\\Windows\\System32\\cmd.exe",
+
+	// Windows WSL
+	"C:\\Windows\\System32\\wsl.exe",
+
+	// Git Bash on Windows
+	"C:\\Program Files\\Git\\bin\\bash.exe",
+	"C:\\Program Files\\Git\\usr\\bin\\bash.exe",
+	"C:\\Program Files (x86)\\Git\\bin\\bash.exe",
+	"C:\\Program Files (x86)\\Git\\usr\\bin\\bash.exe",
+
+	// MSYS2/MinGW/Cygwin on Windows
+	"C:\\msys64\\usr\\bin\\bash.exe",
+	"C:\\msys32\\usr\\bin\\bash.exe",
+	"C:\\MinGW\\msys\\1.0\\bin\\bash.exe",
+	"C:\\cygwin64\\bin\\bash.exe",
+	"C:\\cygwin\\bin\\bash.exe",
+
+	// Unix/Linux/macOS - Bourne-compatible shells
+	"/bin/sh",
+	"/usr/bin/sh",
+	"/bin/bash",
+	"/usr/bin/bash",
+	"/usr/local/bin/bash",
+	"/opt/homebrew/bin/bash",
+	"/opt/local/bin/bash",
+
+	// Z Shell
+	"/bin/zsh",
+	"/usr/bin/zsh",
+	"/usr/local/bin/zsh",
+	"/opt/homebrew/bin/zsh",
+	"/opt/local/bin/zsh",
+
+	// Dash
+	"/bin/dash",
+	"/usr/bin/dash",
+
+	// Ash
+	"/bin/ash",
+	"/usr/bin/ash",
+
+	// C Shells
+	"/bin/csh",
+	"/usr/bin/csh",
+	"/bin/tcsh",
+	"/usr/bin/tcsh",
+	"/usr/local/bin/tcsh",
+
+	// Korn Shells
+	"/bin/ksh",
+	"/usr/bin/ksh",
+	"/bin/ksh93",
+	"/usr/bin/ksh93",
+	"/bin/mksh",
+	"/usr/bin/mksh",
+	"/bin/pdksh",
+	"/usr/bin/pdksh",
+
+	// Fish Shell
+	"/usr/bin/fish",
+	"/usr/local/bin/fish",
+	"/opt/homebrew/bin/fish",
+	"/opt/local/bin/fish",
+
+	// Modern shells
+	"/usr/bin/elvish",
+	"/usr/local/bin/elvish",
+	"/usr/bin/xonsh",
+	"/usr/local/bin/xonsh",
+	"/usr/bin/nu",
+	"/usr/local/bin/nu",
+	"/usr/bin/nushell",
+	"/usr/local/bin/nushell",
+	"/usr/bin/ion",
+	"/usr/local/bin/ion",
+
+	// BusyBox
+	"/bin/busybox",
+	"/usr/bin/busybox",
+])
+
+const SHELL_PATHS = {
+	// Windows paths
+	POWERSHELL_7: "C:\\Program Files\\PowerShell\\7\\pwsh.exe",
+	POWERSHELL_LEGACY: "C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
+	CMD: "C:\\Windows\\System32\\cmd.exe",
+	WSL_BASH: "/bin/bash",
+	// Unix paths
+	MAC_DEFAULT: "/bin/zsh",
+	LINUX_DEFAULT: "/bin/bash",
+	CSH: "/bin/csh",
+	BASH: "/bin/bash",
+	KSH: "/bin/ksh",
+	SH: "/bin/sh",
+	ZSH: "/bin/zsh",
+	DASH: "/bin/dash",
+	TCSH: "/bin/tcsh",
+	FALLBACK: "/bin/sh",
+} as const
+
+interface MacTerminalProfile {
+	path?: string | string[]
+}
+
+type MacTerminalProfiles = Record<string, MacTerminalProfile>
+
+interface WindowsTerminalProfile {
+	path?: string | string[]
+	source?: "PowerShell" | "WSL"
+}
+
+type WindowsTerminalProfiles = Record<string, WindowsTerminalProfile>
+
+interface LinuxTerminalProfile {
+	path?: string | string[]
+}
+
+type LinuxTerminalProfiles = Record<string, LinuxTerminalProfile>
+
+// -----------------------------------------------------
+// 1) VS Code Terminal Configuration Helpers
+// -----------------------------------------------------
+
+type PlatformProfilesMap = {
+	windows: WindowsTerminalProfiles
+	osx: MacTerminalProfiles
+	linux: LinuxTerminalProfiles
+}
+
+/**
+ * Reads the VS Code terminal profile configuration for the given platform.
+ *
+ * The key must be one of `"windows"`, `"osx"`, or `"linux"` — the exact strings
+ * VS Code uses in `terminal.integrated.defaultProfile.<key>` and
+ * `terminal.integrated.profiles.<key>`. Passing any other value is a compile-time
+ * error, which prevents silent mismatches such as `"darwin"` returning empty config.
+ *
+ * The return type (`defaultProfileName` and `profiles`) is inferred from `K` via
+ * `PlatformProfilesMap`, so callers don't need an explicit type parameter.
+ *
+ * Returns `{ defaultProfileName: null, profiles: {} }` on any VS Code API error.
+ */
+function getTerminalConfig<K extends keyof PlatformProfilesMap>(
+	platformKey: K,
+): { defaultProfileName: string | null; profiles: PlatformProfilesMap[K] } {
+	try {
+		const config = vscode.workspace.getConfiguration("terminal.integrated")
+		const rawProfileName = config.get<string>(`defaultProfile.${platformKey}`)
+		const defaultProfileName = typeof rawProfileName === "string" ? rawProfileName : null
+		const profiles = config.get<PlatformProfilesMap[K]>(`profiles.${platformKey}`) ?? ({} as PlatformProfilesMap[K])
+		return { defaultProfileName, profiles }
+	} catch {
+		return { defaultProfileName: null, profiles: {} as PlatformProfilesMap[K] }
+	}
+}
+
+// -----------------------------------------------------
+// 2) Platform-Specific VS Code Shell Retrieval
+// -----------------------------------------------------
+
+/**
+ * Normalizes a path that can be either a string or an array of strings.
+ * If it's an array, returns the first element. Otherwise returns the string.
+ */
+function normalizeShellPath(path: string | string[] | undefined): string | null {
+	if (!path) return null
+	if (Array.isArray(path)) {
+		return path.length > 0 ? path[0] : null
+	}
+	return path
+}
+
+/** Attempts to retrieve a shell path from VS Code config on Windows. */
+function getWindowsShellFromVSCode(): string | null {
+	const { defaultProfileName, profiles } = getTerminalConfig("windows")
+	if (!defaultProfileName) {
+		// No explicit Windows terminal profile is configured. VS Code auto-detects
+		// the default on modern Windows and prefers PowerShell 7 (pwsh.exe) when it
+		// is installed, otherwise the always-present Windows PowerShell 5.1. Mirror
+		// that here so the system prompt advertises the real shell instead of falling
+		// through to COMSPEC (cmd.exe). See issue #82.
+		return existsSync(SHELL_PATHS.POWERSHELL_7) ? SHELL_PATHS.POWERSHELL_7 : SHELL_PATHS.POWERSHELL_LEGACY
+	}
+
+	const profile = profiles[defaultProfileName]
+
+	// If the profile name indicates PowerShell, do version-based detection.
+	// In testing it was found these typically do not have a path, and this
+	// implementation manages to deductively get the correct version of PowerShell
+	if (defaultProfileName.toLowerCase().includes("powershell")) {
+		const normalizedPath = normalizeShellPath(profile?.path)
+		if (normalizedPath) {
+			// If there's an explicit PowerShell path, return that
+			return normalizedPath
+		} else if (profile?.source === "PowerShell") {
+			// If the profile is sourced from PowerShell, assume the newest
+			return SHELL_PATHS.POWERSHELL_7
+		}
+		// Otherwise, assume legacy Windows PowerShell
+		return SHELL_PATHS.POWERSHELL_LEGACY
+	}
+
+	// If there's a specific path, return that immediately
+	const normalizedPath = normalizeShellPath(profile?.path)
+	if (normalizedPath) {
+		return normalizedPath
+	}
+
+	// If the profile indicates WSL
+	if (profile?.source === "WSL" || defaultProfileName.toLowerCase().includes("wsl")) {
+		return SHELL_PATHS.WSL_BASH
+	}
+
+	// If nothing special detected, we assume cmd
+	return SHELL_PATHS.CMD
+}
+
+/** Attempts to retrieve a shell path from VS Code config on macOS. */
+function getMacShellFromVSCode(): string | null {
+	const { defaultProfileName, profiles } = getTerminalConfig("osx")
+	if (!defaultProfileName) {
+		return null
+	}
+
+	const profile = profiles[defaultProfileName]
+	return normalizeShellPath(profile?.path)
+}
+
+/** Attempts to retrieve a shell path from VS Code config on Linux. */
+function getLinuxShellFromVSCode(): string | null {
+	const { defaultProfileName, profiles } = getTerminalConfig("linux")
+	if (!defaultProfileName) {
+		return null
+	}
+
+	const profile = profiles[defaultProfileName]
+	return normalizeShellPath(profile?.path)
+}
+
+// -----------------------------------------------------
+// 3) General Fallback Helpers
+// -----------------------------------------------------
+
+/**
+ * Tries to get a user’s shell from os.userInfo() (works on Unix if the
+ * underlying system call is supported). Returns null on error or if not found.
+ */
+function getShellFromUserInfo(): string | null {
+	try {
+		const { shell } = userInfo()
+		return shell || null
+	} catch {
+		return null
+	}
+}
+
+/** Returns the environment-based shell variable, or null if not set. */
+function getShellFromEnv(): string | null {
+	const { env } = process
+
+	if (process.platform === "win32") {
+		// On Windows, COMSPEC typically holds cmd.exe
+		return env.COMSPEC || "C:\\Windows\\System32\\cmd.exe"
+	}
+
+	if (process.platform === "darwin") {
+		// On macOS/Linux, SHELL is commonly the environment variable
+		return env.SHELL || "/bin/zsh"
+	}
+
+	if (process.platform === "linux") {
+		// On Linux, SHELL is commonly the environment variable
+		return env.SHELL || "/bin/bash"
+	}
+	return null
+}
+
+// -----------------------------------------------------
+// 4) Shell Validation Functions
+// -----------------------------------------------------
+
+/**
+ * Validates if a shell path is in the allowlist to prevent arbitrary command execution
+ */
+function isShellAllowed(shellPath: string): boolean {
+	if (!shellPath) return false
+
+	const normalizedPath = path.normalize(shellPath)
+
+	// Direct lookup first
+	if (SHELL_ALLOWLIST.has(normalizedPath)) {
+		return true
+	}
+
+	// On Windows, try case-insensitive comparison
+	if (process.platform === "win32") {
+		const lowerPath = normalizedPath.toLowerCase()
+		for (const allowedPath of SHELL_ALLOWLIST) {
+			if (allowedPath.toLowerCase() === lowerPath) {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+/**
+ * Returns a safe fallback shell based on the platform
+ */
+function getSafeFallbackShell(): string {
+	if (process.platform === "win32") {
+		return SHELL_PATHS.CMD
+	} else if (process.platform === "darwin") {
+		return SHELL_PATHS.MAC_DEFAULT
+	} else {
+		return SHELL_PATHS.LINUX_DEFAULT
+	}
+}
+
+// -----------------------------------------------------
+// 5) Publicly Exposed Shell Getter
+// -----------------------------------------------------
+
+export function getShell(): string {
+	let shell: string | null = null
+
+	// 1. Check VS Code config first.
+	if (process.platform === "win32") {
+		// Special logic for Windows
+		shell = getWindowsShellFromVSCode()
+	} else if (process.platform === "darwin") {
+		// macOS from VS Code
+		shell = getMacShellFromVSCode()
+	} else if (process.platform === "linux") {
+		// Linux from VS Code
+		shell = getLinuxShellFromVSCode()
+	}
+
+	// 2. If no shell from VS Code, try userInfo()
+	if (!shell) {
+		shell = getShellFromUserInfo()
+	}
+
+	// 3. If still nothing, try environment variable
+	if (!shell) {
+		shell = getShellFromEnv()
+	}
+
+	// 4. Finally, fall back to a default
+	if (!shell) {
+		shell = getSafeFallbackShell()
+	}
+
+	// 5. Validate the shell against allowlist
+	if (!isShellAllowed(shell)) {
+		shell = getSafeFallbackShell()
+	}
+
+	return shell
+}

package/src/vendor/zoo-code/src/utils/text-normalization.ts

@@ -0,0 +1,99 @@
+/**
+ * Common character mappings for normalization
+ */
+export const NORMALIZATION_MAPS = {
+	// Smart quotes to regular quotes
+	SMART_QUOTES: {
+		"\u201C": '"', // Left double quote (U+201C)
+		"\u201D": '"', // Right double quote (U+201D)
+		"\u2018": "'", // Left single quote (U+2018)
+		"\u2019": "'", // Right single quote (U+2019)
+	},
+	// Other typographic characters
+	TYPOGRAPHIC: {
+		"\u2026": "...", // Ellipsis
+		"\u2014": "-", // Em dash
+		"\u2013": "-", // En dash
+		"\u00A0": " ", // Non-breaking space
+	},
+}
+
+/**
+ * Options for string normalization
+ */
+export interface NormalizeOptions {
+	smartQuotes?: boolean // Replace smart quotes with straight quotes
+	typographicChars?: boolean // Replace typographic characters
+	extraWhitespace?: boolean // Collapse multiple whitespace to single space
+	trim?: boolean // Trim whitespace from start and end
+}
+
+/**
+ * Default options for normalization
+ */
+const DEFAULT_OPTIONS: NormalizeOptions = {
+	smartQuotes: true,
+	typographicChars: true,
+	extraWhitespace: true,
+	trim: true,
+}
+
+/**
+ * Normalizes a string based on the specified options
+ *
+ * @param str The string to normalize
+ * @param options Normalization options
+ * @returns The normalized string
+ */
+export function normalizeString(str: string, options: NormalizeOptions = DEFAULT_OPTIONS): string {
+	const opts = { ...DEFAULT_OPTIONS, ...options }
+	let normalized = str
+
+	// Replace smart quotes
+	if (opts.smartQuotes) {
+		for (const [smart, regular] of Object.entries(NORMALIZATION_MAPS.SMART_QUOTES)) {
+			normalized = normalized.replace(new RegExp(smart, "g"), regular)
+		}
+	}
+
+	// Replace typographic characters
+	if (opts.typographicChars) {
+		for (const [typographic, regular] of Object.entries(NORMALIZATION_MAPS.TYPOGRAPHIC)) {
+			normalized = normalized.replace(new RegExp(typographic, "g"), regular)
+		}
+	}
+
+	// Normalize whitespace
+	if (opts.extraWhitespace) {
+		normalized = normalized.replace(/\s+/g, " ")
+	}
+
+	// Trim whitespace
+	if (opts.trim) {
+		normalized = normalized.trim()
+	}
+
+	return normalized
+}
+
+/**
+ * Unescapes common HTML entities in a string
+ *
+ * @param text The string containing HTML entities to unescape
+ * @returns The unescaped string with HTML entities converted to their literal characters
+ */
+export function unescapeHtmlEntities(text: string): string {
+	if (!text) return text
+
+	return text
+		.replace(/&lt;/g, "<")
+		.replace(/&gt;/g, ">")
+		.replace(/&quot;/g, '"')
+		.replace(/&#39;/g, "'")
+		.replace(/&apos;/g, "'")
+		.replace(/&#91;/g, "[")
+		.replace(/&#93;/g, "]")
+		.replace(/&lsqb;/g, "[")
+		.replace(/&rsqb;/g, "]")
+		.replace(/&amp;/g, "&")
+}

package/src/vendor/zoo-code/types/global-settings.ts

@@ -0,0 +1,19 @@
+/**
+ * Vendored subset of `zoo-code/packages/types/src/global-settings.ts`.
+ *
+ * Only `DEFAULT_DIFF_FUZZY_THRESHOLD` is carried here (verbatim value) — it is
+ * the one global-setting constant the vendored diff strategy imports. The full
+ * upstream file also defines dozens of settings-related constants + zod schemas
+ * that pull in `codebase-index`, `experiment`, `history`, `provider-settings`,
+ * `telemetry` and `type-fu` modules, none of which the headless harness needs.
+ */
+
+/**
+ * Default fuzzy matching threshold for the multi-search-replace diff strategy.
+ * A value of 1.0 (exact match) is used by default for safety, especially when
+ * auto-approval for writes is enabled. This prevents unintended changes from
+ * being applied due to minor mismatches. Users can lower this threshold manually
+ * in settings to reduce "Edit Unsuccessful" errors caused by minor whitespace
+ * or formatting differences, accepting a higher risk of unintended edits.
+ */
+export const DEFAULT_DIFF_FUZZY_THRESHOLD = 1.0

package/src/vendor/zoo-code/types/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Vendored `@roo-code/types` barrel.
+ *
+ * The harness does not depend on the published `@roo-code/types` package. The
+ * type modules below are copied verbatim from `packages/types/src/`, and this
+ * barrel re-exports exactly the surface the vendored core imports. Vendored
+ * files' `@roo-code/types` imports are rewritten to import this barrel by
+ * relative path (issue #99 rework).
+ *
+ * Files: tool.ts, mode.ts, todo.ts, vscode.ts are verbatim copies.
+ * message.ts and tool-params.ts are also verbatim copies; only the two types
+ * each of them contributes to the vendored core are re-exported here.
+ */
+
+export * from "./tool.js"
+export * from "./mode.js"
+export * from "./todo.js"
+export * from "./vscode.js"
+export * from "./global-settings.js"
+
+export type { ClineAsk, ToolProgressStatus } from "./message.js"
+export type { GenerateImageParams, ReadFileToolParams } from "./tool-params.js"