@alumbwe/anvil 1.0.0

package/src/__tests__/launcher-disconnect.test.ts

@@ -0,0 +1,104 @@
+import { spawn } from 'child_process'
+import path from 'path'
+
+import { expect, test } from 'bun:test'
+
+import { ensureCliTestEnv } from './test-utils'
+
+ensureCliTestEnv()
+
+const LAUNCHER_FIXTURE = path.join(
+  import.meta.dir,
+  'helpers',
+  'launcher-disconnect-fixture.cjs',
+)
+const RENDERER_FIXTURE = path.join(
+  import.meta.dir,
+  'helpers',
+  'renderer-cleanup-fixture.tsx',
+)
+
+/**
+ * How long to keep reading after the fixture exits. Its diagnostics are written
+ * immediately before `process.exit`, so the bytes are already in the pipe and
+ * this only covers the hand-off — measured, 100ms was enough to capture them in
+ * full. Kept well above that, but deliberately short: the fixture bounds itself
+ * at ~21s worst case (15s renderer-ready deadline, then a 6s survival window
+ * that starts only once the launcher is killed), and the headroom under the
+ * test timeout below is what stops a slow runner from turning a real failure
+ * back into the contentless timeout this indirection exists to prevent. A cold
+ * Windows CI runner once ate most of a start-anchored budget just booting bun,
+ * landing the whole run on the old 15s test timeout with zero diagnostics.
+ */
+const OUTPUT_DRAIN_MS = 750
+
+test('the CLI exits cleanly when its package launcher disappears', async () => {
+  const result = await new Promise<{
+    code: number | null
+    signal: NodeJS.Signals | null
+    output: string
+  }>((resolve, reject) => {
+    const child = spawn(
+      'node',
+      [LAUNCHER_FIXTURE, 'observe', RENDERER_FIXTURE],
+      { stdio: ['ignore', 'pipe', 'pipe'] },
+    )
+    let output = ''
+    let exit: { code: number | null; signal: NodeJS.Signals | null } | undefined
+    let openStreams = 2
+    let settled = false
+    let drain: ReturnType<typeof setTimeout> | undefined
+
+    // Report as soon as we know the exit status AND either the pipes drained or
+    // the drain window elapsed. Nothing resolves without an exit status, so a
+    // surviving CLI still fails the assertions below rather than passing.
+    const settle = () => {
+      if (settled || !exit) return
+      settled = true
+      if (drain) clearTimeout(drain)
+      resolve({ ...exit, output })
+    }
+    const onStreamEnd = () => {
+      openStreams -= 1
+      if (openStreams === 0) settle()
+    }
+
+    child.stdout.on('data', (chunk) => {
+      output += chunk
+    })
+    child.stderr.on('data', (chunk) => {
+      output += chunk
+    })
+    child.stdout.once('end', onStreamEnd)
+    child.stderr.once('end', onStreamEnd)
+    child.once('error', reject)
+
+    // Wait on 'exit', not 'close'. The fixture spawns both the launcher and the
+    // CLI with stdio:'inherit', so those grandchildren hold these pipes open. A
+    // CLI that outlives its launcher — the exact failure this test exists to
+    // catch — keeps them open forever, so 'close' never fires and the run died
+    // on the 15s timeout instead, throwing away the fixture's exit code and its
+    // "CLI survived after its launcher exited" diagnostic.
+    child.once('exit', (code, signal) => {
+      exit = { code, signal }
+      if (openStreams === 0) {
+        settle()
+        return
+      }
+      drain = setTimeout(settle, OUTPUT_DRAIN_MS)
+    })
+  })
+
+  if (result.code !== 0) {
+    console.error(
+      result.output ||
+        '(fixture exited without any captured output — it writes its diagnostic ' +
+          'immediately before process.exit, which can truncate a piped write)',
+    )
+  }
+  expect(result.code).toBe(0)
+  expect(result.signal).toBeNull()
+  expect(result.output).toContain('CLEAN_EXIT_VISIBLE')
+  expect(result.output).toContain('CLI_EXITED_AFTER_LAUNCHER')
+  expect(result.output).not.toContain('CLI survived after its launcher exited')
+}, 30_000)

package/src/__tests__/mocks/hover-toggle-controller.ts

@@ -0,0 +1,71 @@
+import {
+  OPEN_DELAY_MS,
+  CLOSE_DELAY_MS,
+  REOPEN_SUPPRESS_MS,
+} from '../../components/agent-mode-toggle'
+
+export const createHoverToggleControllerForTest = () => {
+  let isOpen = false
+  let reopenBlockedUntil = 0
+  let openTimeout: any = null
+  let closeTimeout: any = null
+
+  const clearOpenTimer = () => {
+    clearTimeout(openTimeout)
+    openTimeout = null
+  }
+
+  const clearCloseTimer = () => {
+    clearTimeout(closeTimeout)
+    closeTimeout = null
+  }
+
+  const clearAllTimers = () => {
+    clearOpenTimer()
+    clearCloseTimer()
+  }
+
+  const openNow = () => {
+    clearAllTimers()
+    isOpen = true
+  }
+
+  const closeNow = (suppressReopen = false) => {
+    clearAllTimers()
+    isOpen = false
+    if (suppressReopen) {
+      reopenBlockedUntil = Date.now() + REOPEN_SUPPRESS_MS
+    }
+  }
+
+  const scheduleOpen = () => {
+    if (isOpen) return
+    if (Date.now() < reopenBlockedUntil) return
+    clearOpenTimer()
+    openTimeout = setTimeout(() => {
+      openNow()
+    }, OPEN_DELAY_MS)
+  }
+
+  const scheduleClose = () => {
+    if (!isOpen) return
+    clearCloseTimer()
+    closeTimeout = setTimeout(() => {
+      isOpen = false
+      closeTimeout = null
+    }, CLOSE_DELAY_MS)
+  }
+
+  return {
+    get isOpen() {
+      return isOpen
+    },
+    openNow,
+    closeNow,
+    scheduleOpen,
+    scheduleClose,
+    clearOpenTimer,
+    clearCloseTimer,
+    clearAllTimers,
+  }
+}

package/src/__tests__/open-tui-native-bundle.test.ts

@@ -0,0 +1,378 @@
+import {
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from 'fs'
+import { tmpdir } from 'os'
+import { basename, dirname, join } from 'path'
+
+import { afterEach, describe, expect, test } from 'bun:test'
+
+import {
+  ensureOpenTuiNativeBundle,
+  getValidBundleVersion,
+  sealOpenTuiNativeBundle,
+} from '../../scripts/open-tui-native-bundle'
+
+const TARGET = { platform: 'win32', arch: 'x64' } as const
+const CURRENT_VERSION = '0.3.4'
+const PREVIOUS_VERSION = '0.3.3'
+const PACKAGE_NAME = '@opentui/core-win32-x64'
+
+let testRoot: string | null = null
+
+function createPackageDir(): string {
+  testRoot = mkdtempSync(join(tmpdir(), 'opentui-native-bundle-test-'))
+  return join(testRoot, '@opentui', 'core-win32-x64')
+}
+
+function writeCompleteBundle(packageDir: string, version: string): void {
+  mkdirSync(packageDir, { recursive: true })
+  writeFileSync(
+    join(packageDir, 'package.json'),
+    JSON.stringify({
+      name: PACKAGE_NAME,
+      version,
+      os: [TARGET.platform],
+      cpu: [TARGET.arch],
+    }),
+  )
+  writeFileSync(join(packageDir, 'index.bun.js'), 'export default "native"')
+  writeFileSync(join(packageDir, 'opentui.dll'), `dll-${version}`)
+  sealOpenTuiNativeBundle(packageDir, version, TARGET)
+}
+
+function writeStagedBundle(stagingRoot: string, version: string): void {
+  writeCompleteBundle(
+    join(stagingRoot, 'node_modules', '@opentui', 'core-win32-x64'),
+    version,
+  )
+}
+
+function stagingDirectories(packageDir: string): string[] {
+  const prefix = `.${basename(packageDir)}-install-`
+  return readdirSync(dirname(packageDir)).filter((entry) =>
+    entry.startsWith(prefix),
+  )
+}
+
+function removeDirectory(directory: string): void {
+  rmSync(directory, { recursive: true, force: true })
+}
+
+afterEach(() => {
+  if (testRoot) {
+    rmSync(testRoot, { recursive: true, force: true })
+    testRoot = null
+  }
+})
+
+describe('OpenTUI native bundle identity', () => {
+  // The glibc and musl packages are byte-identical in layout and differ only in
+  // their `name`, so validating one against the other's target silently
+  // rejected a good install as "incomplete or incompatible" — which is how
+  // every Linux build broke on the 0.3.4 upgrade.
+  const MUSL_TARGET = { platform: 'linux', arch: 'x64', libc: 'musl' } as const
+  const GLIBC_TARGET = { platform: 'linux', arch: 'x64' } as const
+
+  function writeLinuxBundle(
+    packageDir: string,
+    packageName: string,
+    libc?: 'musl',
+  ): void {
+    mkdirSync(packageDir, { recursive: true })
+    writeFileSync(
+      join(packageDir, 'package.json'),
+      JSON.stringify({
+        name: packageName,
+        version: CURRENT_VERSION,
+        os: ['linux'],
+        cpu: ['x64'],
+        ...(libc ? { libc: [libc] } : {}),
+      }),
+    )
+    writeFileSync(join(packageDir, 'index.bun.js'), 'export default "native"')
+    writeFileSync(join(packageDir, 'libopentui.so'), `so-${CURRENT_VERSION}`)
+  }
+
+  test('accepts the musl package under a musl target', () => {
+    testRoot = mkdtempSync(join(tmpdir(), 'opentui-native-bundle-test-'))
+    const packageDir = join(testRoot, '@opentui', 'core-linux-x64-musl')
+    writeLinuxBundle(packageDir, '@opentui/core-linux-x64-musl', 'musl')
+
+    sealOpenTuiNativeBundle(packageDir, CURRENT_VERSION, MUSL_TARGET)
+    expect(getValidBundleVersion(packageDir, MUSL_TARGET)).toBe(CURRENT_VERSION)
+  })
+
+  test('rejects the musl package under a glibc target', () => {
+    testRoot = mkdtempSync(join(tmpdir(), 'opentui-native-bundle-test-'))
+    const packageDir = join(testRoot, '@opentui', 'core-linux-x64-musl')
+    writeLinuxBundle(packageDir, '@opentui/core-linux-x64-musl', 'musl')
+
+    expect(() =>
+      sealOpenTuiNativeBundle(packageDir, CURRENT_VERSION, GLIBC_TARGET),
+    ).toThrow('is incomplete or incompatible')
+  })
+
+  test('rejects the glibc package under a musl target', () => {
+    testRoot = mkdtempSync(join(tmpdir(), 'opentui-native-bundle-test-'))
+    const packageDir = join(testRoot, '@opentui', 'core-linux-x64')
+    writeLinuxBundle(packageDir, '@opentui/core-linux-x64')
+
+    expect(() =>
+      sealOpenTuiNativeBundle(packageDir, CURRENT_VERSION, MUSL_TARGET),
+    ).toThrow('is incomplete or incompatible')
+  })
+})
+
+describe('OpenTUI native bundle recovery', () => {
+  test('reuses a complete matching bundle', () => {
+    const packageDir = createPackageDir()
+    writeCompleteBundle(packageDir, CURRENT_VERSION)
+    let installCalls = 0
+
+    const result = ensureOpenTuiNativeBundle({
+      packageDir,
+      version: CURRENT_VERSION,
+      targetInfo: TARGET,
+      installBundle: () => {
+        installCalls++
+      },
+    })
+
+    expect(result).toBe('reused')
+    expect(installCalls).toBe(0)
+  })
+
+  test.each([
+    ['missing bundle', (_packageDir: string) => {}],
+    [
+      'missing native library',
+      (packageDir: string) => {
+        writeCompleteBundle(packageDir, CURRENT_VERSION)
+        rmSync(join(packageDir, 'opentui.dll'))
+      },
+    ],
+    [
+      'empty native library',
+      (packageDir: string) => {
+        writeCompleteBundle(packageDir, CURRENT_VERSION)
+        writeFileSync(join(packageDir, 'opentui.dll'), '')
+      },
+    ],
+    [
+      'nonempty truncated native library',
+      (packageDir: string) => {
+        writeCompleteBundle(packageDir, CURRENT_VERSION)
+        writeFileSync(join(packageDir, 'opentui.dll'), 'MZ-partial')
+      },
+    ],
+    [
+      'malformed metadata',
+      (packageDir: string) => {
+        writeCompleteBundle(packageDir, CURRENT_VERSION)
+        writeFileSync(join(packageDir, 'package.json'), '{invalid')
+      },
+    ],
+    [
+      'missing integrity receipt',
+      (packageDir: string) => {
+        writeCompleteBundle(packageDir, CURRENT_VERSION)
+        rmSync(join(packageDir, '.freebuff-native-bundle.json'))
+      },
+    ],
+    [
+      'malformed integrity receipt',
+      (packageDir: string) => {
+        writeCompleteBundle(packageDir, CURRENT_VERSION)
+        writeFileSync(
+          join(packageDir, '.freebuff-native-bundle.json'),
+          '{invalid',
+        )
+      },
+    ],
+  ])('repairs a bundle with %s', (_label, damageBundle) => {
+    const packageDir = createPackageDir()
+    damageBundle(packageDir)
+
+    const result = ensureOpenTuiNativeBundle({
+      packageDir,
+      version: CURRENT_VERSION,
+      targetInfo: TARGET,
+      installBundle: (stagingRoot) => {
+        writeStagedBundle(stagingRoot, CURRENT_VERSION)
+      },
+    })
+
+    expect(result).toBe('installed')
+    expect(getValidBundleVersion(packageDir, TARGET)).toBe(CURRENT_VERSION)
+  })
+
+  test.each([
+    [
+      'is interrupted',
+      (_stagingRoot: string) => {
+        throw new Error('install interrupted')
+      },
+    ],
+    [
+      'produces malformed output',
+      (stagingRoot: string) => {
+        const stagedPackageDir = join(
+          stagingRoot,
+          'node_modules',
+          '@opentui',
+          'core-win32-x64',
+        )
+        mkdirSync(stagedPackageDir, { recursive: true })
+        writeFileSync(join(stagedPackageDir, 'package.json'), '{invalid')
+      },
+    ],
+  ])('preserves a valid previous bundle when staging %s', (_label, stage) => {
+    const packageDir = createPackageDir()
+    writeCompleteBundle(packageDir, PREVIOUS_VERSION)
+
+    expect(() =>
+      ensureOpenTuiNativeBundle({
+        packageDir,
+        version: CURRENT_VERSION,
+        targetInfo: TARGET,
+        installBundle: stage,
+      }),
+    ).toThrow()
+
+    expect(getValidBundleVersion(packageDir, TARGET)).toBe(PREVIOUS_VERSION)
+    expect(stagingDirectories(packageDir)).toEqual([])
+  })
+
+  test('restores an orphaned recovery copy before retrying', () => {
+    const packageDir = createPackageDir()
+    const previousDir = `${packageDir}.previous`
+    writeCompleteBundle(previousDir, PREVIOUS_VERSION)
+
+    expect(() =>
+      ensureOpenTuiNativeBundle({
+        packageDir,
+        version: CURRENT_VERSION,
+        targetInfo: TARGET,
+        installBundle: () => {
+          throw new Error('retry failed')
+        },
+      }),
+    ).toThrow('retry failed')
+
+    expect(getValidBundleVersion(packageDir, TARGET)).toBe(PREVIOUS_VERSION)
+    expect(getValidBundleVersion(previousDir, TARGET)).toBeNull()
+  })
+
+  test('reuses a valid bundle when stale recovery cleanup fails', () => {
+    const packageDir = createPackageDir()
+    const previousDir = `${packageDir}.previous`
+    writeCompleteBundle(packageDir, CURRENT_VERSION)
+    writeCompleteBundle(previousDir, PREVIOUS_VERSION)
+    let installCalls = 0
+
+    const result = ensureOpenTuiNativeBundle({
+      packageDir,
+      version: CURRENT_VERSION,
+      targetInfo: TARGET,
+      installBundle: () => {
+        installCalls++
+      },
+      removeDirectory: (directory) => {
+        if (directory === previousDir) throw new Error('recovery copy is busy')
+        removeDirectory(directory)
+      },
+    })
+
+    expect(result).toBe('reused')
+    expect(installCalls).toBe(0)
+    expect(getValidBundleVersion(packageDir, TARGET)).toBe(CURRENT_VERSION)
+    expect(getValidBundleVersion(previousDir, TARGET)).toBe(PREVIOUS_VERSION)
+  })
+
+  test('keeps a successful swap when recovery cleanup fails', () => {
+    const packageDir = createPackageDir()
+    const previousDir = `${packageDir}.previous`
+    writeCompleteBundle(packageDir, PREVIOUS_VERSION)
+
+    const result = ensureOpenTuiNativeBundle({
+      packageDir,
+      version: CURRENT_VERSION,
+      targetInfo: TARGET,
+      installBundle: (stagingRoot) => {
+        writeStagedBundle(stagingRoot, CURRENT_VERSION)
+      },
+      removeDirectory: (directory) => {
+        if (directory === previousDir) throw new Error('recovery copy is busy')
+        removeDirectory(directory)
+      },
+    })
+
+    expect(result).toBe('installed')
+    expect(getValidBundleVersion(packageDir, TARGET)).toBe(CURRENT_VERSION)
+    expect(getValidBundleVersion(previousDir, TARGET)).toBe(PREVIOUS_VERSION)
+    expect(stagingDirectories(packageDir)).toEqual([])
+  })
+
+  test('reuses a valid bundle installed by a concurrent winner', () => {
+    const packageDir = createPackageDir()
+
+    const result = ensureOpenTuiNativeBundle({
+      packageDir,
+      version: CURRENT_VERSION,
+      targetInfo: TARGET,
+      installBundle: (stagingRoot) => {
+        writeStagedBundle(stagingRoot, CURRENT_VERSION)
+      },
+      renameDirectory: (source, destination) => {
+        if (destination === packageDir) {
+          writeCompleteBundle(packageDir, CURRENT_VERSION)
+          throw new Error('destination already installed')
+        }
+        renameSync(source, destination)
+      },
+    })
+
+    expect(result).toBe('reused')
+    expect(getValidBundleVersion(packageDir, TARGET)).toBe(CURRENT_VERSION)
+    expect(stagingDirectories(packageDir)).toEqual([])
+  })
+
+  test('restores the previous bundle when the final swap fails', () => {
+    const packageDir = createPackageDir()
+    writeCompleteBundle(packageDir, PREVIOUS_VERSION)
+    let renameCalls = 0
+
+    expect(() =>
+      ensureOpenTuiNativeBundle({
+        packageDir,
+        version: CURRENT_VERSION,
+        targetInfo: TARGET,
+        installBundle: (stagingRoot) => {
+          writeStagedBundle(stagingRoot, CURRENT_VERSION)
+        },
+        renameDirectory: (source, destination) => {
+          renameCalls++
+          if (
+            renameCalls === 2 &&
+            basename(destination) === basename(packageDir)
+          ) {
+            throw new Error('final rename failed')
+          }
+          renameSync(source, destination)
+        },
+      }),
+    ).toThrow('final rename failed')
+
+    expect(renameCalls).toBe(3)
+    expect(getValidBundleVersion(packageDir, TARGET)).toBe(PREVIOUS_VERSION)
+    expect(readFileSync(join(packageDir, 'opentui.dll'), 'utf8')).toBe(
+      `dll-${PREVIOUS_VERSION}`,
+    )
+  })
+})