savant-code 0.0.19 → 0.0.21

package/cli/src/utils/terminal-images.ts

@@ -1,223 +0,0 @@
-/**
- * Terminal image rendering utilities
- * Supports iTerm2 inline images protocol and Kitty graphics protocol
- */
-
-import { getCliEnv } from './env'
-
-import type { CliEnv } from '../types/env'
-
-export type TerminalImageProtocol = 'iterm2' | 'kitty' | 'sixel' | 'none'
-
-let cachedProtocol: TerminalImageProtocol | null = null
-
-/**
- * Detect which image protocol the terminal supports
- */
-export function detectTerminalImageSupport(
-  env: CliEnv = getCliEnv(),
-): TerminalImageProtocol {
-  if (cachedProtocol !== null) {
-    return cachedProtocol
-  }
-
-  // Check for iTerm2
-  if (env.TERM_PROGRAM === 'iTerm.app') {
-    cachedProtocol = 'iterm2'
-    return cachedProtocol
-  }
-
-  // Check for Kitty
-  if (env.TERM === 'xterm-kitty' || env.KITTY_WINDOW_ID !== undefined) {
-    cachedProtocol = 'kitty'
-    return cachedProtocol
-  }
-
-  // Check for Sixel support (less common)
-  if (env.TERM?.includes('sixel') || env.SIXEL_SUPPORT === 'true') {
-    cachedProtocol = 'sixel'
-    return cachedProtocol
-  }
-
-  cachedProtocol = 'none'
-  return cachedProtocol
-}
-
-/**
- * Check if terminal supports inline images
- */
-export function supportsInlineImages(): boolean {
-  return detectTerminalImageSupport() !== 'none'
-}
-
-/**
- * Generate iTerm2 inline image escape sequence
- * @param base64Data - Base64 encoded image data
- * @param options - Display options
- */
-function generateITerm2ImageSequence(
-  base64Data: string,
-  options: {
-    width?: number | string // cells or 'auto'
-    height?: number | string // cells or 'auto'
-    preserveAspectRatio?: boolean
-    inline?: boolean
-    name?: string
-  } = {},
-): string {
-  const {
-    width = 'auto',
-    height = 'auto',
-    preserveAspectRatio = true,
-    inline = true,
-    name,
-  } = options
-
-  // Build the parameter string
-  const params: string[] = []
-
-  if (inline) {
-    params.push('inline=1')
-  }
-
-  if (width !== 'auto') {
-    params.push(`width=${width}`)
-  }
-
-  if (height !== 'auto') {
-    params.push(`height=${height}`)
-  }
-
-  if (!preserveAspectRatio) {
-    params.push('preserveAspectRatio=0')
-  }
-
-  if (name) {
-    params.push(`name=${Buffer.from(name).toString('base64')}`)
-  }
-
-  // Add size parameter (required)
-  params.push(`size=${base64Data.length}`)
-
-  const paramString = params.join(';')
-
-  // Format: ESC ] 1337 ; File = [params] : base64data BEL
-  // Using \x1b for ESC and \x07 for BEL
-  return `\x1b]1337;File=${paramString}:${base64Data}\x07`
-}
-
-/**
- * Generate Kitty graphics protocol escape sequence
- * @param base64Data - Base64 encoded image data
- * @param options - Display options
- */
-function generateKittyImageSequence(
-  base64Data: string,
-  options: {
-    width?: number // cells
-    height?: number // cells
-    id?: number
-  } = {},
-): string {
-  const { width, height, id } = options
-
-  // Build key-value pairs for the control data
-  const kvPairs: string[] = [
-    'a=T', // action: transmit and display
-    'f=100', // format: PNG (100) - let Kitty auto-detect
-    't=d', // transmission: direct (data follows)
-  ]
-
-  if (width) {
-    kvPairs.push(`c=${width}`) // columns
-  }
-
-  if (height) {
-    kvPairs.push(`r=${height}`) // rows
-  }
-
-  if (id) {
-    kvPairs.push(`i=${id}`) // image id
-  }
-
-  const controlData = kvPairs.join(',')
-
-  // Kitty requires chunked transmission for large images
-  // For simplicity, we'll send in one chunk if small enough
-  const CHUNK_SIZE = 4096
-
-  if (base64Data.length <= CHUNK_SIZE) {
-    // Single chunk: ESC _ G <control> ; <data> ESC \
-    return `\x1b_G${controlData};${base64Data}\x1b\\`
-  }
-
-  // Multi-chunk transmission
-  const chunks: string[] = []
-  for (let i = 0; i < base64Data.length; i += CHUNK_SIZE) {
-    const chunk = base64Data.slice(i, i + CHUNK_SIZE)
-    const isLast = i + CHUNK_SIZE >= base64Data.length
-    const chunkControl = isLast ? controlData : `${controlData},m=1` // m=1 means more chunks coming
-    chunks.push(`\x1b_G${chunkControl};${chunk}\x1b\\`)
-  }
-
-  return chunks.join('')
-}
-
-/**
- * Render an image inline in the terminal
- * @param base64Data - Base64 encoded image data
- * @param options - Display options
- * @returns The escape sequence string, or null if not supported
- */
-export function renderInlineImage(
-  base64Data: string,
-  options: {
-    width?: number
-    height?: number
-    filename?: string
-  } = {},
-): string | null {
-  const protocol = detectTerminalImageSupport()
-
-  switch (protocol) {
-    case 'iterm2':
-      return generateITerm2ImageSequence(base64Data, {
-        width: options.width,
-        height: options.height,
-        name: options.filename,
-      })
-
-    case 'kitty':
-      return generateKittyImageSequence(base64Data, {
-        width: options.width,
-        height: options.height,
-      })
-
-    case 'sixel':
-      // Sixel is more complex and requires actual image decoding
-      // For now, return null and fall back to metadata display
-      return null
-
-    case 'none':
-    default:
-      return null
-  }
-}
-
-/**
- * Get a user-friendly description of the terminal image support
- */
-export function getImageSupportDescription(): string {
-  const protocol = detectTerminalImageSupport()
-
-  switch (protocol) {
-    case 'iterm2':
-      return 'iTerm2 inline images'
-    case 'kitty':
-      return 'Kitty graphics protocol'
-    case 'sixel':
-      return 'Sixel graphics'
-    case 'none':
-      return 'No inline image support'
-  }
-}

package/cli/src/utils/terminal-reset-sequences.ts

@@ -1,33 +0,0 @@
-/**
- * Terminal escape sequences to reset terminal state.
- * Shared by the in-process cleanup handlers (renderer-cleanup.ts) and the
- * sacrificial watchdog process (terminal-watchdog.ts).
- *
- * Keep this list in sync with the modes OpenTUI enables (see the enable
- * sequences in @opentui/core's native lib) and with
- * SAFE_TERMINAL_RESET_SEQUENCES in the npm release launcher
- * (cli/release-core/launcher.js).
- *
- * Sequences:
- * - \x1b[?1049l: Exit alternate screen buffer (restores main screen)
- * - \x1b[?1000l: Disable X10 mouse mode
- * - \x1b[?1002l: Disable button event mouse mode
- * - \x1b[?1003l: Disable any-event mouse mode (all motion tracking)
- * - \x1b[?1006l: Disable SGR extended mouse mode
- * - \x1b[?1004l: Disable focus reporting
- * - \x1b[?2004l: Disable bracketed paste mode
- * - \x1b[<u:     Pop the kitty keyboard protocol flags OpenTUI pushes
- * - \x1b[>4;0m:  Reset xterm modifyOtherKeys (OpenTUI sets [>4;1m)
- * - \x1b[?25h:   Show cursor (safety measure)
- */
-export const TERMINAL_RESET_SEQUENCES =
-  '\x1b[?1049l' + // Exit alternate screen buffer
-  '\x1b[?1000l' + // Disable X10 mouse mode
-  '\x1b[?1002l' + // Disable button event mouse mode
-  '\x1b[?1003l' + // Disable any-event mouse mode (all motion)
-  '\x1b[?1006l' + // Disable SGR extended mouse mode
-  '\x1b[?1004l' + // Disable focus reporting
-  '\x1b[?2004l' + // Disable bracketed paste mode
-  '\x1b[<u' + // Pop kitty keyboard protocol flags
-  '\x1b[>4;0m' + // Reset modifyOtherKeys
-  '\x1b[?25h' // Show cursor

package/cli/src/utils/terminal-title.ts

@@ -1,113 +0,0 @@
-/**
- * Terminal title utilities using OSC (Operating System Command) escape sequences.
- *
- * OSC sequence format for setting title:
- * - `\x1b]0;${title}\x07` - Sets both window title and icon name
- * - `\x1b` is ESC, `]0;` starts the title command, `\x07` (BEL) ends it
- *
- * We write directly to /dev/tty to bypass OpenTUI's stdout capture,
- * similar to how clipboard.ts handles OSC52 sequences.
- */
-
-import { closeSync, constants, openSync, writeSync } from 'fs'
-
-import { IS_SAVANT_FREE } from './constants'
-import { getCliEnv } from './env'
-
-const MAX_TITLE_LENGTH = 60
-const TITLE_PREFIX = IS_SAVANT_FREE ? 'SavantFree: ' : 'SavantCode: '
-const OSC_TERMINATOR = '\x07' // BEL
-
-function isInTmux(env: ReturnType<typeof getCliEnv>): boolean {
-  return Boolean(env.TMUX)
-}
-
-function isInScreen(env: ReturnType<typeof getCliEnv>): boolean {
-  if (env.STY) return true
-  const term = env.TERM ?? ''
-  return term.startsWith('screen') && !isInTmux(env)
-}
-
-/**
- * Build the OSC title sequence with tmux/screen passthrough if needed
- */
-function buildTitleSequence(
-  title: string,
-  env: ReturnType<typeof getCliEnv>,
-): string {
-  const osc = `\x1b]0;${title}${OSC_TERMINATOR}`
-
-  // tmux passthrough: wrap in DCS and double ESC characters
-  if (isInTmux(env)) {
-    const escaped = osc.replace(/\x1b/g, '\x1b\x1b')
-    return `\x1bPtmux;${escaped}\x1b\\`
-  }
-
-  // GNU screen passthrough: wrap in DCS
-  if (isInScreen(env)) {
-    return `\x1bP${osc}\x1b\\`
-  }
-
-  return osc
-}
-
-/**
- * Write an escape sequence directly to the controlling terminal.
- * This bypasses OpenTUI's stdout capture by writing to /dev/tty directly.
- */
-function writeToTty(sequence: string): boolean {
-  const ttyPath = process.platform === 'win32' ? 'CON' : '/dev/tty'
-
-  let fd: number | null = null
-  try {
-    fd = openSync(ttyPath, constants.O_WRONLY)
-    writeSync(fd, sequence)
-    return true
-  } catch {
-    return false
-  } finally {
-    if (fd !== null) {
-      try {
-        closeSync(fd)
-      } catch {
-        // Ignore close errors
-      }
-    }
-  }
-}
-
-/**
- * Set the terminal window title.
- * Works on most modern terminal emulators, including through tmux and screen.
- *
- * @param title - The title to set (will be truncated if too long)
- */
-export function setTerminalTitle(title: string): void {
-  // Sanitize: remove control characters and newlines
-  const sanitized = title.replace(/[\x00-\x1f\x7f]/g, ' ').trim()
-  if (!sanitized) return
-
-  // Truncate to reasonable length
-  const maxInputLength = MAX_TITLE_LENGTH - TITLE_PREFIX.length
-  const truncated =
-    sanitized.length > maxInputLength
-      ? sanitized.slice(0, maxInputLength - 1) + '…'
-      : sanitized
-
-  const fullTitle = `${TITLE_PREFIX}${truncated}`
-  const env = getCliEnv()
-  const sequence = buildTitleSequence(fullTitle, env)
-
-  writeToTty(sequence)
-}
-
-/**
- * Reset the terminal title to the default.
- * Call this when the CLI exits to restore the terminal to a clean state.
- */
-export function resetTerminalTitle(): void {
-  // Empty title resets to terminal's default behavior
-  const env = getCliEnv()
-  const sequence = buildTitleSequence('', env)
-  writeToTty(sequence)
-}

package/cli/src/utils/terminal-watchdog.ts

@@ -1,246 +0,0 @@
-/**
- * Sacrificial watchdog process that resets the terminal if the CLI dies
- * without running its own cleanup (SIGKILL, native crash, group kill).
- *
- * The in-process handlers (renderer-cleanup.ts) cover catchable exits, and
- * the npm wrapper resets when it outlives the binary — but neither survives
- * `pkill -9 node`-style sweeps that take out the wrapper and binary together,
- * and dev/direct-binary runs have no wrapper at all. This covers those.
- *
- * POSIX:
- * - We spawn a detached `/bin/sh` whose stdin is a pipe from this process.
- *   `sh` isn't named node/bun/savant-code/savant-free, so process-name kill sweeps
- *   miss it, and `detached` puts it in its own session so process-group kills
- *   miss it too.
- * - The watchdog blocks on `cat` until the pipe hits EOF — which only happens
- *   when this process is gone, however it died — then writes the reset
- *   sequences to its stdout, which is a dup of our stdout (the terminal).
- *   It must NOT open /dev/tty: being in its own session it has no controlling
- *   terminal, so that open fails with ENXIO. Writing to an inherited tty fd
- *   needs no controlling terminal.
- * - On clean shutdown we SIGKILL the watchdog first (process.kill is
- *   synchronous), so it never fires and the normal cleanup path owns the
- *   terminal writes.
- *
- * Windows (closes the savant-code#843 after-exit gap, where the hosting
- * terminal keeps sending mouse/focus VT input that the shell echoes as
- * `^[[<35;12;7M` gibberish):
- * - Bun/libuv put direct children in a kill-on-job-close job object, so a
- *   plain child — detached or not — is terminated the moment we die
- *   (oven-sh/bun#31603) and can never fire. Grandchildren of job members are
- *   NOT added to the job (silent-breakaway semantics), so we launch a
- *   short-lived PowerShell bootstrap (in the job; its death doesn't matter)
- *   that uses Start-Process -NoNewWindow to spawn the real watchdog outside
- *   the job, attached to our console.
- * - The pipe/EOF trick can't cross the bootstrap hop, so the watchdog
- *   detects our death with `Wait-Process -Id <our pid>` instead, then writes
- *   the reset sequences to its console stdout (ConPTY forwards the disable
- *   sequences to the hosting terminal).
- * - We hold no handle to the grandchild, so clean shutdown can't kill it.
- *   Instead stopTerminalWatchdog() synchronously drops a disarm file; the
- *   watchdog checks it after Wait-Process and exits silently when present.
- * - Windows PowerShell 5.1 always exists and is invoked by absolute path.
- *   Scripts are passed as plain -Command text so the command lines stay
- *   human-readable in process listings (encoded PowerShell spawned by a CLI
- *   is a classic EDR/AV malware heuristic). They are deliberately built
- *   without double quotes, which makes that quoting-safe — see
- *   spawnWindowsWatchdog.
- * - Arming takes a few hundred ms (PowerShell boot); deaths inside that
- *   window fall back to the pre-existing behavior (npm wrapper or nothing).
- */
-import { spawn } from 'child_process'
-import { closeSync, openSync, writeFileSync } from 'fs'
-import os from 'os'
-import path from 'path'
-
-import { getCliEnv } from './env'
-import { TERMINAL_RESET_SEQUENCES } from './terminal-reset-sequences'
-
-import type { ChildProcess } from 'child_process'
-
-let watchdog: ChildProcess | null = null
-let disarmFilePath: string | null = null
-
-/** Read-only watchdog state for local process diagnostics. */
-export function getTerminalWatchdogDiagnostics() {
-  const external = disarmFilePath !== null
-  const childIsRunning = Boolean(
-    watchdog?.pid && watchdog.exitCode === null && watchdog.signalCode === null,
-  )
-  return {
-    armed: childIsRunning || external,
-    external,
-    pid: !external && childIsRunning ? watchdog?.pid : undefined,
-  }
-}
-
-/** Reset payload with ESC as printf-compatible octal escapes. */
-function printfPayload(): string {
-  return TERMINAL_RESET_SEQUENCES.replace(/\x1b/g, '\\033')
-}
-
-function spawnPosixWatchdog(overrideFd: number | null): ChildProcess {
-  // `cat` holds until our death closes the pipe; the reset then goes to the
-  // watchdog's stdout (see stdio below). The payload contains no quotes, so
-  // embedding it in single quotes is safe.
-  const script = `cat >/dev/null 2>&1; printf '${printfPayload()}'`
-  return spawn('/bin/sh', ['-c', script, 'terminal-reset-watchdog'], {
-    detached: true,
-    stdio: ['pipe', overrideFd ?? 'inherit', 'ignore'],
-  })
-}
-
-/** Single-quote a string for PowerShell (only ' needs escaping, by doubling). */
-function psQuote(value: string): string {
-  return `'${value.replace(/'/g, "''")}'`
-}
-
-function spawnWindowsWatchdog(options: {
-  ttyPath?: string
-  disarmPath: string
-}): ChildProcess {
-  // The payload rides as a numeric byte array, which keeps the script free of
-  // double quotes and string interpolation (the no-`"` invariant the quoting
-  // below relies on) and avoids any Console.Out encoding translation, so the
-  // reset payload arrives byte-exact.
-  const payloadBytes = Array.from(
-    Buffer.from(TERMINAL_RESET_SEQUENCES, 'ascii'),
-  ).join(',')
-  // Tests observe a file instead of the console; production writes to the
-  // watchdog's stdout, which is the console (Start-Process -NoNewWindow
-  // without redirection leaves the grandchild on our console's handles).
-  const writeResets = options.ttyPath
-    ? `[System.IO.File]::WriteAllBytes(${psQuote(options.ttyPath)}, $b)`
-    : '$s=[Console]::OpenStandardOutput(); $s.Write($b, 0, $b.Length); $s.Flush()'
-  // The armed marker lets tests wait out the bootstrap hop before killing
-  // the fixture; production never passes ttyPath so no marker is written.
-  const armedMarker = options.ttyPath
-    ? `[System.IO.File]::WriteAllText(${psQuote(options.ttyPath + '.armed')}, 'armed'); `
-    : ''
-  const watchdogScript =
-    armedMarker +
-    `try { Wait-Process -Id ${process.pid} -ErrorAction Stop } catch {}; ` +
-    `if (Test-Path -LiteralPath ${psQuote(options.disarmPath)}) { ` +
-    `Remove-Item -LiteralPath ${psQuote(options.disarmPath)} -Force -ErrorAction SilentlyContinue ` +
-    `} else { ` +
-    `$b=[byte[]](${payloadBytes}); ` +
-    `${writeResets} }`
-
-  // Windows PowerShell 5.1 ships with every supported Windows; use the
-  // absolute path so a broken PATH can't take out the safety net.
-  const systemRoot = getCliEnv().SystemRoot ?? 'C:\\Windows'
-  const powershell = path.join(
-    systemRoot,
-    'System32',
-    'WindowsPowerShell',
-    'v1.0',
-    'powershell.exe',
-  )
-
-  // Plain -Command (not -EncodedCommand) so the command lines are auditable
-  // in process listings — encoded PowerShell trips EDR/AV heuristics. This is
-  // quoting-safe because the watchdog script contains no `"` (paths are
-  // single-quoted, the payload is numeric): it survives as the one
-  // double-quoted region of the grandchild's argument string, which
-  // Start-Process passes verbatim (single pre-built -ArgumentList string). On
-  // the bootstrap's own command line those `"` are escaped as \" by spawn,
-  // which powershell.exe's argv tokenizer unescapes.
-  const watchdogArgs = `-NoProfile -NonInteractive -Command "${watchdogScript}"`
-  const bootstrapScript =
-    `Start-Process -FilePath ${psQuote(powershell)} ` +
-    `-ArgumentList ${psQuote(watchdogArgs)} -NoNewWindow`
-
-  return spawn(
-    powershell,
-    ['-NoProfile', '-NonInteractive', '-Command', bootstrapScript],
-    {
-      stdio: ['ignore', 'ignore', 'ignore'],
-    },
-  )
-}
-
-/**
- * Start the watchdog. Call once, before the TUI renderer starts enabling
- * terminal modes. No-op when stdout isn't a TTY (unless an explicit ttyPath
- * is injected, e.g. in tests), or if already started.
- *
- * @param options.ttyPath - Override the reset target (POSIX: the watchdog's
- *   stdout is pointed at this file; Windows: the watchdog writes the payload
- *   to this file and drops a `<ttyPath>.armed` marker once running). Tests
- *   inject a regular file here to observe what gets written.
- */
-export function startTerminalWatchdog(options?: { ttyPath?: string }): void {
-  if (watchdog) return
-  if (!options?.ttyPath && !process.stdout.isTTY) return
-
-  let overrideFd: number | null = null
-  try {
-    let child: ChildProcess
-    if (process.platform === 'win32') {
-      const disarmPath = path.join(
-        os.tmpdir(),
-        `savant-code-watchdog-disarm-${process.pid}-${Math.random().toString(36).slice(2)}`,
-      )
-      child = spawnWindowsWatchdog({ ttyPath: options?.ttyPath, disarmPath })
-      disarmFilePath = disarmPath
-    } else {
-      if (options?.ttyPath) {
-        overrideFd = openSync(options.ttyPath, 'w')
-      }
-      child = spawnPosixWatchdog(overrideFd)
-    }
-    child.on('error', () => {
-      watchdog = null
-      // A watchdog that never spawned will never consume the disarm file;
-      // don't leave stopTerminalWatchdog() writing one nothing will delete.
-      disarmFilePath = null
-    })
-    // Don't let the watchdog (or our write end of its pipe) hold the event
-    // loop open — the CLI must still be able to exit naturally. stdin is a
-    // Socket at runtime; its unref isn't in the Writable type.
-    child.unref()
-    child.stdin?.on('error', () => {})
-    ;(child.stdin as { unref?: () => void } | null)?.unref?.()
-    watchdog = child
-  } catch {
-    // Best-effort: no watchdog is the pre-existing behavior.
-  } finally {
-    if (overrideFd !== null) {
-      try {
-        closeSync(overrideFd) // the child holds its own dup
-      } catch {
-        // Ignore close errors
-      }
-    }
-  }
-}
-
-/**
- * Disarm the watchdog before it can fire. Called from the clean-shutdown path
- * (and safe to call multiple times). Synchronous, so it completes even inside
- * a process 'exit' handler.
- */
-export function stopTerminalWatchdog(): void {
-  const child = watchdog
-  const disarm = disarmFilePath
-  if (!child && !disarm) return
-  watchdog = null
-  disarmFilePath = null
-  if (disarm) {
-    // Windows: the real watchdog is a grandchild we hold no handle to; it
-    // checks for this file after our death and stays silent when present.
-    try {
-      writeFileSync(disarm, '')
-    } catch {
-      // Best-effort; worst case the watchdog writes resets on a clean exit,
-      // which the terminal treats as no-ops.
-    }
-  }
-  if (child) {
-    try {
-      child.kill('SIGKILL')
-    } catch {
-      // Already dead — nothing to stop.
-    }
-  }
-}