@shareai-lab/kode 1.1.13 → 1.1.16-dev.1

package/src/utils/PersistentShell.ts

@@ -1,552 +0,0 @@
-import * as fs from 'fs'
-import { homedir } from 'os'
-import { existsSync } from 'fs'
-import shellquote from 'shell-quote'
-import { spawn, execSync, type ChildProcess } from 'child_process'
-import { isAbsolute, resolve, join } from 'path'
-import { logError } from './log'
-import * as os from 'os'
-import { logEvent } from '../services/statsig'
-import { PRODUCT_COMMAND } from '../constants/product'
-
-type ExecResult = {
-  stdout: string
-  stderr: string
-  code: number
-  interrupted: boolean
-}
-type QueuedCommand = {
-  command: string
-  abortSignal?: AbortSignal
-  timeout?: number
-  resolve: (result: ExecResult) => void
-  reject: (error: Error) => void
-}
-
-const TEMPFILE_PREFIX = os.tmpdir() + `/${PRODUCT_COMMAND}-`
-const DEFAULT_TIMEOUT = 30 * 60 * 1000
-const SIGTERM_CODE = 143 // Standard exit code for SIGTERM
-const FILE_SUFFIXES = {
-  STATUS: '-status',
-  STDOUT: '-stdout',
-  STDERR: '-stderr',
-  CWD: '-cwd',
-}
-const SHELL_CONFIGS: Record<string, string> = {
-  '/bin/bash': '.bashrc',
-  '/bin/zsh': '.zshrc',
-}
-
-type DetectedShell = {
-  bin: string
-  args: string[]
-  type: 'posix' | 'msys' | 'wsl'
-}
-
-function quoteForBash(str: string): string {
-  return `'${str.replace(/'/g, "'\\''")}'`
-}
-
-function toBashPath(pathStr: string, type: 'posix' | 'msys' | 'wsl'): string {
-  // Already POSIX absolute path
-  if (pathStr.startsWith('/')) return pathStr
-  if (type === 'posix') return pathStr
-
-  // Normalize backslashes
-  const normalized = pathStr.replace(/\\/g, '/').replace(/\\\\/g, '/')
-  const driveMatch = /^[A-Za-z]:/.exec(normalized)
-  if (driveMatch) {
-    const drive = normalized[0].toLowerCase()
-    const rest = normalized.slice(2)
-    if (type === 'msys') {
-      return `/` + drive + (rest.startsWith('/') ? rest : `/${rest}`)
-    }
-    // wsl
-    return `/mnt/` + drive + (rest.startsWith('/') ? rest : `/${rest}`)
-  }
-  // Relative path: just convert slashes
-  return normalized
-}
-
-function fileExists(p: string | undefined): p is string {
-  return !!p && existsSync(p)
-}
-
-// Robust PATH splitter for Windows and POSIX
-function splitPathEntries(pathEnv: string, platform: NodeJS.Platform): string[] {
-  if (!pathEnv) return []
-
-  // POSIX: ':' is the separator
-  if (platform !== 'win32') {
-    return pathEnv
-      .split(':')
-      .map(s => s.trim().replace(/^"|"$/g, ''))
-      .filter(Boolean)
-  }
-
-  // Windows: primarily ';', but some environments may use ':'
-  // We must not split drive letters like 'C:\\' or 'D:foo\\bar'
-  const entries: string[] = []
-  let current = ''
-  const pushCurrent = () => {
-    const cleaned = current.trim().replace(/^"|"$/g, '')
-    if (cleaned) entries.push(cleaned)
-    current = ''
-  }
-
-  for (let i = 0; i < pathEnv.length; i++) {
-    const ch = pathEnv[i]
-
-    if (ch === ';') {
-      pushCurrent()
-      continue
-    }
-
-    if (ch === ':') {
-      const segmentLength = current.length
-      const firstChar = current[0]
-      const isDriveLetterPrefix = segmentLength === 1 && /[A-Za-z]/.test(firstChar || '')
-      // Treat ':' as separator only if it's NOT the drive letter colon
-      if (!isDriveLetterPrefix) {
-        pushCurrent()
-        continue
-      }
-    }
-
-    current += ch
-  }
-
-  // Flush the final segment
-  pushCurrent()
-
-  return entries
-}
-
-function detectShell(): DetectedShell {
-  const isWin = process.platform === 'win32'
-  if (!isWin) {
-    const bin = process.env.SHELL || '/bin/bash'
-    return { bin, args: ['-l'], type: 'posix' }
-  }
-
-  // 1) Respect SHELL if it points to a bash.exe that exists
-  if (process.env.SHELL && /bash\.exe$/i.test(process.env.SHELL) && existsSync(process.env.SHELL)) {
-    return { bin: process.env.SHELL, args: ['-l'], type: 'msys' }
-  }
-
-  // 1.1) Explicit override
-  if (process.env.KODE_BASH && existsSync(process.env.KODE_BASH)) {
-    return { bin: process.env.KODE_BASH, args: ['-l'], type: 'msys' }
-  }
-
-  // 2) Common Git Bash/MSYS2 locations
-  const programFiles = [
-    process.env['ProgramFiles'],
-    process.env['ProgramFiles(x86)'],
-    process.env['ProgramW6432'],
-  ].filter(Boolean) as string[]
-
-  const localAppData = process.env['LocalAppData']
-
-  const candidates: string[] = []
-  for (const base of programFiles) {
-    candidates.push(
-      join(base, 'Git', 'bin', 'bash.exe'),
-      join(base, 'Git', 'usr', 'bin', 'bash.exe'),
-    )
-  }
-  if (localAppData) {
-    candidates.push(
-      join(localAppData, 'Programs', 'Git', 'bin', 'bash.exe'),
-      join(localAppData, 'Programs', 'Git', 'usr', 'bin', 'bash.exe'),
-    )
-  }
-  // MSYS2 default
-  candidates.push('C:/msys64/usr/bin/bash.exe')
-
-  for (const c of candidates) {
-    if (existsSync(c)) {
-      return { bin: c, args: ['-l'], type: 'msys' }
-    }
-  }
-
-  // 2.1) Search in PATH for bash.exe
-  const pathEnv = process.env.PATH || process.env.Path || process.env.path || ''
-  const pathEntries = splitPathEntries(pathEnv, process.platform)
-  for (const p of pathEntries) {
-    const candidate = join(p, 'bash.exe')
-    if (existsSync(candidate)) {
-      return { bin: candidate, args: ['-l'], type: 'msys' }
-    }
-  }
-
-  // 3) WSL
-  try {
-    // Quick probe to ensure WSL+bash exists
-    execSync('wsl.exe -e bash -lc "echo KODE_OK"', { stdio: 'ignore', timeout: 1500 })
-    return { bin: 'wsl.exe', args: ['-e', 'bash', '-l'], type: 'wsl' }
-  } catch {}
-
-  // 4) Last resort: meaningful error
-  const hint = [
-    '无法找到可用的 bash。请安装 Git for Windows 或启用 WSL。',
-    '推荐安装 Git: https://git-scm.com/download/win',
-    '或启用 WSL 并安装 Ubuntu: https://learn.microsoft.com/windows/wsl/install',
-  ].join('\n')
-  throw new Error(hint)
-}
-
-export class PersistentShell {
-  private commandQueue: QueuedCommand[] = []
-  private isExecuting: boolean = false
-  private shell: ChildProcess
-  private isAlive: boolean = true
-  private commandInterrupted: boolean = false
-  private statusFile: string
-  private stdoutFile: string
-  private stderrFile: string
-  private cwdFile: string
-  private cwd: string
-  private binShell: string
-  private shellArgs: string[]
-  private shellType: 'posix' | 'msys' | 'wsl'
-  private statusFileBashPath: string
-  private stdoutFileBashPath: string
-  private stderrFileBashPath: string
-  private cwdFileBashPath: string
-
-  constructor(cwd: string) {
-    const { bin, args, type } = detectShell()
-    this.binShell = bin
-    this.shellArgs = args
-    this.shellType = type
-
-    this.shell = spawn(this.binShell, this.shellArgs, {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      cwd,
-      env: {
-        ...process.env,
-        GIT_EDITOR: 'true',
-      },
-    })
-
-    this.cwd = cwd
-
-    this.shell.on('exit', (code, signal) => {
-      if (code) {
-        // TODO: It would be nice to alert the user that shell crashed
-        logError(`Shell exited with code ${code} and signal ${signal}`)
-        logEvent('persistent_shell_exit', {
-          code: code?.toString() || 'null',
-          signal: signal || 'null',
-        })
-      }
-      for (const file of [
-        this.statusFile,
-        this.stdoutFile,
-        this.stderrFile,
-        this.cwdFile,
-      ]) {
-        if (fs.existsSync(file)) {
-          fs.unlinkSync(file)
-        }
-      }
-      this.isAlive = false
-    })
-
-    const id = Math.floor(Math.random() * 0x10000)
-      .toString(16)
-      .padStart(4, '0')
-
-    this.statusFile = TEMPFILE_PREFIX + id + FILE_SUFFIXES.STATUS
-    this.stdoutFile = TEMPFILE_PREFIX + id + FILE_SUFFIXES.STDOUT
-    this.stderrFile = TEMPFILE_PREFIX + id + FILE_SUFFIXES.STDERR
-    this.cwdFile = TEMPFILE_PREFIX + id + FILE_SUFFIXES.CWD
-    for (const file of [this.statusFile, this.stdoutFile, this.stderrFile]) {
-      fs.writeFileSync(file, '')
-    }
-    // Initialize CWD file with initial directory
-    fs.writeFileSync(this.cwdFile, cwd)
-
-    // Compute bash-visible paths for redirections
-    this.statusFileBashPath = toBashPath(this.statusFile, this.shellType)
-    this.stdoutFileBashPath = toBashPath(this.stdoutFile, this.shellType)
-    this.stderrFileBashPath = toBashPath(this.stderrFile, this.shellType)
-    this.cwdFileBashPath = toBashPath(this.cwdFile, this.shellType)
-
-    // Source ~/.bashrc when available (works for bash on POSIX/MSYS/WSL)
-    this.sendToShell('[ -f ~/.bashrc ] && source ~/.bashrc || true')
-  }
-
-  private static instance: PersistentShell | null = null
-
-  static restart() {
-    if (PersistentShell.instance) {
-      PersistentShell.instance.close()
-      PersistentShell.instance = null
-    }
-  }
-
-  static getInstance(): PersistentShell {
-    if (!PersistentShell.instance || !PersistentShell.instance.isAlive) {
-      PersistentShell.instance = new PersistentShell(process.cwd())
-    }
-    return PersistentShell.instance
-  }
-
-  killChildren() {
-    const parentPid = this.shell.pid
-    try {
-      const childPids = execSync(`pgrep -P ${parentPid}`)
-        .toString()
-        .trim()
-        .split('\n')
-        .filter(Boolean) // Filter out empty strings
-
-      if (childPids.length > 0) {
-        logEvent('persistent_shell_command_interrupted', {
-          numChildProcesses: childPids.length.toString(),
-        })
-      }
-
-      childPids.forEach(pid => {
-        try {
-          process.kill(Number(pid), 'SIGTERM')
-        } catch (error) {
-          logError(`Failed to kill process ${pid}: ${error}`)
-          logEvent('persistent_shell_kill_process_error', {
-            error: (error as Error).message.substring(0, 10),
-          })
-        }
-      })
-    } catch {
-      // pgrep returns non-zero when no processes are found - this is expected
-    } finally {
-      this.commandInterrupted = true
-    }
-  }
-
-  private async processQueue() {
-    /**
-     * Processes commands from the queue one at a time.
-     * Concurrency invariants:
-     * - Only one instance runs at a time (controlled by isExecuting)
-     * - Is the only caller of updateCwd() in the system
-     * - Calls updateCwd() after each command completes
-     * - Ensures commands execute serially via the queue
-     * - Handles interruption via abortSignal by calling killChildren()
-     * - Cleans up abortSignal listeners after command completion or interruption
-     */
-    if (this.isExecuting || this.commandQueue.length === 0) return
-
-    this.isExecuting = true
-    const { command, abortSignal, timeout, resolve, reject } =
-      this.commandQueue.shift()!
-
-    const killChildren = () => this.killChildren()
-    if (abortSignal) {
-      abortSignal.addEventListener('abort', killChildren)
-    }
-
-    try {
-      const result = await this.exec_(command, timeout)
-
-      // No need to update cwd - it's handled in exec_ via the CWD file
-
-      resolve(result)
-    } catch (error) {
-      logEvent('persistent_shell_command_error', {
-        error: (error as Error).message.substring(0, 10),
-      })
-      reject(error as Error)
-    } finally {
-      this.isExecuting = false
-      if (abortSignal) {
-        abortSignal.removeEventListener('abort', killChildren)
-      }
-      // Process next command in queue
-      this.processQueue()
-    }
-  }
-
-  async exec(
-    command: string,
-    abortSignal?: AbortSignal,
-    timeout?: number,
-  ): Promise<ExecResult> {
-    return new Promise((resolve, reject) => {
-      this.commandQueue.push({ command, abortSignal, timeout, resolve, reject })
-      this.processQueue()
-    })
-  }
-
-  private async exec_(command: string, timeout?: number): Promise<ExecResult> {
-    /**
-     * Direct command execution without going through the queue.
-     * Concurrency invariants:
-     * - Not safe for concurrent calls (uses shared files)
-     * - Called only when queue is idle
-     * - Relies on file-based IPC to handle shell interaction
-     * - Does not modify the command queue state
-     * - Tracks interruption state via commandInterrupted flag
-     * - Resets interruption state at start of new command
-     * - Reports interruption status in result object
-     *
-     * Exit Code & CWD Handling:
-     * - Executes command and immediately captures its exit code into a shell variable
-     * - Updates the CWD file with the working directory after capturing exit code
-     * - Writes the preserved exit code to the status file as the final step
-     * - This sequence eliminates race conditions between exit code capture and CWD updates
-     * - The pwd() method reads the CWD file directly for current directory info
-     */
-    const quotedCommand = shellquote.quote([command])
-
-    // Check the syntax of the command
-    try {
-      if (this.shellType === 'wsl') {
-        execSync(`wsl.exe -e bash -n -c ${quotedCommand}`, {
-          stdio: 'ignore',
-          timeout: 1000,
-        })
-      } else {
-        execSync(`${this.binShell} -n -c ${quotedCommand}`, {
-          stdio: 'ignore',
-          timeout: 1000,
-        })
-      }
-    } catch (stderr) {
-      // If there's a syntax error, return an error and log it
-      const errorStr =
-        typeof stderr === 'string' ? stderr : String(stderr || '')
-      logEvent('persistent_shell_syntax_error', {
-        error: errorStr.substring(0, 10),
-      })
-      return Promise.resolve({
-        stdout: '',
-        stderr: errorStr,
-        code: 128,
-        interrupted: false,
-      })
-    }
-
-    const commandTimeout = timeout || DEFAULT_TIMEOUT
-    // Reset interrupted state for new command
-    this.commandInterrupted = false
-    return new Promise<ExecResult>(resolve => {
-      // Truncate output files
-      fs.writeFileSync(this.stdoutFile, '')
-      fs.writeFileSync(this.stderrFile, '')
-      fs.writeFileSync(this.statusFile, '')
-      // Break up the command sequence for clarity using an array of commands
-      const commandParts = []
-
-      // 1. Execute the main command with redirections
-      commandParts.push(
-        `eval ${quotedCommand} < /dev/null > ${quoteForBash(this.stdoutFileBashPath)} 2> ${quoteForBash(this.stderrFileBashPath)}`,
-      )
-
-      // 2. Capture exit code immediately after command execution to avoid losing it
-      commandParts.push(`EXEC_EXIT_CODE=$?`)
-
-      // 3. Update CWD file
-      commandParts.push(`pwd > ${quoteForBash(this.cwdFileBashPath)}`)
-
-      // 4. Write the preserved exit code to status file to avoid race with pwd
-      commandParts.push(`echo $EXEC_EXIT_CODE > ${quoteForBash(this.statusFileBashPath)}`)
-
-      // Send the combined commands as a single operation to maintain atomicity
-      this.sendToShell(commandParts.join('\n'))
-
-      // Check for command completion or timeout
-      const start = Date.now()
-      const checkCompletion = setInterval(() => {
-        try {
-          let statusFileSize = 0
-          if (fs.existsSync(this.statusFile)) {
-            statusFileSize = fs.statSync(this.statusFile).size
-          }
-
-          if (
-            statusFileSize > 0 ||
-            Date.now() - start > commandTimeout ||
-            this.commandInterrupted
-          ) {
-            clearInterval(checkCompletion)
-            const stdout = fs.existsSync(this.stdoutFile)
-              ? fs.readFileSync(this.stdoutFile, 'utf8')
-              : ''
-            let stderr = fs.existsSync(this.stderrFile)
-              ? fs.readFileSync(this.stderrFile, 'utf8')
-              : ''
-            let code: number
-            if (statusFileSize) {
-              code = Number(fs.readFileSync(this.statusFile, 'utf8'))
-            } else {
-              // Timeout occurred - kill any running processes
-              this.killChildren()
-              code = SIGTERM_CODE
-              stderr += (stderr ? '\n' : '') + 'Command execution timed out'
-              logEvent('persistent_shell_command_timeout', {
-                command: command.substring(0, 10),
-                timeout: commandTimeout.toString(),
-              })
-            }
-            resolve({
-              stdout,
-              stderr,
-              code,
-              interrupted: this.commandInterrupted,
-            })
-          }
-        } catch {
-          // Ignore file system errors during polling - they are expected
-          // as we check for completion before files exist
-        }
-      }, 10) // increasing this will introduce latency
-    })
-  }
-
-  private sendToShell(command: string) {
-    try {
-      this.shell!.stdin!.write(command + '\n')
-    } catch (error) {
-      const errorString =
-        error instanceof Error
-          ? error.message
-          : String(error || 'Unknown error')
-      logError(`Error in sendToShell: ${errorString}`)
-      logEvent('persistent_shell_write_error', {
-        error: errorString.substring(0, 100),
-        command: command.substring(0, 30),
-      })
-      throw error
-    }
-  }
-
-  pwd(): string {
-    try {
-      const newCwd = fs.readFileSync(this.cwdFile, 'utf8').trim()
-      if (newCwd) {
-        this.cwd = newCwd
-      }
-    } catch (error) {
-      logError(`Shell pwd error ${error}`)
-    }
-    // Always return the cached value
-    return this.cwd
-  }
-
-  async setCwd(cwd: string) {
-    const resolved = isAbsolute(cwd) ? cwd : resolve(process.cwd(), cwd)
-    if (!existsSync(resolved)) {
-      throw new Error(`Path "${resolved}" does not exist`)
-    }
-    const bashPath = toBashPath(resolved, this.shellType)
-    await this.exec(`cd ${quoteForBash(bashPath)}`)
-  }
-
-  close(): void {
-    this.shell!.stdin!.end()
-    this.shell.kill()
-  }
-}