@xelauvas/xela-cli 0.1.0

package/src/utils/dxt/zip.ts

@@ -0,0 +1,226 @@
+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

@@ -0,0 +1,191 @@
+/**
+ * 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

@@ -0,0 +1,183 @@
+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))
+})