@alumbwe/anvil 1.0.0

package/src/__tests__/helpers/launcher-disconnect-fixture.cjs

@@ -0,0 +1,176 @@
+const { spawn, spawnSync } = require('child_process')
+const { existsSync, readFileSync, rmSync } = require('fs')
+const { tmpdir } = require('os')
+const { join } = require('path')
+
+const mode = process.argv[2]
+const rendererFixture = process.argv[3]
+// Two separate clocks, because they bound different things. Boot covers
+// spawning bun + transpiling the TSX renderer on a cold CI runner — slow, and
+// not what this test measures. Survival starts only once the launcher has
+// been killed and bounds the thing under test: how long the CLI may outlive
+// its launcher (it polls the launcher PID every 500ms). A single
+// start-anchored deadline let a slow boot eat the whole survival budget and
+// pushed real failures into the harness's contentless test timeout.
+const READY_TIMEOUT_MS = 15_000
+const SURVIVAL_TIMEOUT_MS = 6_000
+
+if (mode !== 'observe' && mode !== 'launch') {
+  console.error(
+    'usage: launcher-disconnect-fixture.cjs <observe|launch> [renderer-fixture]',
+  )
+  process.exit(2)
+}
+
+if (mode === 'launch') {
+  // Stand in for the package's Node launcher. The observer terminates this
+  // process externally after the renderer reports that it is ready.
+  setInterval(() => {}, READY_TIMEOUT_MS)
+} else {
+  if (!rendererFixture) {
+    console.error('observe mode requires a renderer fixture')
+    process.exit(2)
+  }
+
+  const cleanExitMarkerPath = join(
+    tmpdir(),
+    `launcher-disconnect-${process.pid}-${Math.random().toString(36).slice(2)}`,
+  )
+  const rendererReadyMarkerPath = `${cleanExitMarkerPath}-ready`
+  const removeMarkers = () => {
+    try {
+      rmSync(cleanExitMarkerPath, { force: true })
+      rmSync(rendererReadyMarkerPath, { force: true })
+    } catch {}
+  }
+  const forceKill = (child) => {
+    if (!child.pid || child.exitCode !== null) return
+    try {
+      if (process.platform === 'win32') {
+        spawnSync('taskkill', ['/PID', String(child.pid), '/F'], {
+          stdio: 'ignore',
+        })
+      } else {
+        child.kill('SIGKILL')
+      }
+    } catch {}
+  }
+
+  const launcher = spawn(process.execPath, [__filename, 'launch'], {
+    stdio: 'inherit',
+  })
+  const cli = spawn(
+    'bun',
+    [
+      rendererFixture,
+      'launcher-disconnect',
+      cleanExitMarkerPath,
+      rendererReadyMarkerPath,
+    ],
+    {
+      // The repository's package test command sets NODE_ENV=production while
+      // this TSX fixture uses Bun's test JSX transform.
+      env: {
+        ...process.env,
+        NODE_ENV: 'test',
+        BUN_ENV: 'test',
+        ANVIL_LAUNCHER_PID: String(launcher.pid),
+      },
+      stdio: 'inherit',
+    },
+  )
+
+  let launcherKillRequested = false
+  let launcherExited = false
+  let cliExit
+  let survivalTimeout
+
+  const finishIfReady = () => {
+    if (!launcherExited || !cliExit) return
+    clearInterval(readyPoll)
+    if (survivalTimeout) clearTimeout(survivalTimeout)
+
+    let cleanExitConfirmed = false
+    try {
+      cleanExitConfirmed =
+        readFileSync(cleanExitMarkerPath, 'utf8') === 'CLEAN_EXIT_VISIBLE'
+    } catch {}
+    removeMarkers()
+
+    if (
+      !launcherKillRequested ||
+      cliExit.code !== 0 ||
+      cliExit.signal !== null ||
+      !cleanExitConfirmed
+    ) {
+      console.error('CLI exited without running clean-exit handlers')
+      process.exit(8)
+    }
+    console.log('CLEAN_EXIT_VISIBLE\nCLI_EXITED_AFTER_LAUNCHER')
+    process.exit(0)
+  }
+
+  launcher.once('error', (error) => {
+    forceKill(cli)
+    removeMarkers()
+    console.error('failed to start launcher fixture:', error)
+    process.exit(3)
+  })
+  launcher.once('exit', () => {
+    launcherExited = true
+    finishIfReady()
+  })
+  cli.once('error', (error) => {
+    forceKill(launcher)
+    removeMarkers()
+    console.error('failed to start renderer fixture:', error)
+    process.exit(4)
+  })
+  cli.once('exit', (code, signal) => {
+    cliExit = { code, signal }
+    finishIfReady()
+  })
+
+  const readyDeadline = Date.now() + READY_TIMEOUT_MS
+  const readyPoll = setInterval(() => {
+    if (launcherKillRequested) return
+    if (existsSync(rendererReadyMarkerPath)) {
+      launcherKillRequested = true
+      if (process.platform === 'win32') {
+        const result = spawnSync(
+          'taskkill',
+          ['/PID', String(launcher.pid), '/F'],
+          { stdio: 'inherit' },
+        )
+        if (result.error || result.status !== 0) {
+          forceKill(cli)
+          removeMarkers()
+          console.error(
+            'failed to kill launcher fixture:',
+            result.error ?? `taskkill exited ${result.status}`,
+          )
+          process.exit(5)
+        }
+      } else {
+        launcher.kill('SIGKILL')
+      }
+      // The survival clock starts now — the launcher is dead, and the CLI's
+      // 500ms PID poll should notice within a cycle or two. Anchoring this at
+      // fixture start instead meant a slow bun boot consumed the whole window.
+      clearInterval(readyPoll)
+      survivalTimeout = setTimeout(() => {
+        forceKill(launcher)
+        forceKill(cli)
+        removeMarkers()
+        console.error('CLI survived after its launcher exited')
+        process.exit(7)
+      }, SURVIVAL_TIMEOUT_MS)
+    } else if (Date.now() >= readyDeadline) {
+      forceKill(launcher)
+      forceKill(cli)
+      removeMarkers()
+      console.error('renderer fixture did not become ready')
+      process.exit(6)
+    }
+  }, 25)
+}

package/src/__tests__/helpers/mock-api-client.ts

@@ -0,0 +1,64 @@
+import { mock } from 'bun:test'
+
+import type { AnvilApiClient } from '../../utils/anvil-api'
+
+export interface MockApiClientOverrides {
+  get?: ReturnType<typeof mock>
+  post?: ReturnType<typeof mock>
+  put?: ReturnType<typeof mock>
+  patch?: ReturnType<typeof mock>
+  delete?: ReturnType<typeof mock>
+  request?: ReturnType<typeof mock>
+  me?: ReturnType<typeof mock>
+  usage?: ReturnType<typeof mock>
+  loginCode?: ReturnType<typeof mock>
+  loginStatus?: ReturnType<typeof mock>
+  publish?: ReturnType<typeof mock>
+  logout?: ReturnType<typeof mock>
+  feedback?: ReturnType<typeof mock>
+  baseUrl?: string
+  authToken?: string
+}
+
+/**
+ * Default OK response for mock API methods.
+ * Returns { ok: true, status: 200 } without data, matching our ApiResponse type
+ * where `data` is optional for responses without a body.
+ */
+const defaultOkResponse = () =>
+  Promise.resolve({ ok: true as const, status: 200 })
+
+/**
+ * Creates a mock AnvilApiClient with sensible defaults.
+ * All methods return { ok: true, status: 200 } by default.
+ * Pass overrides to customize specific methods.
+ */
+export const createMockApiClient = (
+  overrides: MockApiClientOverrides = {},
+): AnvilApiClient => ({
+  get: (overrides.get ?? mock(defaultOkResponse)) as AnvilApiClient['get'],
+  post: (overrides.post ??
+    mock(defaultOkResponse)) as AnvilApiClient['post'],
+  put: (overrides.put ?? mock(defaultOkResponse)) as AnvilApiClient['put'],
+  patch: (overrides.patch ??
+    mock(defaultOkResponse)) as AnvilApiClient['patch'],
+  delete: (overrides.delete ??
+    mock(defaultOkResponse)) as AnvilApiClient['delete'],
+  request: (overrides.request ??
+    mock(defaultOkResponse)) as AnvilApiClient['request'],
+  me: (overrides.me ?? mock(defaultOkResponse)) as AnvilApiClient['me'],
+  usage: (overrides.usage ??
+    mock(defaultOkResponse)) as AnvilApiClient['usage'],
+  loginCode: (overrides.loginCode ??
+    mock(defaultOkResponse)) as AnvilApiClient['loginCode'],
+  loginStatus: (overrides.loginStatus ??
+    mock(defaultOkResponse)) as AnvilApiClient['loginStatus'],
+  publish: (overrides.publish ??
+    mock(defaultOkResponse)) as AnvilApiClient['publish'],
+  logout: (overrides.logout ??
+    mock(defaultOkResponse)) as AnvilApiClient['logout'],
+  feedback: (overrides.feedback ??
+    mock(defaultOkResponse)) as AnvilApiClient['feedback'],
+  baseUrl: overrides.baseUrl ?? 'https://test.codebuff.com',
+  authToken: overrides.authToken,
+})

package/src/__tests__/helpers/renderer-cleanup-fixture.tsx

@@ -0,0 +1,89 @@
+import { createCliRenderer } from '@opentui/core'
+import { createRoot } from '@opentui/react'
+import { writeFileSync } from 'fs'
+import React from 'react'
+
+import { exitCliCleanly } from '../../utils/exit-cleanly'
+import { installProcessCleanupHandlers } from '../../utils/renderer-cleanup'
+import { writeFileDescriptorSync } from '../../utils/terminal-io'
+
+const mode = process.argv[2]
+const cleanExitMarkerPath = process.argv[3]
+const rendererReadyMarkerPath = process.argv[4]
+if (
+  mode !== 'clean' &&
+  mode !== 'fatal' &&
+  mode !== 'rejection' &&
+  mode !== 'unprintable-rejection' &&
+  mode !== 'launcher-disconnect' &&
+  mode !== 'sigint' &&
+  mode !== 'sigterm' &&
+  mode !== 'sighup'
+) {
+  console.error(
+    'usage: renderer-cleanup-fixture.tsx <clean|fatal|rejection|unprintable-rejection|launcher-disconnect|sigint|sigterm|sighup>',
+  )
+  process.exit(2)
+}
+
+const renderer = await createCliRenderer({
+  exitOnCtrlC: false,
+  screenMode: 'alternate-screen',
+})
+installProcessCleanupHandlers(renderer)
+
+let exitScheduled = false
+renderer.setFrameCallback(async () => {
+  if (exitScheduled) return
+  exitScheduled = true
+  setTimeout(() => {
+    if (mode === 'fatal') {
+      throw new Error('fatal-cleanup-fixture')
+    }
+    if (mode === 'rejection') {
+      void Promise.reject(new Error('rejection-cleanup-fixture'))
+      return
+    }
+    if (mode === 'unprintable-rejection') {
+      void Promise.reject(Object.create(null))
+      return
+    }
+    if (mode === 'launcher-disconnect') {
+      if (rendererReadyMarkerPath) {
+        writeFileSync(rendererReadyMarkerPath, 'renderer-ready')
+      }
+      return
+    }
+    if (mode === 'clean') {
+      void exitCliCleanly()
+    } else {
+      const signal =
+        mode === 'sigint' ? 'SIGINT' : mode === 'sigterm' ? 'SIGTERM' : 'SIGHUP'
+      process.kill(process.pid, signal)
+    }
+  }, 10)
+
+  // Keep a frame active until the exit begins, forcing OpenTUI's deferred
+  // destroy path rather than its simpler synchronous finalization path.
+  await Bun.sleep(500)
+})
+
+if (
+  mode !== 'fatal' &&
+  mode !== 'rejection' &&
+  mode !== 'unprintable-rejection'
+) {
+  process.on('exit', () => {
+    if (mode === 'launcher-disconnect' && cleanExitMarkerPath) {
+      try {
+        writeFileSync(cleanExitMarkerPath, 'CLEAN_EXIT_VISIBLE')
+      } catch {}
+    } else {
+      writeFileDescriptorSync(process.stdout.fd, 'CLEAN_EXIT_VISIBLE\n')
+    }
+  })
+}
+
+createRoot(renderer).render(
+  <text>ALTERNATE_SCREEN_CONTENT_SHOULD_NOT_SURVIVE</text>,
+)

package/src/__tests__/helpers/terminal-watchdog-fixture.ts

@@ -0,0 +1,75 @@
+/**
+ * Fixture process for terminal-watchdog.test.ts.
+ *
+ * Usage: bun terminal-watchdog-fixture.ts <mode> <ttyPath>
+ * - mode "hang":  start the watchdog and stay alive until killed by the test.
+ * - mode "clean": start the watchdog, then stop it and exit (clean shutdown).
+ * - mode "spawn-failure": report a watchdog startup failure and exit.
+ *
+ * Prints "ready" once the watchdog is armed. On Windows, arming is asynchronous
+ * (a PowerShell bootstrap has to launch the real watchdog outside Bun's
+ * kill-on-close job object), so we wait for the `<ttyPath>.armed` marker before
+ * printing "ready" — killing earlier would take the bootstrap down before the
+ * watchdog exists.
+ */
+import { existsSync, writeFileSync } from 'fs'
+
+import {
+  getTerminalWatchdogDiagnostics,
+  startTerminalWatchdog,
+  stopTerminalWatchdog,
+} from '../../utils/terminal-watchdog'
+
+const [mode, ttyPath] = process.argv.slice(2)
+
+if (!mode || !ttyPath) {
+  console.error(
+    'usage: terminal-watchdog-fixture.ts <hang|clean|spawn-failure> <ttyPath>',
+  )
+  process.exit(2)
+}
+
+async function waitForArmed(): Promise<void> {
+  if (process.platform !== 'win32') return
+  // An explicit opt-out is the one path where no armed marker is expected.
+  if (!getTerminalWatchdogDiagnostics().armed) return
+  // Deliberately shorter than the test's own ready budget, so a runner too slow
+  // to boot PowerShell fails here — with a message — instead of surfacing later
+  // as an unexplained empty write. Sized for several fixtures arming at once.
+  const deadline = Date.now() + 40_000
+  while (Date.now() < deadline) {
+    if (existsSync(`${ttyPath}.armed`)) return
+    await new Promise((r) => setTimeout(r, 50))
+  }
+  console.error(`watchdog never armed within 40s (marker: ${ttyPath}.armed)`)
+  process.exit(3)
+}
+
+if (mode === 'spawn-failure') {
+  const failure = await new Promise<unknown>((resolve) => {
+    startTerminalWatchdog({
+      ttyPath,
+      reportFailure: resolve,
+      windowsPowerShellPath: `${ttyPath}.missing.exe`,
+    })
+    setTimeout(() => {
+      console.error('watchdog failure was not reported')
+      process.exit(4)
+    }, 10_000)
+  })
+  writeFileSync(ttyPath, JSON.stringify(failure))
+  process.exit(0)
+}
+
+startTerminalWatchdog({ ttyPath })
+
+if (mode === 'clean') {
+  await waitForArmed()
+  stopTerminalWatchdog()
+  console.log('ready')
+  process.exit(0)
+}
+
+await waitForArmed()
+console.log('ready')
+setInterval(() => {}, 1_000)

package/src/__tests__/home-directory-detection.test.ts

@@ -0,0 +1,213 @@
+import { describe, test, expect, beforeEach } from 'bun:test'
+
+import { useChatStore } from '../state/chat-store'
+import { getInputModeConfig } from '../utils/input-modes'
+
+/**
+ * Tests for home directory detection and banner behavior
+ *
+ * The home directory detection works as follows:
+ * 1. When fileTreeLoaded becomes true and fileTree.length === 0
+ * 2. setActiveTopBanner('homeDir') is called to show top banner
+ * 3. setInputMode('homeDir') is called to show bottom banner
+ *
+ * Closing behavior:
+ * - Closing the top banner calls closeTopBanner() and resets inputMode to 'default'
+ * - Closing the bottom banner also calls closeTopBanner() and resets inputMode
+ */
+describe('Home Directory Detection', () => {
+  beforeEach(() => {
+    useChatStore.getState().reset()
+  })
+
+  describe('banner state management', () => {
+    test('should set activeTopBanner to homeDir when home directory detected', () => {
+      const store = useChatStore.getState()
+
+      // Simulate home directory detection
+      store.setActiveTopBanner('homeDir')
+
+      expect(useChatStore.getState().activeTopBanner).toBe('homeDir')
+    })
+
+    test('should set inputMode to homeDir when home directory detected', () => {
+      const store = useChatStore.getState()
+
+      // Simulate home directory detection
+      store.setInputMode('homeDir')
+
+      expect(useChatStore.getState().inputMode).toBe('homeDir')
+    })
+
+    test('should set both top banner and input mode when home directory detected', () => {
+      const store = useChatStore.getState()
+
+      // Simulate the full home directory detection logic
+      store.setActiveTopBanner('homeDir')
+      store.setInputMode('homeDir')
+
+      const state = useChatStore.getState()
+      expect(state.activeTopBanner).toBe('homeDir')
+      expect(state.inputMode).toBe('homeDir')
+    })
+
+    test('closeTopBanner should set activeTopBanner to null', () => {
+      const store = useChatStore.getState()
+
+      store.setActiveTopBanner('homeDir')
+      expect(useChatStore.getState().activeTopBanner).toBe('homeDir')
+
+      store.closeTopBanner()
+      expect(useChatStore.getState().activeTopBanner).toBeNull()
+    })
+  })
+
+  describe('detection conditions', () => {
+    test('should only trigger when fileTreeLoaded is true AND fileTree is empty', () => {
+      // Simulate the detection logic from chat.tsx
+      const simulateDetection = (
+        fileTreeLoaded: boolean,
+        fileTreeLength: number,
+      ) => {
+        if (fileTreeLoaded && fileTreeLength === 0) {
+          useChatStore.getState().setActiveTopBanner('homeDir')
+          useChatStore.getState().setInputMode('homeDir')
+          return true
+        }
+        return false
+      }
+
+      // Reset state
+      useChatStore.getState().reset()
+
+      // Case 1: fileTreeLoaded=false, empty array - should NOT trigger
+      expect(simulateDetection(false, 0)).toBe(false)
+      expect(useChatStore.getState().activeTopBanner).toBeNull()
+
+      // Reset state
+      useChatStore.getState().reset()
+
+      // Case 2: fileTreeLoaded=true, non-empty array - should NOT trigger
+      expect(simulateDetection(true, 5)).toBe(false)
+      expect(useChatStore.getState().activeTopBanner).toBeNull()
+
+      // Reset state
+      useChatStore.getState().reset()
+
+      // Case 3: fileTreeLoaded=true, empty array - SHOULD trigger
+      expect(simulateDetection(true, 0)).toBe(true)
+      expect(useChatStore.getState().activeTopBanner).toBe('homeDir')
+      expect(useChatStore.getState().inputMode).toBe('homeDir')
+    })
+
+    test('should not trigger for non-empty directories', () => {
+      const fileTreeLoaded = true
+      const fileTreeLength: number = 10
+
+      if (fileTreeLoaded && fileTreeLength === 0) {
+        useChatStore.getState().setActiveTopBanner('homeDir')
+      }
+
+      expect(useChatStore.getState().activeTopBanner).toBeNull()
+    })
+  })
+
+  describe('closing behavior', () => {
+    test('closing top banner should reset both banner and input mode', () => {
+      const store = useChatStore.getState()
+
+      // Set up home directory banner state
+      store.setActiveTopBanner('homeDir')
+      store.setInputMode('homeDir')
+
+      // Simulate closing top banner (as done in TopBanner component)
+      store.closeTopBanner()
+      // The TopBanner component also resets input mode if it's 'homeDir'
+      if (useChatStore.getState().inputMode === 'homeDir') {
+        store.setInputMode('default')
+      }
+
+      const state = useChatStore.getState()
+      expect(state.activeTopBanner).toBeNull()
+      expect(state.inputMode).toBe('default')
+    })
+
+    test('closing bottom banner should also close top banner', () => {
+      const store = useChatStore.getState()
+
+      // Set up home directory banner state
+      store.setActiveTopBanner('homeDir')
+      store.setInputMode('homeDir')
+
+      // Simulate closing bottom banner (as done in HomeDirBanner component)
+      store.setInputMode('default')
+      store.closeTopBanner()
+
+      const state = useChatStore.getState()
+      expect(state.activeTopBanner).toBeNull()
+      expect(state.inputMode).toBe('default')
+    })
+  })
+
+  describe('input mode configuration', () => {
+    test('homeDir mode should have correct configuration', () => {
+      const config = getInputModeConfig('homeDir')
+
+      expect(config.icon).toBeNull()
+      expect(config.color).toBe('warning')
+      expect(config.showAgentModeToggle).toBe(true)
+      expect(config.disableSlashSuggestions).toBe(false)
+    })
+
+    test('homeDir mode should allow normal input behavior', () => {
+      const config = getInputModeConfig('homeDir')
+
+      // Users should still be able to:
+      // - Type normal prompts (showAgentModeToggle: true)
+      // - Use slash commands (disableSlashSuggestions: false)
+      expect(config.showAgentModeToggle).toBe(true)
+      expect(config.disableSlashSuggestions).toBe(false)
+    })
+
+    test('homeDir mode should have a placeholder', () => {
+      const config = getInputModeConfig('homeDir')
+
+      expect(config.placeholder).toBeDefined()
+      expect(config.placeholder.length).toBeGreaterThan(0)
+    })
+  })
+
+  describe('TopBannerType state', () => {
+    test('should support homeDir banner type', () => {
+      const store = useChatStore.getState()
+
+      store.setActiveTopBanner('homeDir')
+
+      expect(useChatStore.getState().activeTopBanner).toBe('homeDir')
+    })
+
+    test('should support null (no banner)', () => {
+      const store = useChatStore.getState()
+
+      store.setActiveTopBanner('homeDir')
+      store.setActiveTopBanner(null)
+
+      expect(useChatStore.getState().activeTopBanner).toBeNull()
+    })
+  })
+
+  describe('reset behavior', () => {
+    test('reset should clear home directory banner state', () => {
+      const store = useChatStore.getState()
+
+      store.setActiveTopBanner('homeDir')
+      store.setInputMode('homeDir')
+
+      store.reset()
+
+      const state = useChatStore.getState()
+      expect(state.activeTopBanner).toBeNull()
+      expect(state.inputMode).toBe('default')
+    })
+  })
+})