@alumbwe/anvil 1.0.0 → 1.0.2

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

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

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

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

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