@alumbwe/anvil 1.0.0

package/src/pre-init/tree-sitter-wasm.ts

@@ -0,0 +1,96 @@
+// Find tree-sitter.wasm so the SDK's tree-sitter parser singleton can load
+// it at runtime. Must be the very first import in `index.tsx`: subsequent
+// imports (the SDK / code-map) eagerly construct the parser, and its init
+// reads what we publish here on `globalThis` and via the env var.
+//
+// Final approach after several attempts to embed the wasm into the bun
+// --compile binary all failed on Windows (the bytes ended up in the
+// binary, but every JS-level retrieval mechanism — `with { type: 'file' }`
+// import binding, base64 string literals, chunked base64 in a generated
+// module, function-export wrappers — was either tree-shaken, transformed
+// by the minifier, or otherwise stripped):
+//
+//   ship tree-sitter.wasm as a sibling file next to the binary.
+//
+// It's 200KB, the npm tarball already contains the binary; adding one
+// more file is trivial. The build script copies the wasm into `cli/bin/`
+// after compile, the release workflow tarballs both, and the freebuff /
+// anvil downloader extracts both into the same directory. At runtime,
+// `process.execPath` plus a relative file lookup gets us the wasm with
+// zero bundler involvement.
+
+import { existsSync, readFileSync } from 'fs'
+import { dirname, isAbsolute, join, resolve } from 'path'
+
+// Where to look for the sibling tree-sitter.wasm. We can't just use
+// `dirname(process.execPath)`: at pre-init time inside a bun --compile
+// binary on Windows, `process.execPath` returns the *bunfs* internal
+// path (`B:\~BUN\root\<binary>.exe`) rather than the on-disk path of
+// the .exe the user invoked. By the time main() runs it switches to
+// the disk path, but pre-init has long since bailed out.
+//
+// Try several sources in order; the first whose sibling .wasm exists
+// wins. argv[0] is normally the path the binary was invoked with —
+// always a real disk path, never bunfs. execPath is kept as a fallback
+// for environments where argv[0] is something exotic.
+const candidates = (
+  [process.argv[0], process.execPath] as Array<string | undefined>
+)
+  .filter((p): p is string => typeof p === 'string' && p.length > 0)
+  .map((p) => (isAbsolute(p) ? p : resolve(p)))
+  .map((p) => join(dirname(p), 'tree-sitter.wasm'))
+
+const siblingPath = candidates.find((p) => existsSync(p))
+
+// Pre-init diagnostic — only fires when --smoke-tree-sitter is set so we
+// don't spam every run. We need to see what argv[0] / execPath looked
+// like at this exact phase on Windows: the round-7 main() diag showed
+// disk paths, but pre-init silently bailed, meaning module-init time
+// gives different values. argv[0] alone wasn't enough to fix it.
+if (process.argv.includes('--smoke-tree-sitter')) {
+  console.error(
+    `[pre-init diag] argv[0]=${process.argv[0]}\n` +
+      `[pre-init diag] execPath=${process.execPath}\n` +
+      `[pre-init diag] candidates=${JSON.stringify(candidates)}\n` +
+      `[pre-init diag] resolved siblingPath=${siblingPath ?? '<none>'}\n`,
+  )
+}
+
+if (siblingPath) {
+  // Tell init-node.ts (in code-map / the SDK bundle) where the wasm
+  // is. The locateFile callback there will hand this path to
+  // emscripten, which fs.readFile's it.
+  process.env.ANVIL_TREE_SITTER_WASM_PATH = siblingPath
+
+  // Also publish on globalThis so the smoke handler in index.tsx can
+  // read it without touching process.env (which is gated by the env
+  // architecture check outside the allowlisted pre-init files).
+  ;(
+    globalThis as { __ANVIL_TREE_SITTER_WASM_PATH__?: string }
+  ).__ANVIL_TREE_SITTER_WASM_PATH__ = siblingPath
+
+  // Also try the synchronous-bytes path: hand the bytes straight to
+  // Parser.init({ wasmBinary }) so the SDK doesn't need to round-trip
+  // through emscripten's path resolution. Both channels feed the same
+  // tree-sitter init; whichever one trips first wins.
+  try {
+    const buf = readFileSync(siblingPath)
+    ;(
+      globalThis as { __ANVIL_TREE_SITTER_WASM_BINARY__?: Uint8Array }
+    ).__ANVIL_TREE_SITTER_WASM_BINARY__ = new Uint8Array(
+      buf.buffer,
+      buf.byteOffset,
+      buf.byteLength,
+    )
+  } catch (err) {
+    console.error(
+      '[tree-sitter pre-init] readFileSync failed for sibling wasm at',
+      siblingPath,
+      '—',
+      err instanceof Error ? err.message : String(err),
+    )
+  }
+}
+
+// `--smoke-tree-sitter` is the deterministic CI gate. The handler lives at
+// the top of main() in cli/src/index.tsx (before parseArgs).

package/src/project-files.ts

@@ -0,0 +1,102 @@
+import { mkdirSync, readdirSync, statSync } from 'fs'
+import path from 'path'
+
+import { getConfigDir } from './utils/auth'
+
+let projectRoot: string | undefined
+let currentChatId: string | undefined
+
+function ensureChatDirectory(dir: string) {
+  mkdirSync(dir, { recursive: true })
+}
+
+export function setProjectRoot(dir: string) {
+  projectRoot = dir
+  return projectRoot
+}
+
+export function getProjectRoot() {
+  if (!projectRoot) {
+    throw new Error('Project root not set')
+  }
+  return projectRoot
+}
+
+export function tryGetProjectRoot() {
+  return projectRoot
+}
+
+export function getCurrentChatId() {
+  if (!currentChatId) {
+    currentChatId = new Date().toISOString().replace(/:/g, '-')
+  }
+  return currentChatId
+}
+
+export function setCurrentChatId(chatId: string) {
+  currentChatId = chatId
+  return currentChatId
+}
+
+export function startNewChat() {
+  currentChatId = new Date().toISOString().replace(/:/g, '-')
+  return currentChatId
+}
+
+// Get the project-specific data directory
+export function getProjectDataDir(): string {
+  const root = getProjectRoot()
+  if (!root) {
+    throw new Error('Project root not set')
+  }
+
+  const baseName = path.basename(root)
+  const baseDir = path.join(getConfigDir(), 'projects', baseName)
+
+  return baseDir
+}
+
+/**
+ * Find the most recent chat directory based on modification time
+ * Returns null if no chat directories exist
+ */
+export function getMostRecentChatDir(): string | null {
+  try {
+    const chatsDir = path.join(getProjectDataDir(), 'chats')
+    if (!statSync(chatsDir, { throwIfNoEntry: false })) {
+      return null
+    }
+
+    const chatDirs = readdirSync(chatsDir)
+      .map((name) => {
+        const fullPath = path.join(chatsDir, name)
+        try {
+          const stat = statSync(fullPath)
+          return { name, fullPath, mtime: stat.mtime }
+        } catch {
+          return null
+        }
+      })
+      .filter(
+        (item): item is { name: string; fullPath: string; mtime: Date } =>
+          item !== null && statSync(item.fullPath).isDirectory(),
+      )
+
+    if (chatDirs.length === 0) {
+      return null
+    }
+
+    // Sort by modification time, most recent first
+    chatDirs.sort((a, b) => b.mtime.getTime() - a.mtime.getTime())
+    return chatDirs[0].fullPath
+  } catch {
+    return null
+  }
+}
+
+export function getCurrentChatDir(): string {
+  const chatId = getCurrentChatId()
+  const dir = path.join(getProjectDataDir(), 'chats', chatId)
+  ensureChatDirectory(dir)
+  return dir
+}

package/src/smoke/terminal-command-broker.ts

@@ -0,0 +1,439 @@
+import { runTerminalCommand } from '@anvil/sdk'
+import { createCliRenderer } from '@opentui/core'
+import { existsSync, mkdirSync, writeFileSync } from 'fs'
+import path from 'path'
+
+import { installProcessCleanupHandlers } from '../utils/renderer-cleanup'
+import { startTerminalWatchdog } from '../utils/terminal-watchdog'
+import {
+  createTerminalCommandBroker,
+  terminalCommandBroker,
+} from '../utils/terminal-command-broker'
+import { installTerminalProtocolController } from '../utils/terminal-protocol-controller'
+import { writeTerminalControlSync } from '../utils/terminal-io'
+
+import type { CliRenderer } from '@opentui/core'
+import type { AnvilToolOutput } from '@anvil/sdk'
+
+const WAIT_INTERVAL_MS = 25
+
+type TerminalResult =
+  AnvilToolOutput<'run_terminal_command'>[number]['value']
+
+type SmokeResult = {
+  ok: boolean
+  platform: NodeJS.Platform
+  stdinIsTTY: boolean
+  stdoutIsTTY: boolean
+  simpleCommand?: { stdout: string; stderr: string; exitCode: number | null }
+  repeatedCommands?: { completed: number }
+  overlap?: {
+    focusStates: boolean[]
+    controlWrites: string[]
+    mouseStayedEnabledDuringOverlap: boolean
+    mouseStayedEnabledAfterCancellation: boolean
+    mouseStayedEnabledAfterCompletion: boolean
+    firstCancellationMessage: string
+    secondStdout: string
+    consoleReaderStdout: string
+  }
+  brokerFailure?: { message: string; commandStarted: boolean }
+  error?: string
+  stack?: string
+}
+
+function assertSmoke(condition: unknown, message: string): asserts condition {
+  if (!condition) throw new Error(message)
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`
+}
+
+function toBashPath(value: string): string {
+  return value.replace(/\\/g, '/')
+}
+
+function asTerminalResult(
+  output: AnvilToolOutput<'run_terminal_command'>,
+): TerminalResult {
+  assertSmoke(output.length === 1, 'terminal command returned no result')
+  return output[0].value
+}
+
+function readString(value: TerminalResult, key: 'stdout' | 'stderr'): string {
+  if (key === 'stdout') {
+    return 'stdout' in value && typeof value.stdout === 'string'
+      ? value.stdout
+      : ''
+  }
+  return 'stderr' in value && typeof value.stderr === 'string'
+    ? value.stderr
+    : ''
+}
+
+function readExitCode(value: TerminalResult): number | null {
+  return 'exitCode' in value && typeof value.exitCode === 'number'
+    ? value.exitCode
+    : null
+}
+
+function readMessage(value: TerminalResult): string {
+  return 'message' in value && typeof value.message === 'string'
+    ? value.message
+    : ''
+}
+
+async function waitFor(
+  condition: () => boolean,
+  timeoutMs: number,
+  failureMessage: string,
+): Promise<void> {
+  const deadline = Date.now() + timeoutMs
+  while (!condition()) {
+    if (Date.now() >= deadline) throw new Error(failureMessage)
+    await Bun.sleep(WAIT_INTERVAL_MS)
+  }
+}
+
+function writeResult(resultPath: string, result: SmokeResult): void {
+  mkdirSync(path.dirname(resultPath), { recursive: true })
+  writeFileSync(resultPath, JSON.stringify(result, null, 2))
+}
+
+async function destroyRenderer(renderer: CliRenderer): Promise<void> {
+  if (renderer.isDestroyed) return
+  await new Promise<void>((resolve, reject) => {
+    const onDestroy = () => {
+      clearTimeout(timeout)
+      resolve()
+    }
+    const timeout = setTimeout(() => {
+      renderer.removeListener('destroy', onDestroy)
+      renderer.isDestroyed
+        ? resolve()
+        : reject(new Error('OpenTUI renderer did not finish destroying'))
+    }, 2_000)
+    renderer.once('destroy', onDestroy)
+    renderer.destroy()
+  })
+}
+
+/**
+ * `markerPath` is written before the CONIN$ probe so the harness knows the descendant is alive and
+ * can start injecting terminal reports for a leaked console to pick up. It cannot also stand for
+ * "the probe finished" — it is written while the outcome is still unknown.
+ *
+ * `verdictPath` is written once the probe has resolved, down both branches, and is what makes the
+ * abort deterministic. Waiting a fixed interval after the ready marker instead raced PowerShell's
+ * startup on a loaded runner and aborted before the verdict reached stdout.
+ *
+ * The flush is load-bearing: the broker force-kills on Windows (`taskkill /f`), so a line still
+ * sitting in PowerShell's own buffer is lost outright rather than drained from the pipe.
+ */
+function createConsoleReaderScript(
+  markerPath: string,
+  verdictPath: string,
+): string {
+  const quotedMarker = markerPath.replace(/'/g, "''")
+  const quotedVerdict = verdictPath.replace(/'/g, "''")
+  return [
+    `$ErrorActionPreference = 'Stop'`,
+    `[System.IO.File]::WriteAllText('${quotedMarker}', 'ready')`,
+    `try {`,
+    `  $stream = [System.IO.File]::Open('CONIN$', [System.IO.FileMode]::Open, [System.IO.FileAccess]::Read, [System.IO.FileShare]::ReadWrite)`,
+    `  $buffer = New-Object byte[] 4096`,
+    `  $count = $stream.Read($buffer, 0, $buffer.Length)`,
+    `  if ($count -gt 0) {`,
+    `    $hex = [System.BitConverter]::ToString($buffer, 0, $count).Replace('-', '')`,
+    `    [Console]::Out.WriteLine('CONSOLE_LEAK_HEX:' + $hex)`,
+    `  }`,
+    `} catch {`,
+    `  [Console]::Out.WriteLine('CONSOLE_UNAVAILABLE')`,
+    `}`,
+    `[Console]::Out.Flush()`,
+    `[System.IO.File]::WriteAllText('${quotedVerdict}', 'done')`,
+    `Start-Sleep -Seconds 20`,
+  ].join('\r\n')
+}
+
+export async function runPackagedTerminalBrokerSmoke({
+  resultPath,
+  exchangeDir,
+}: {
+  resultPath: string
+  exchangeDir: string
+}): Promise<number> {
+  const result: SmokeResult = {
+    ok: false,
+    platform: process.platform,
+    stdinIsTTY: Boolean(process.stdin.isTTY),
+    stdoutIsTTY: Boolean(process.stdout.isTTY),
+  }
+  let renderer: CliRenderer | null = null
+
+  try {
+    assertSmoke(process.platform === 'win32', 'broker smoke requires Windows')
+    assertSmoke(
+      process.stdin.isTTY && process.stdout.isTTY,
+      'broker smoke requires a native Windows console',
+    )
+
+    mkdirSync(exchangeDir, { recursive: true })
+    const harnessReadyPath = path.join(exchangeDir, 'broker-ready')
+    const reportsSentPath = path.join(exchangeDir, 'reports-sent')
+    const consoleReaderReadyPath = path.join(
+      exchangeDir,
+      'console-reader-ready',
+    )
+    const consoleReaderVerdictPath = path.join(
+      exchangeDir,
+      'console-reader-verdict',
+    )
+    const consoleReaderScriptPath = path.join(exchangeDir, 'console-reader.ps1')
+    const forbiddenSpawnPath = path.join(exchangeDir, 'broker-failure-spawned')
+    writeFileSync(
+      consoleReaderScriptPath,
+      createConsoleReaderScript(
+        consoleReaderReadyPath,
+        consoleReaderVerdictPath,
+      ),
+    )
+
+    startTerminalWatchdog()
+    renderer = await createCliRenderer({
+      backgroundColor: 'transparent',
+      exitOnCtrlC: false,
+      screenMode: 'alternate-screen',
+    })
+    installProcessCleanupHandlers(renderer)
+
+    const controlWrites: string[] = []
+    const controller = installTerminalProtocolController(renderer, {
+      writeControl: (sequence) => {
+        controlWrites.push(sequence)
+        return writeTerminalControlSync(sequence)
+      },
+    })
+    renderer.once('destroy', () => controller.dispose())
+    const focusStates: boolean[] = []
+    const unsubscribeFocus = controller.subscribeToFocus({
+      onFocusChange: (focused) => focusStates.push(focused),
+    })
+
+    const simple = asTerminalResult(
+      await runTerminalCommand({
+        command: `printf 'COMMAND_OK'; printf 'COMMAND_ERR' >&2`,
+        process_type: 'SYNC',
+        cwd: process.cwd(),
+        timeout_seconds: 10,
+        terminalCommandBroker,
+      }),
+    )
+    const simpleStdout = readString(simple, 'stdout')
+    const simpleStderr = readString(simple, 'stderr')
+    const simpleExitCode = readExitCode(simple)
+    assertSmoke(simpleStdout === 'COMMAND_OK', 'simple command stdout was lost')
+    assertSmoke(
+      simpleStderr === 'COMMAND_ERR',
+      'simple command stderr was lost',
+    )
+    assertSmoke(
+      simpleExitCode === 0,
+      'simple command did not exit successfully',
+    )
+    result.simpleCommand = {
+      stdout: simpleStdout,
+      stderr: simpleStderr,
+      exitCode: simpleExitCode,
+    }
+
+    const overlapWriteStart = controlWrites.length
+    const firstAbort = new AbortController()
+    const readerCommand =
+      `powershell.exe -NoProfile -NonInteractive -ExecutionPolicy Bypass -File ` +
+      shellQuote(toBashPath(consoleReaderScriptPath))
+    const firstRun = runTerminalCommand({
+      command: readerCommand,
+      process_type: 'SYNC',
+      cwd: process.cwd(),
+      timeout_seconds: 30,
+      signal: firstAbort.signal,
+      terminalCommandBroker,
+    })
+    const secondRun = runTerminalCommand({
+      command: `sleep 5; printf 'SECOND_DONE'`,
+      process_type: 'SYNC',
+      cwd: process.cwd(),
+      timeout_seconds: 15,
+      terminalCommandBroker,
+    })
+
+    const mouseStayedEnabledDuringOverlap = renderer.useMouse === true
+    assertSmoke(
+      mouseStayedEnabledDuringOverlap,
+      'brokers changed mouse reporting',
+    )
+    assertSmoke(
+      controlWrites.length === overlapWriteStart,
+      'brokers changed focus reporting',
+    )
+    await waitFor(
+      () => existsSync(consoleReaderReadyPath),
+      10_000,
+      'console reader descendant did not start',
+    )
+    writeFileSync(harnessReadyPath, 'ready')
+    await waitFor(
+      () => existsSync(reportsSentPath),
+      10_000,
+      'native Windows harness did not inject terminal reports',
+    )
+    await waitFor(
+      () => focusStates.includes(false) && focusStates.includes(true),
+      5_000,
+      'OpenTUI did not receive focus activity while commands ran',
+    )
+    // Only abort once the descendant has actually resolved its CONIN$ probe and flushed the
+    // verdict. This sits after the reports-sent wait deliberately: a descendant that DID inherit a
+    // console is blocked in $stream.Read until those reports arrive, and only then writes its leak
+    // line and the verdict. A descendant with no console fails File.Open immediately, so if the
+    // verdict never lands the open must have succeeded — which is itself the leak this asserts
+    // against, hence the wording below rather than a bare timeout.
+    // 10s to match the waits above, and because the abort has a real budget: the script exits on
+    // its own after Start-Sleep -Seconds 20 and firstRun times out at 30, either of which would
+    // turn the cancellation assertion below into a confusing failure. In practice the verdict is
+    // already on disk by the time this runs — a console-free open throws at once.
+    await waitFor(
+      () => existsSync(consoleReaderVerdictPath),
+      10_000,
+      'console reader never resolved its CONIN$ probe — an open that blocks instead of failing means the descendant did have a Windows console',
+    )
+
+    firstAbort.abort()
+    const first = asTerminalResult(await firstRun)
+    const firstCancellationMessage = readMessage(first)
+    assertSmoke(
+      firstCancellationMessage.includes('aborted by the user'),
+      'first overlapping command did not report cancellation',
+    )
+    const mouseStayedEnabledAfterCancellation = renderer.useMouse === true
+    assertSmoke(
+      mouseStayedEnabledAfterCancellation,
+      'broker cancellation changed mouse reporting',
+    )
+
+    const second = asTerminalResult(await secondRun)
+    const secondStdout = readString(second, 'stdout')
+    assertSmoke(secondStdout === 'SECOND_DONE', 'overlapping command was lost')
+    const mouseStayedEnabledAfterCompletion = renderer.useMouse === true
+    const overlapWrites = controlWrites.slice(overlapWriteStart)
+    assertSmoke(
+      overlapWrites.length === 0,
+      'completion changed focus reporting',
+    )
+
+    const consoleReaderStdout = readString(first, 'stdout')
+    assertSmoke(
+      !consoleReaderStdout.includes('CONSOLE_LEAK_HEX:'),
+      'a command descendant read terminal reports from CONIN$',
+    )
+    assertSmoke(
+      consoleReaderStdout.includes('CONSOLE_UNAVAILABLE'),
+      'the command descendant still had a Windows console',
+    )
+    result.overlap = {
+      focusStates,
+      controlWrites: overlapWrites,
+      mouseStayedEnabledDuringOverlap,
+      mouseStayedEnabledAfterCancellation,
+      mouseStayedEnabledAfterCompletion,
+      firstCancellationMessage,
+      secondStdout,
+      consoleReaderStdout,
+    }
+
+    // The Windows failure that motivated this gate appeared only after users
+    // had run several agent commands. Exercise repeated packaged-broker stdio
+    // setup after the driver has completed its time-sensitive report injection.
+    const repeatedCommandCount = 64
+    for (let index = 0; index < repeatedCommandCount; index++) {
+      const marker = `REPEATED_${index}`
+      const repeated = asTerminalResult(
+        await runTerminalCommand({
+          command: `printf '${marker}'`,
+          process_type: 'SYNC',
+          cwd: process.cwd(),
+          timeout_seconds: 10,
+          terminalCommandBroker,
+        }),
+      )
+      assertSmoke(
+        readString(repeated, 'stdout') === marker,
+        `repeated broker command ${index} lost its output`,
+      )
+      assertSmoke(
+        readExitCode(repeated) === 0,
+        `repeated broker command ${index} failed`,
+      )
+    }
+    result.repeatedCommands = { completed: repeatedCommandCount }
+
+    let failureMessage = ''
+    try {
+      await runTerminalCommand({
+        command: `printf 'spawned' > ${shellQuote(toBashPath(forbiddenSpawnPath))}`,
+        process_type: 'SYNC',
+        cwd: process.cwd(),
+        timeout_seconds: 10,
+        terminalCommandBroker: createTerminalCommandBroker({
+          invocation: () => ({
+            executable: path.join(
+              exchangeDir,
+              `missing-terminal-broker-${crypto.randomUUID()}.exe`,
+            ),
+            args: [],
+          }),
+        }),
+      })
+      throw new Error('command unexpectedly started without its broker')
+    } catch (error) {
+      failureMessage = error instanceof Error ? error.message : String(error)
+    }
+    result.brokerFailure = {
+      message: failureMessage,
+      commandStarted: existsSync(forbiddenSpawnPath),
+    }
+    assertSmoke(
+      failureMessage.includes('Restart Freebuff'),
+      'broker failure did not include actionable recovery guidance',
+    )
+    assertSmoke(
+      !existsSync(forbiddenSpawnPath),
+      'command spawned after broker startup failed',
+    )
+
+    unsubscribeFocus()
+    controller.dispose()
+    await destroyRenderer(renderer)
+    result.ok = true
+    writeResult(resultPath, result)
+    return 0
+  } catch (error) {
+    result.error = error instanceof Error ? error.message : String(error)
+    if (error instanceof Error && error.stack) result.stack = error.stack
+    if (renderer && !renderer.isDestroyed) {
+      try {
+        await destroyRenderer(renderer)
+      } catch (cleanupError) {
+        result.error += `; cleanup failed: ${errorMessage(cleanupError)}`
+      }
+    }
+    writeResult(resultPath, result)
+    return 1
+  }
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}

package/src/state/__tests__/chat-store-focus.test.ts

@@ -0,0 +1,22 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+
+import { useChatStore } from '../chat-store'
+
+afterEach(() => {
+  const store = useChatStore.getState()
+  store.setInputFocused(true)
+  store.setIsFocusSupported(false)
+})
+
+describe('chat store focus state', () => {
+  test('chat reset preserves terminal focus and detected capabilities', () => {
+    const store = useChatStore.getState()
+    store.setInputFocused(false)
+    store.setIsFocusSupported(true)
+
+    store.reset()
+
+    expect(useChatStore.getState().inputFocused).toBe(false)
+    expect(useChatStore.getState().isFocusSupported).toBe(true)
+  })
+})