subagent-cli 0.3.0 → 0.3.1

package/src/utils/dxt/zip.ts

@@ -1,226 +0,0 @@
-import { isAbsolute, normalize } from 'path'
-import { logForDebugging } from '../debug.js'
-import { isENOENT } from '../errors.js'
-import { getFsImplementation } from '../fsOperations.js'
-import { containsPathTraversal } from '../path.js'
-
-const LIMITS = {
-  MAX_FILE_SIZE: 512 * 1024 * 1024, // 512MB per file
-  MAX_TOTAL_SIZE: 1024 * 1024 * 1024, // 1024MB total uncompressed
-  MAX_FILE_COUNT: 100000, // Maximum number of files
-  MAX_COMPRESSION_RATIO: 50, // Anything above 50:1 is suspicious
-  MIN_COMPRESSION_RATIO: 0.5, // Below 0.5:1 might indicate already compressed malicious content
-}
-
-/**
- * State tracker for zip file validation during extraction
- */
-type ZipValidationState = {
-  fileCount: number
-  totalUncompressedSize: number
-  compressedSize: number
-  errors: string[]
-}
-
-/**
- * File metadata from fflate filter
- */
-type ZipFileMetadata = {
-  name: string
-  originalSize?: number
-}
-
-/**
- * Result of validating a single file in a zip archive
- */
-type FileValidationResult = {
-  isValid: boolean
-  error?: string
-}
-
-/**
- * Validates a file path to prevent path traversal attacks
- */
-export function isPathSafe(filePath: string): boolean {
-  if (containsPathTraversal(filePath)) {
-    return false
-  }
-
-  // Normalize the path to resolve any '.' segments
-  const normalized = normalize(filePath)
-
-  // Check for absolute paths (we only want relative paths in archives)
-  if (isAbsolute(normalized)) {
-    return false
-  }
-
-  return true
-}
-
-/**
- * Validates a single file during zip extraction
- */
-export function validateZipFile(
-  file: ZipFileMetadata,
-  state: ZipValidationState,
-): FileValidationResult {
-  state.fileCount++
-
-  let error: string | undefined
-
-  // Check file count
-  if (state.fileCount > LIMITS.MAX_FILE_COUNT) {
-    error = `Archive contains too many files: ${state.fileCount} (max: ${LIMITS.MAX_FILE_COUNT})`
-  }
-
-  // Validate path safety
-  if (!isPathSafe(file.name)) {
-    error = `Unsafe file path detected: "${file.name}". Path traversal or absolute paths are not allowed.`
-  }
-
-  // Check individual file size
-  const fileSize = file.originalSize || 0
-  if (fileSize > LIMITS.MAX_FILE_SIZE) {
-    error = `File "${file.name}" is too large: ${Math.round(fileSize / 1024 / 1024)}MB (max: ${Math.round(LIMITS.MAX_FILE_SIZE / 1024 / 1024)}MB)`
-  }
-
-  // Track total uncompressed size
-  state.totalUncompressedSize += fileSize
-
-  // Check total size
-  if (state.totalUncompressedSize > LIMITS.MAX_TOTAL_SIZE) {
-    error = `Archive total size is too large: ${Math.round(state.totalUncompressedSize / 1024 / 1024)}MB (max: ${Math.round(LIMITS.MAX_TOTAL_SIZE / 1024 / 1024)}MB)`
-  }
-
-  // Check compression ratio for zip bomb detection
-  const currentRatio = state.totalUncompressedSize / state.compressedSize
-  if (currentRatio > LIMITS.MAX_COMPRESSION_RATIO) {
-    error = `Suspicious compression ratio detected: ${currentRatio.toFixed(1)}:1 (max: ${LIMITS.MAX_COMPRESSION_RATIO}:1). This may be a zip bomb.`
-  }
-
-  return error ? { isValid: false, error } : { isValid: true }
-}
-
-/**
- * Unzips data from a Buffer and returns its contents as a record of file paths to Uint8Array data.
- * Uses unzipSync to avoid fflate worker termination crashes in bun.
- * Accepts raw zip bytes so that the caller can read the file asynchronously.
- *
- * fflate is lazy-imported to avoid its ~196KB of top-level lookup tables (revfd
- * Int32Array(32769), rev Uint16Array(32768), etc.) being allocated at startup
- * when this module is reached via the plugin loader chain.
- */
-export async function unzipFile(
-  zipData: Buffer,
-): Promise<Record<string, Uint8Array>> {
-  const { unzipSync } = await import('fflate')
-  const compressedSize = zipData.length
-
-  const state: ZipValidationState = {
-    fileCount: 0,
-    totalUncompressedSize: 0,
-    compressedSize: compressedSize,
-    errors: [],
-  }
-
-  const result = unzipSync(new Uint8Array(zipData), {
-    filter: file => {
-      const validationResult = validateZipFile(file, state)
-      if (!validationResult.isValid) {
-        throw new Error(validationResult.error!)
-      }
-      return true
-    },
-  })
-
-  logForDebugging(
-    `Zip extraction completed: ${state.fileCount} files, ${Math.round(state.totalUncompressedSize / 1024)}KB uncompressed`,
-  )
-
-  return result
-}
-
-/**
- * Parse Unix file modes from a zip's central directory.
- *
- * fflate's `unzipSync` returns only `Record<string, Uint8Array>` — it does not
- * surface the external file attributes stored in the central directory. This
- * means executable bits are lost during extraction (everything becomes 0644).
- * The git-clone path preserves +x natively, but the GCS/zip path needs this
- * helper to keep parity.
- *
- * Returns `name → mode` for entries created on a Unix host (`versionMadeBy`
- * high byte === 3). Entries from other hosts, or with no mode bits set, are
- * omitted. Callers should treat a missing key as "use default mode".
- *
- * Format per PKZIP APPNOTE.TXT §4.3.12 (central directory) and §4.3.16 (EOCD).
- * ZIP64 is not handled — returns `{}` on archives >4GB or >65535 entries,
- * which is fine for marketplace zips (~3.5MB) and MCPB bundles.
- */
-export function parseZipModes(data: Uint8Array): Record<string, number> {
-  // Buffer view for readUInt* methods — shares memory, no copy.
-  const buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength)
-  const modes: Record<string, number> = {}
-
-  // 1. Find the End of Central Directory record (sig 0x06054b50). It lives in
-  //    the trailing 22 + 65535 bytes (fixed EOCD size + max comment length).
-  //    Scan backwards — the EOCD is typically the last 22 bytes.
-  const minEocd = Math.max(0, buf.length - 22 - 0xffff)
-  let eocd = -1
-  for (let i = buf.length - 22; i >= minEocd; i--) {
-    if (buf.readUInt32LE(i) === 0x06054b50) {
-      eocd = i
-      break
-    }
-  }
-  if (eocd < 0) return modes // malformed — let fflate's error surface elsewhere
-
-  const entryCount = buf.readUInt16LE(eocd + 10)
-  let off = buf.readUInt32LE(eocd + 16) // central directory start offset
-
-  // 2. Walk central directory entries (sig 0x02014b50). Each entry has a
-  //    46-byte fixed header followed by variable-length name/extra/comment.
-  for (let i = 0; i < entryCount; i++) {
-    if (off + 46 > buf.length || buf.readUInt32LE(off) !== 0x02014b50) break
-    const versionMadeBy = buf.readUInt16LE(off + 4)
-    const nameLen = buf.readUInt16LE(off + 28)
-    const extraLen = buf.readUInt16LE(off + 30)
-    const commentLen = buf.readUInt16LE(off + 32)
-    const externalAttr = buf.readUInt32LE(off + 38)
-    const name = buf.toString('utf8', off + 46, off + 46 + nameLen)
-
-    // versionMadeBy high byte = host OS. 3 = Unix. For Unix zips, the high
-    // 16 bits of externalAttr hold st_mode (file type + permission bits).
-    if (versionMadeBy >> 8 === 3) {
-      const mode = (externalAttr >>> 16) & 0xffff
-      if (mode) modes[name] = mode
-    }
-
-    off += 46 + nameLen + extraLen + commentLen
-  }
-
-  return modes
-}
-
-/**
- * Reads a zip file from disk asynchronously and unzips it.
- * Returns its contents as a record of file paths to Uint8Array data.
- */
-export async function readAndUnzipFile(
-  filePath: string,
-): Promise<Record<string, Uint8Array>> {
-  const fs = getFsImplementation()
-
-  try {
-    const zipData = await fs.readFileBytes(filePath)
-    // await is required here: without it, rejections from the now-async
-    // unzipFile() escape the try/catch and bypass the error wrapping below.
-    return await unzipFile(zipData)
-  } catch (error) {
-    if (isENOENT(error)) {
-      throw error
-    }
-    const errorMessage = error instanceof Error ? error.message : String(error)
-    throw new Error(`Failed to read or unzip file: ${errorMessage}`)
-  }
-}

package/src/utils/earlyInput.ts

@@ -1,191 +0,0 @@
-/**
- * Early Input Capture
- *
- * This module captures terminal input that is typed before the REPL is fully
- * initialized. Users often type `claude` and immediately start typing their
- * prompt, but those early keystrokes would otherwise be lost during startup.
- *
- * Usage:
- * 1. Call startCapturingEarlyInput() as early as possible in cli.tsx
- * 2. When REPL is ready, call consumeEarlyInput() to get any buffered text
- * 3. stopCapturingEarlyInput() is called automatically when input is consumed
- */
-
-import { lastGrapheme } from './intl.js'
-
-// Buffer for early input characters
-let earlyInputBuffer = ''
-// Flag to track if we're currently capturing
-let isCapturing = false
-// Reference to the readable handler so we can remove it later
-let readableHandler: (() => void) | null = null
-
-/**
- * Start capturing stdin data early, before the REPL is initialized.
- * Should be called as early as possible in the startup sequence.
- *
- * Only captures if stdin is a TTY (interactive terminal).
- */
-export function startCapturingEarlyInput(): void {
-  // Only capture in interactive mode: stdin must be a TTY, and we must not
-  // be in print mode. Raw mode disables ISIG (terminal Ctrl+C → SIGINT),
-  // which would make -p uninterruptible.
-  if (
-    !process.stdin.isTTY ||
-    isCapturing ||
-    process.argv.includes('-p') ||
-    process.argv.includes('--print')
-  ) {
-    return
-  }
-
-  isCapturing = true
-  earlyInputBuffer = ''
-
-  // Set stdin to raw mode and use 'readable' event like Ink does
-  // This ensures compatibility with how the REPL will handle stdin later
-  try {
-    process.stdin.setEncoding('utf8')
-    process.stdin.setRawMode(true)
-    process.stdin.ref()
-
-    readableHandler = () => {
-      let chunk = process.stdin.read()
-      while (chunk !== null) {
-        if (typeof chunk === 'string') {
-          processChunk(chunk)
-        }
-        chunk = process.stdin.read()
-      }
-    }
-
-    process.stdin.on('readable', readableHandler)
-  } catch {
-    // If we can't set raw mode, just silently continue without early capture
-    isCapturing = false
-  }
-}
-
-/**
- * Process a chunk of input data
- */
-function processChunk(str: string): void {
-  let i = 0
-  while (i < str.length) {
-    const char = str[i]!
-    const code = char.charCodeAt(0)
-
-    // Ctrl+C (code 3) - stop capturing and exit immediately.
-    // We use process.exit here instead of gracefulShutdown because at this
-    // early stage of startup, the shutdown machinery isn't initialized yet.
-    if (code === 3) {
-      stopCapturingEarlyInput()
-      // eslint-disable-next-line custom-rules/no-process-exit
-      process.exit(130) // Standard exit code for Ctrl+C
-      return
-    }
-
-    // Ctrl+D (code 4) - EOF, stop capturing
-    if (code === 4) {
-      stopCapturingEarlyInput()
-      return
-    }
-
-    // Backspace (code 127 or 8) - remove last grapheme cluster
-    if (code === 127 || code === 8) {
-      if (earlyInputBuffer.length > 0) {
-        const last = lastGrapheme(earlyInputBuffer)
-        earlyInputBuffer = earlyInputBuffer.slice(0, -(last.length || 1))
-      }
-      i++
-      continue
-    }
-
-    // Skip escape sequences (arrow keys, function keys, focus events, etc.)
-    // All escape sequences start with ESC (0x1B) and end with a byte in 0x40-0x7E
-    if (code === 27) {
-      i++ // Skip the ESC character
-      // Skip until the terminating byte (@ to ~) or end of string
-      while (
-        i < str.length &&
-        !(str.charCodeAt(i) >= 64 && str.charCodeAt(i) <= 126)
-      ) {
-        i++
-      }
-      if (i < str.length) i++ // Skip the terminating byte
-      continue
-    }
-
-    // Skip other control characters (except tab and newline)
-    if (code < 32 && code !== 9 && code !== 10 && code !== 13) {
-      i++
-      continue
-    }
-
-    // Convert carriage return to newline
-    if (code === 13) {
-      earlyInputBuffer += '\n'
-      i++
-      continue
-    }
-
-    // Add printable characters and allowed control chars to buffer
-    earlyInputBuffer += char
-    i++
-  }
-}
-
-/**
- * Stop capturing early input.
- * Called automatically when input is consumed, or can be called manually.
- */
-export function stopCapturingEarlyInput(): void {
-  if (!isCapturing) {
-    return
-  }
-
-  isCapturing = false
-
-  if (readableHandler) {
-    process.stdin.removeListener('readable', readableHandler)
-    readableHandler = null
-  }
-
-  // Don't reset stdin state - the REPL's Ink App will manage stdin state.
-  // If we call setRawMode(false) here, it can interfere with the REPL's
-  // own stdin setup which happens around the same time.
-}
-
-/**
- * Consume any early input that was captured.
- * Returns the captured input and clears the buffer.
- * Automatically stops capturing when called.
- */
-export function consumeEarlyInput(): string {
-  stopCapturingEarlyInput()
-  const input = earlyInputBuffer.trim()
-  earlyInputBuffer = ''
-  return input
-}
-
-/**
- * Check if there is any early input available without consuming it.
- */
-export function hasEarlyInput(): boolean {
-  return earlyInputBuffer.trim().length > 0
-}
-
-/**
- * Seed the early input buffer with text that will appear pre-filled
- * in the prompt input when the REPL renders. Does not auto-submit.
- */
-export function seedEarlyInput(text: string): void {
-  earlyInputBuffer = text
-}
-
-/**
- * Check if early input capture is currently active.
- */
-export function isCapturingEarlyInput(): boolean {
-  return isCapturing
-}

package/src/utils/editor.ts

@@ -1,183 +0,0 @@
-import {
-  type SpawnOptions,
-  type SpawnSyncOptions,
-  spawn,
-  spawnSync,
-} from 'child_process'
-import memoize from 'lodash-es/memoize.js'
-import { basename } from 'path'
-import instances from '../ink/instances.js'
-import { logForDebugging } from './debug.js'
-import { whichSync } from './which.js'
-
-function isCommandAvailable(command: string): boolean {
-  return !!whichSync(command)
-}
-
-// GUI editors that open in a separate window and can be spawned detached
-// without fighting the TUI for stdin. VS Code forks (cursor, windsurf, codium)
-// are listed explicitly since none contain 'code' as a substring.
-const GUI_EDITORS = [
-  'code',
-  'cursor',
-  'windsurf',
-  'codium',
-  'subl',
-  'atom',
-  'gedit',
-  'notepad++',
-  'notepad',
-]
-
-// Editors that accept +N as a goto-line argument. The Windows default
-// ('start /wait notepad') does not — notepad treats +42 as a filename.
-const PLUS_N_EDITORS = /\b(vi|vim|nvim|nano|emacs|pico|micro|helix|hx)\b/
-
-// VS Code and forks use -g file:line. subl uses bare file:line (no -g).
-const VSCODE_FAMILY = new Set(['code', 'cursor', 'windsurf', 'codium'])
-
-/**
- * Classify the editor as GUI or not. Returns the matched GUI family name
- * for goto-line argv selection, or undefined for terminal editors.
- * Note: this is classification only — spawn the user's actual binary, not
- * this return value, so `code-insiders` / absolute paths are preserved.
- *
- * Uses basename so /home/alice/code/bin/nvim doesn't match 'code' via the
- * directory component. code-insiders → still matches 'code', /usr/bin/code →
- * 'code' → matches.
- */
-export function classifyGuiEditor(editor: string): string | undefined {
-  const base = basename(editor.split(' ')[0] ?? '')
-  return GUI_EDITORS.find(g => base.includes(g))
-}
-
-/**
- * Build goto-line argv for a GUI editor. VS Code family uses -g file:line;
- * subl uses bare file:line; others don't support goto-line.
- */
-function guiGotoArgv(
-  guiFamily: string,
-  filePath: string,
-  line: number | undefined,
-): string[] {
-  if (!line) return [filePath]
-  if (VSCODE_FAMILY.has(guiFamily)) return ['-g', `${filePath}:${line}`]
-  if (guiFamily === 'subl') return [`${filePath}:${line}`]
-  return [filePath]
-}
-
-/**
- * Launch a file in the user's external editor.
- *
- * For GUI editors (code, subl, etc.): spawns detached — the editor opens
- * in a separate window and Claude Code stays interactive.
- *
- * For terminal editors (vim, nvim, nano, etc.): blocks via Ink's alt-screen
- * handoff until the editor exits. This is the same dance as editFileInEditor()
- * in promptEditor.ts, minus the read-back.
- *
- * Returns true if the editor was launched, false if no editor is available.
- */
-export function openFileInExternalEditor(
-  filePath: string,
-  line?: number,
-): boolean {
-  const editor = getExternalEditor()
-  if (!editor) return false
-
-  // Spawn the user's actual binary (preserves code-insiders, abs paths, etc.).
-  // Split into binary + extra args so multi-word values like 'start /wait
-  // notepad' or 'code --wait' propagate all tokens to spawn.
-  const parts = editor.split(' ')
-  const base = parts[0] ?? editor
-  const editorArgs = parts.slice(1)
-  const guiFamily = classifyGuiEditor(editor)
-
-  if (guiFamily) {
-    const gotoArgv = guiGotoArgv(guiFamily, filePath, line)
-    const detachedOpts: SpawnOptions = { detached: true, stdio: 'ignore' }
-    let child
-    if (process.platform === 'win32') {
-      // shell: true on win32 so code.cmd / cursor.cmd / windsurf.cmd resolve —
-      // CreateProcess can't execute .cmd/.bat directly. Assemble quoted command
-      // string; cmd.exe doesn't expand $() or backticks inside double quotes.
-      // Quote each arg so paths with spaces survive the shell join.
-      const gotoStr = gotoArgv.map(a => `"${a}"`).join(' ')
-      child = spawn(`${editor} ${gotoStr}`, { ...detachedOpts, shell: true })
-    } else {
-      // POSIX: argv array with no shell — injection-safe. shell: true would
-      // expand $() / backticks inside double quotes, and filePath is
-      // filesystem-sourced (possible RCE from a malicious repo filename).
-      child = spawn(base, [...editorArgs, ...gotoArgv], detachedOpts)
-    }
-    // spawn() emits ENOENT asynchronously. ENOENT on $VISUAL/$EDITOR is a
-    // user-config error, not an internal bug — don't pollute error telemetry.
-    child.on('error', e =>
-      logForDebugging(`editor spawn failed: ${e}`, { level: 'error' }),
-    )
-    child.unref()
-    return true
-  }
-
-  // Terminal editor — needs alt-screen handoff since it takes over the
-  // terminal. Blocks until the editor exits.
-  const inkInstance = instances.get(process.stdout)
-  if (!inkInstance) return false
-  // Only prepend +N for editors known to support it — notepad treats +42 as a
-  // filename to open. Test basename so /home/vim/bin/kak doesn't match 'vim'
-  // via the directory segment.
-  const useGotoLine = line && PLUS_N_EDITORS.test(basename(base))
-  inkInstance.enterAlternateScreen()
-  try {
-    const syncOpts: SpawnSyncOptions = { stdio: 'inherit' }
-    let result
-    if (process.platform === 'win32') {
-      // On Windows use shell: true so cmd.exe builtins like `start` resolve.
-      // shell: true joins args unquoted, so assemble the command string with
-      // explicit quoting ourselves (matching promptEditor.ts:74). spawnSync
-      // returns errors in .error rather than throwing.
-      const lineArg = useGotoLine ? `+${line} ` : ''
-      result = spawnSync(`${editor} ${lineArg}"${filePath}"`, {
-        ...syncOpts,
-        shell: true,
-      })
-    } else {
-      // POSIX: spawn directly (no shell), argv array is quote-safe.
-      const args = [
-        ...editorArgs,
-        ...(useGotoLine ? [`+${line}`, filePath] : [filePath]),
-      ]
-      result = spawnSync(base, args, syncOpts)
-    }
-    if (result.error) {
-      logForDebugging(`editor spawn failed: ${result.error}`, {
-        level: 'error',
-      })
-      return false
-    }
-    return true
-  } finally {
-    inkInstance.exitAlternateScreen()
-  }
-}
-
-export const getExternalEditor = memoize((): string | undefined => {
-  // Prioritize environment variables
-  if (process.env.VISUAL?.trim()) {
-    return process.env.VISUAL.trim()
-  }
-
-  if (process.env.EDITOR?.trim()) {
-    return process.env.EDITOR.trim()
-  }
-
-  // `isCommandAvailable` breaks the claude process' stdin on Windows
-  // as a bandaid, we skip it
-  if (process.platform === 'win32') {
-    return 'start /wait notepad'
-  }
-
-  // Search for available editors in order of preference
-  const editors = ['code', 'vi', 'nano']
-  return editors.find(command => isCommandAvailable(command))
-})