@xortex/xcode 3.0.0

package/utils/bash/shellCompletion.ts

@@ -0,0 +1,259 @@
+import type { SuggestionItem } from 'src/components/PromptInput/PromptInputFooterSuggestions.js'
+import {
+  type ParseEntry,
+  quote,
+  tryParseShellCommand,
+} from '../bash/shellQuote.js'
+import { logForDebugging } from '../debug.js'
+import { getShellType } from '../localInstaller.js'
+import * as Shell from '../Shell.js'
+
+// Constants
+const MAX_SHELL_COMPLETIONS = 15
+const SHELL_COMPLETION_TIMEOUT_MS = 1000
+const COMMAND_OPERATORS = ['|', '||', '&&', ';'] as const
+
+export type ShellCompletionType = 'command' | 'variable' | 'file'
+
+type InputContext = {
+  prefix: string
+  completionType: ShellCompletionType
+}
+
+/**
+ * Check if a parsed token is a command operator (|, ||, &&, ;)
+ */
+function isCommandOperator(token: ParseEntry): boolean {
+  return (
+    typeof token === 'object' &&
+    token !== null &&
+    'op' in token &&
+    (COMMAND_OPERATORS as readonly string[]).includes(token.op as string)
+  )
+}
+
+/**
+ * Determine completion type based solely on prefix characteristics
+ */
+function getCompletionTypeFromPrefix(prefix: string): ShellCompletionType {
+  if (prefix.startsWith('$')) {
+    return 'variable'
+  }
+  if (
+    prefix.includes('/') ||
+    prefix.startsWith('~') ||
+    prefix.startsWith('.')
+  ) {
+    return 'file'
+  }
+  return 'command'
+}
+
+/**
+ * Find the last string token and its index in parsed tokens
+ */
+function findLastStringToken(
+  tokens: ParseEntry[],
+): { token: string; index: number } | null {
+  const i = tokens.findLastIndex(t => typeof t === 'string')
+  return i !== -1 ? { token: tokens[i] as string, index: i } : null
+}
+
+/**
+ * Check if we're in a context that expects a new command
+ * (at start of input or after a command operator)
+ */
+function isNewCommandContext(
+  tokens: ParseEntry[],
+  currentTokenIndex: number,
+): boolean {
+  if (currentTokenIndex === 0) {
+    return true
+  }
+  const prevToken = tokens[currentTokenIndex - 1]
+  return prevToken !== undefined && isCommandOperator(prevToken)
+}
+
+/**
+ * Parse input to extract completion context
+ */
+function parseInputContext(input: string, cursorOffset: number): InputContext {
+  const beforeCursor = input.slice(0, cursorOffset)
+
+  // Check if it's a variable prefix, before expanding with shell-quote
+  const varMatch = beforeCursor.match(/\$[a-zA-Z_][a-zA-Z0-9_]*$/)
+  if (varMatch) {
+    return { prefix: varMatch[0], completionType: 'variable' }
+  }
+
+  // Parse with shell-quote
+  const parseResult = tryParseShellCommand(beforeCursor)
+  if (!parseResult.success) {
+    // Fallback to simple parsing
+    const tokens = beforeCursor.split(/\s+/)
+    const prefix = tokens[tokens.length - 1] || ''
+    const isFirstToken = tokens.length === 1 && !beforeCursor.includes(' ')
+    const completionType = isFirstToken
+      ? 'command'
+      : getCompletionTypeFromPrefix(prefix)
+    return { prefix, completionType }
+  }
+
+  // Extract current token
+  const lastToken = findLastStringToken(parseResult.tokens)
+  if (!lastToken) {
+    // No string token found - check if after operator
+    const lastParsedToken = parseResult.tokens[parseResult.tokens.length - 1]
+    const completionType =
+      lastParsedToken && isCommandOperator(lastParsedToken)
+        ? 'command'
+        : 'command' // Default to command at start
+    return { prefix: '', completionType }
+  }
+
+  // If there's a trailing space, the user is starting a new argument
+  if (beforeCursor.endsWith(' ')) {
+    // After first token (command) with space = file argument expected
+    return { prefix: '', completionType: 'file' }
+  }
+
+  // Determine completion type from context
+  const baseType = getCompletionTypeFromPrefix(lastToken.token)
+
+  // If it's clearly a file or variable based on prefix, use that type
+  if (baseType === 'variable' || baseType === 'file') {
+    return { prefix: lastToken.token, completionType: baseType }
+  }
+
+  // For command-like tokens, check context: are we starting a new command?
+  const completionType = isNewCommandContext(
+    parseResult.tokens,
+    lastToken.index,
+  )
+    ? 'command'
+    : 'file' // Not after operator = file argument
+
+  return { prefix: lastToken.token, completionType }
+}
+
+/**
+ * Generate bash completion command using compgen
+ */
+function getBashCompletionCommand(
+  prefix: string,
+  completionType: ShellCompletionType,
+): string {
+  if (completionType === 'variable') {
+    // Variable completion - remove $ prefix
+    const varName = prefix.slice(1)
+    return `compgen -v ${quote([varName])} 2>/dev/null`
+  } else if (completionType === 'file') {
+    // File completion with trailing slash for directories and trailing space for files
+    // Use 'while read' to prevent command injection from filenames containing newlines
+    return `compgen -f ${quote([prefix])} 2>/dev/null | head -${MAX_SHELL_COMPLETIONS} | while IFS= read -r f; do [ -d "$f" ] && echo "$f/" || echo "$f "; done`
+  } else {
+    // Command completion
+    return `compgen -c ${quote([prefix])} 2>/dev/null`
+  }
+}
+
+/**
+ * Generate zsh completion command using native zsh commands
+ */
+function getZshCompletionCommand(
+  prefix: string,
+  completionType: ShellCompletionType,
+): string {
+  if (completionType === 'variable') {
+    // Variable completion - use zsh pattern matching for safe filtering
+    const varName = prefix.slice(1)
+    return `print -rl -- \${(k)parameters[(I)${quote([varName])}*]} 2>/dev/null`
+  } else if (completionType === 'file') {
+    // File completion with trailing slash for directories and trailing space for files
+    // Note: zsh glob expansion is safe from command injection (unlike bash for-in loops)
+    return `for f in ${quote([prefix])}*(N[1,${MAX_SHELL_COMPLETIONS}]); do [[ -d "$f" ]] && echo "$f/" || echo "$f "; done`
+  } else {
+    // Command completion - use zsh pattern matching for safe filtering
+    return `print -rl -- \${(k)commands[(I)${quote([prefix])}*]} 2>/dev/null`
+  }
+}
+
+/**
+ * Get completions for the given shell type
+ */
+async function getCompletionsForShell(
+  shellType: 'bash' | 'zsh',
+  prefix: string,
+  completionType: ShellCompletionType,
+  abortSignal: AbortSignal,
+): Promise<SuggestionItem[]> {
+  let command: string
+
+  if (shellType === 'bash') {
+    command = getBashCompletionCommand(prefix, completionType)
+  } else if (shellType === 'zsh') {
+    command = getZshCompletionCommand(prefix, completionType)
+  } else {
+    // Unsupported shell type
+    return []
+  }
+
+  const shellCommand = await Shell.exec(command, abortSignal, 'bash', {
+    timeout: SHELL_COMPLETION_TIMEOUT_MS,
+  })
+  const result = await shellCommand.result
+  return result.stdout
+    .split('\n')
+    .filter((line: string) => line.trim())
+    .slice(0, MAX_SHELL_COMPLETIONS)
+    .map((text: string) => ({
+      id: text,
+      displayText: text,
+      description: undefined,
+      metadata: { completionType },
+    }))
+}
+
+/**
+ * Get shell completions for the given input
+ * Supports bash and zsh shells (matches Shell.ts execution support)
+ */
+export async function getShellCompletions(
+  input: string,
+  cursorOffset: number,
+  abortSignal: AbortSignal,
+): Promise<SuggestionItem[]> {
+  const shellType = getShellType()
+
+  // Only support bash/zsh (matches Shell.ts execution support)
+  if (shellType !== 'bash' && shellType !== 'zsh') {
+    return []
+  }
+
+  try {
+    const { prefix, completionType } = parseInputContext(input, cursorOffset)
+
+    if (!prefix) {
+      return []
+    }
+
+    const completions = await getCompletionsForShell(
+      shellType,
+      prefix,
+      completionType,
+      abortSignal,
+    )
+
+    // Add inputSnapshot to all suggestions so we can detect when input changes
+    return completions.map(suggestion => ({
+      ...suggestion,
+      metadata: {
+        ...(suggestion.metadata as { completionType: ShellCompletionType }),
+        inputSnapshot: input,
+      },
+    }))
+  } catch (error) {
+    logForDebugging(`Shell completion failed: ${error}`)
+    return [] // Silent fail
+  }
+}

package/utils/bash/shellPrefix.ts

@@ -0,0 +1,28 @@
+import { quote } from './shellQuote.js'
+
+/**
+ * Parses a shell prefix that may contain an executable path and arguments.
+ *
+ * Examples:
+ * - "bash" -> quotes as 'bash'
+ * - "/usr/bin/bash -c" -> quotes as '/usr/bin/bash' -c
+ * - "C:\Program Files\Git\bin\bash.exe -c" -> quotes as 'C:\Program Files\Git\bin\bash.exe' -c
+ *
+ * @param prefix The shell prefix string containing executable and optional arguments
+ * @param command The command to be executed
+ * @returns The properly formatted command string with quoted components
+ */
+export function formatShellPrefixCommand(
+  prefix: string,
+  command: string,
+): string {
+  // Split on the last space before a dash to separate executable from arguments
+  const spaceBeforeDash = prefix.lastIndexOf(' -')
+  if (spaceBeforeDash > 0) {
+    const execPath = prefix.substring(0, spaceBeforeDash)
+    const args = prefix.substring(spaceBeforeDash + 1)
+    return `${quote([execPath])} ${args} ${quote([command])}`
+  } else {
+    return `${quote([prefix])} ${quote([command])}`
+  }
+}

package/utils/bash/shellQuote.ts

@@ -0,0 +1,304 @@
+/**
+ * Safe wrappers for shell-quote library functions that handle errors gracefully
+ * These are drop-in replacements for the original functions
+ */
+
+import {
+  type ParseEntry,
+  parse as shellQuoteParse,
+  quote as shellQuoteQuote,
+} from 'shell-quote'
+import { logError } from '../log.js'
+import { jsonStringify } from '../slowOperations.js'
+
+export type { ParseEntry } from 'shell-quote'
+
+export type ShellParseResult =
+  | { success: true; tokens: ParseEntry[] }
+  | { success: false; error: string }
+
+export type ShellQuoteResult =
+  | { success: true; quoted: string }
+  | { success: false; error: string }
+
+export function tryParseShellCommand(
+  cmd: string,
+  env?:
+    | Record<string, string | undefined>
+    | ((key: string) => string | undefined),
+): ShellParseResult {
+  try {
+    const tokens =
+      typeof env === 'function'
+        ? shellQuoteParse(cmd, env)
+        : shellQuoteParse(cmd, env)
+    return { success: true, tokens }
+  } catch (error) {
+    if (error instanceof Error) {
+      logError(error)
+    }
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown parse error',
+    }
+  }
+}
+
+export function tryQuoteShellArgs(args: unknown[]): ShellQuoteResult {
+  try {
+    const validated: string[] = args.map((arg, index) => {
+      if (arg === null || arg === undefined) {
+        return String(arg)
+      }
+
+      const type = typeof arg
+
+      if (type === 'string') {
+        return arg as string
+      }
+      if (type === 'number' || type === 'boolean') {
+        return String(arg)
+      }
+
+      if (type === 'object') {
+        throw new Error(
+          `Cannot quote argument at index ${index}: object values are not supported`,
+        )
+      }
+      if (type === 'symbol') {
+        throw new Error(
+          `Cannot quote argument at index ${index}: symbol values are not supported`,
+        )
+      }
+      if (type === 'function') {
+        throw new Error(
+          `Cannot quote argument at index ${index}: function values are not supported`,
+        )
+      }
+
+      throw new Error(
+        `Cannot quote argument at index ${index}: unsupported type ${type}`,
+      )
+    })
+
+    const quoted = shellQuoteQuote(validated)
+    return { success: true, quoted }
+  } catch (error) {
+    if (error instanceof Error) {
+      logError(error)
+    }
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown quote error',
+    }
+  }
+}
+
+/**
+ * Checks if parsed tokens contain malformed entries that suggest shell-quote
+ * misinterpreted the command. This happens when input contains ambiguous
+ * patterns (like JSON-like strings with semicolons) that shell-quote parses
+ * according to shell rules, producing token fragments.
+ *
+ * For example, `echo {"hi":"hi;evil"}` gets parsed with `;` as an operator,
+ * producing tokens like `{hi:"hi` (unbalanced brace). Legitimate commands
+ * produce complete, balanced tokens.
+ *
+ * Also detects unterminated quotes in the original command: shell-quote
+ * silently drops an unmatched `"` or `'` and parses the rest as unquoted,
+ * leaving no trace in the tokens. `echo "hi;evil | cat` (one unmatched `"`)
+ * is a bash syntax error, but shell-quote yields clean tokens with `;` as
+ * an operator. The token-level checks below can't catch this, so we walk
+ * the original command with bash quote semantics and flag odd parity.
+ *
+ * Security: This prevents command injection via HackerOne #3482049 where
+ * shell-quote's correct parsing of ambiguous input can be exploited.
+ */
+export function hasMalformedTokens(
+  command: string,
+  parsed: ParseEntry[],
+): boolean {
+  // Check for unterminated quotes in the original command. shell-quote drops
+  // an unmatched quote without leaving any trace in the tokens, so this must
+  // inspect the raw string. Walk with bash semantics: backslash escapes the
+  // next char outside single-quotes; no escapes inside single-quotes.
+  let inSingle = false
+  let inDouble = false
+  let doubleCount = 0
+  let singleCount = 0
+  for (let i = 0; i < command.length; i++) {
+    const c = command[i]
+    if (c === '\\' && !inSingle) {
+      i++
+      continue
+    }
+    if (c === '"' && !inSingle) {
+      doubleCount++
+      inDouble = !inDouble
+    } else if (c === "'" && !inDouble) {
+      singleCount++
+      inSingle = !inSingle
+    }
+  }
+  if (doubleCount % 2 !== 0 || singleCount % 2 !== 0) return true
+
+  for (const entry of parsed) {
+    if (typeof entry !== 'string') continue
+
+    // Check for unbalanced curly braces
+    const openBraces = (entry.match(/{/g) || []).length
+    const closeBraces = (entry.match(/}/g) || []).length
+    if (openBraces !== closeBraces) return true
+
+    // Check for unbalanced parentheses
+    const openParens = (entry.match(/\(/g) || []).length
+    const closeParens = (entry.match(/\)/g) || []).length
+    if (openParens !== closeParens) return true
+
+    // Check for unbalanced square brackets
+    const openBrackets = (entry.match(/\[/g) || []).length
+    const closeBrackets = (entry.match(/\]/g) || []).length
+    if (openBrackets !== closeBrackets) return true
+
+    // Check for unbalanced double quotes
+    // Count quotes that aren't escaped (preceded by backslash)
+    // A token with an odd number of unescaped quotes is malformed
+    // eslint-disable-next-line custom-rules/no-lookbehind-regex -- gated by hasCommandSeparator check at caller, runs on short per-token strings
+    const doubleQuotes = entry.match(/(?<!\\)"/g) || []
+    if (doubleQuotes.length % 2 !== 0) return true
+
+    // Check for unbalanced single quotes
+    // eslint-disable-next-line custom-rules/no-lookbehind-regex -- same as above
+    const singleQuotes = entry.match(/(?<!\\)'/g) || []
+    if (singleQuotes.length % 2 !== 0) return true
+  }
+  return false
+}
+
+/**
+ * Detects commands containing '\' patterns that exploit the shell-quote library's
+ * incorrect handling of backslashes inside single quotes.
+ *
+ * In bash, single quotes preserve ALL characters literally - backslash has no
+ * special meaning. So '\' is just the string \ (the quote opens, contains \,
+ * and the next ' closes it). But shell-quote incorrectly treats \ as an escape
+ * character inside single quotes, causing '\' to NOT close the quoted string.
+ *
+ * This means the pattern '\' <payload> '\' hides <payload> from security checks
+ * because shell-quote thinks it's all one single-quoted string.
+ */
+export function hasShellQuoteSingleQuoteBug(command: string): boolean {
+  // Walk the command with correct bash single-quote semantics
+  let inSingleQuote = false
+  let inDoubleQuote = false
+
+  for (let i = 0; i < command.length; i++) {
+    const char = command[i]
+
+    // Handle backslash escaping outside of single quotes
+    if (char === '\\' && !inSingleQuote) {
+      // Skip the next character (it's escaped)
+      i++
+      continue
+    }
+
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote
+      continue
+    }
+
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote
+
+      // Check if we just closed a single quote and the content ends with
+      // trailing backslashes. shell-quote's chunker regex '((\\'|[^'])*?)'
+      // incorrectly treats \' as an escape sequence inside single quotes,
+      // while bash treats backslash as literal. This creates a differential
+      // where shell-quote merges tokens that bash treats as separate.
+      //
+      // Odd trailing \'s = always a bug:
+      //   '\' -> shell-quote: \' = literal ', still open. bash: \, closed.
+      //   'abc\' -> shell-quote: abc then \' = literal ', still open. bash: abc\, closed.
+      //   '\\\'  -> shell-quote: \\ + \', still open. bash: \\\, closed.
+      //
+      // Even trailing \'s = bug ONLY when a later ' exists in the command:
+      //   '\\' alone -> shell-quote backtracks, both parsers agree string closes. OK.
+      //   '\\' 'next' -> shell-quote: \' consumes the closing ', finds next ' as
+      //                   false close, merges tokens. bash: two separate tokens.
+      //
+      //   Detail: the regex alternation tries \' before [^']. For '\\', it matches
+      //   the first \ via [^'] (next char is \, not '), then the second \ via \'
+      //   (next char IS '). This consumes the closing '. The regex continues reading
+      //   until it finds another ' to close the match. If none exists, it backtracks
+      //   to [^'] for the second \ and closes correctly. If a later ' exists (e.g.,
+      //   the opener of the next single-quoted arg), no backtracking occurs and
+      //   tokens merge. See H1 report: git ls-remote 'safe\\' '--upload-pack=evil' 'repo'
+      //   shell-quote: ["git","ls-remote","safe\\\\ --upload-pack=evil repo"]
+      //   bash:        ["git","ls-remote","safe\\\\","--upload-pack=evil","repo"]
+      if (!inSingleQuote) {
+        let backslashCount = 0
+        let j = i - 1
+        while (j >= 0 && command[j] === '\\') {
+          backslashCount++
+          j--
+        }
+        if (backslashCount > 0 && backslashCount % 2 === 1) {
+          return true
+        }
+        // Even trailing backslashes: only a bug when a later ' exists that
+        // the chunker regex can use as a false closing quote. We check for
+        // ANY later ' because the regex doesn't respect bash quote state
+        // (e.g., a ' inside double quotes is also consumable).
+        if (
+          backslashCount > 0 &&
+          backslashCount % 2 === 0 &&
+          command.indexOf("'", i + 1) !== -1
+        ) {
+          return true
+        }
+      }
+      continue
+    }
+  }
+
+  return false
+}
+
+export function quote(args: ReadonlyArray<unknown>): string {
+  // First try the strict validation
+  const result = tryQuoteShellArgs([...args])
+
+  if (result.success) {
+    return result.quoted
+  }
+
+  // If strict validation failed, use lenient fallback
+  // This handles objects, symbols, functions, etc. by converting them to strings
+  try {
+    const stringArgs = args.map(arg => {
+      if (arg === null || arg === undefined) {
+        return String(arg)
+      }
+
+      const type = typeof arg
+
+      if (type === 'string' || type === 'number' || type === 'boolean') {
+        return String(arg)
+      }
+
+      // For unsupported types, use JSON.stringify as a safe fallback
+      // This ensures we don't crash but still get a meaningful representation
+      return jsonStringify(arg)
+    })
+
+    return shellQuoteQuote(stringArgs)
+  } catch (error) {
+    // SECURITY: Never use JSON.stringify as a fallback for shell quoting.
+    // JSON.stringify uses double quotes which don't prevent shell command execution.
+    // For example, jsonStringify(['echo', '$(whoami)']) produces "echo" "$(whoami)"
+    if (error instanceof Error) {
+      logError(error)
+    }
+    throw new Error('Failed to quote shell arguments safely')
+  }
+}