@alumbwe/anvil 1.0.0

package/src/__tests__/release/wrapper-safety.test.ts

@@ -0,0 +1,412 @@
+import { describe, expect, test } from 'bun:test'
+import { EventEmitter } from 'node:events'
+import { createServer } from 'node:http'
+import { constants as fsConstants } from 'node:fs'
+import {
+  copyFileSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import { createRequire } from 'node:module'
+import type { AddressInfo } from 'node:net'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { fileURLToPath } from 'node:url'
+
+// node-tar opens files on Windows with the numeric UV_FS_O_FILEMAP flag for
+// small entries (oven-sh/bun#12696). bun's fs.open rejects that flag with
+// EINVAL, so extraction silently writes nothing under `bun test` on Windows.
+// The launcher itself runs under node (where the flag works), so this only
+// affects the test runner. Zeroing the constant makes tar fall back to the
+// plain 'w' flag. Must run before any `require('tar')` (the launcher loads it
+// at module top), hence the import above.
+fsConstants.UV_FS_O_FILEMAP = 0
+
+const repoRoot = fileURLToPath(new URL('../../../../', import.meta.url))
+const require = createRequire(import.meta.url)
+
+async function withLocalReleaseServer(
+  response: {
+    statusCode: number
+    body: string | Buffer
+    headers?: Record<string, string | number>
+  },
+  run: (requestedPaths: string[]) => Promise<void>,
+) {
+  const requestedPaths: string[] = []
+  const server = createServer((request, serverResponse) => {
+    requestedPaths.push(request.url ?? '')
+    serverResponse.writeHead(response.statusCode, response.headers)
+    serverResponse.end(response.body)
+  })
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve))
+
+  const previousAppUrl = process.env.NEXT_PUBLIC_ANVIL_APP_URL
+  const previousNoProxy = process.env.NO_PROXY
+  const address = server.address() as AddressInfo
+  process.env.NEXT_PUBLIC_ANVIL_APP_URL = `http://127.0.0.1:${address.port}`
+  process.env.NO_PROXY = '127.0.0.1'
+
+  try {
+    await run(requestedPaths)
+  } finally {
+    if (previousAppUrl === undefined) {
+      delete process.env.NEXT_PUBLIC_ANVIL_APP_URL
+    } else {
+      process.env.NEXT_PUBLIC_ANVIL_APP_URL = previousAppUrl
+    }
+    if (previousNoProxy === undefined) {
+      delete process.env.NO_PROXY
+    } else {
+      process.env.NO_PROXY = previousNoProxy
+    }
+    await new Promise<void>((resolve, reject) =>
+      server.close((error) => (error ? reject(error) : resolve())),
+    )
+  }
+}
+
+const wrappers = [
+  {
+    name: 'anvil',
+    directory: 'cli/release',
+    expectedConfig: {
+      packageName: 'anvil',
+      displayName: 'Anvil',
+      tempDownloadDirName: '.download-temp',
+    },
+  },
+  {
+    name: 'codecane',
+    directory: 'cli/release-staging',
+    expectedConfig: {
+      packageName: 'codecane',
+      displayName: 'Codecane',
+      includeTreeSitterWasm: false,
+      telemetryProperties: { isStaging: true },
+      tempDownloadDirName: '.download-temp-staging',
+    },
+  },
+  {
+    name: 'freebuff',
+    directory: 'freebuff/cli/release',
+    expectedConfig: {
+      packageName: 'freebuff',
+      displayName: 'Freebuff',
+      telemetryEvent: 'cli.update_freebuff_failed',
+    },
+  },
+]
+
+for (const wrapper of wrappers) {
+  describe(`${wrapper.name} release wrapper`, () => {
+    test('contains only product configuration and package loading', () => {
+      const wrapperModule = require(
+        join(repoRoot, wrapper.directory, 'index.js'),
+      )
+      expect(wrapperModule.config).toMatchObject(wrapper.expectedConfig)
+      const packageJson = JSON.parse(
+        readFileSync(join(repoRoot, wrapper.directory, 'package.json'), 'utf8'),
+      )
+      expect(wrapperModule.config.wrapperVersion).toBe(packageJson.version)
+    })
+
+    test('has package-only lifecycle scripts', () => {
+      const packageJson = JSON.parse(
+        readFileSync(join(repoRoot, wrapper.directory, 'package.json'), 'utf8'),
+      )
+      expect(packageJson.scripts?.preinstall).toBeUndefined()
+      expect(packageJson.scripts?.install).toBeUndefined()
+      expect(packageJson.scripts?.postinstall).toBeUndefined()
+      expect(packageJson.scripts?.preuninstall).toBeUndefined()
+      expect(packageJson.scripts?.prepack).toContain('prepare-package.js')
+      expect(packageJson.scripts?.postpack).toContain('prepare-package.js')
+      expect(packageJson.files).toContain('launcher.js')
+      expect(packageJson.files).toContain('http.js')
+    })
+
+    test('prefers its bundled launcher over a source-path collision', () => {
+      const fixtureRoot = mkdtempSync(
+        join(tmpdir(), `${wrapper.name}-wrapper-`),
+      )
+      const fixtureWrapperDir = join(fixtureRoot, wrapper.directory)
+      const fixtureSourceDir = join(fixtureRoot, 'cli/release-core')
+
+      try {
+        mkdirSync(fixtureWrapperDir, { recursive: true })
+        mkdirSync(fixtureSourceDir, { recursive: true })
+        copyFileSync(
+          join(repoRoot, wrapper.directory, 'index.js'),
+          join(fixtureWrapperDir, 'index.js'),
+        )
+        copyFileSync(
+          join(repoRoot, wrapper.directory, 'package.json'),
+          join(fixtureWrapperDir, 'package.json'),
+        )
+
+        const fakeLauncher = (origin: string) => `
+          module.exports = {
+            createLauncher(config) {
+              return { config, main: async () => {}, origin: '${origin}' }
+            },
+          }
+        `
+        writeFileSync(
+          join(fixtureWrapperDir, 'launcher.js'),
+          fakeLauncher('packaged'),
+        )
+        writeFileSync(
+          join(fixtureSourceDir, 'launcher.js'),
+          fakeLauncher('source'),
+        )
+
+        const wrapperModule = require(join(fixtureWrapperDir, 'index.js'))
+        expect(wrapperModule.origin).toBe('packaged')
+      } finally {
+        rmSync(fixtureRoot, { recursive: true, force: true })
+      }
+    })
+  })
+}
+
+describe('shared release launcher safety', () => {
+  const launcherPath = join(repoRoot, 'cli/release-core/launcher.js')
+  const { createLauncher } = require(launcherPath)
+
+  test('stages an update before stopping the running process', () => {
+    const source = readFileSync(launcherPath, 'utf8')
+    const updateFunction = source.slice(
+      source.indexOf('async function checkForUpdates'),
+    )
+    const stageIndex = updateFunction.indexOf(
+      'const stagedBinary = await stageBinary',
+    )
+    const stopIndex = updateFunction.indexOf(
+      'await stopRunningProcess(runningProcess)',
+    )
+    const installIndex = updateFunction.indexOf(
+      'installStagedBinary(stagedBinary)',
+    )
+
+    expect(stageIndex).toBeGreaterThan(-1)
+    expect(stopIndex).toBeGreaterThan(stageIndex)
+    expect(installIndex).toBeGreaterThan(stopIndex)
+  })
+
+  test('requires the wrapper release only for missing or older binaries', () => {
+    const cases: Array<{
+      wrapperVersion: string
+      expectations: Array<[current: string | null, required: string | null]>
+    }> = [
+      {
+        wrapperVersion: '2.0.0',
+        expectations: [
+          [null, '2.0.0'],
+          ['1.9.9', '2.0.0'],
+          ['2.0.0-beta.7', '2.0.0'],
+          ['2.0.0', null],
+          ['2.1.0', null],
+          ['02.0.0', '2.0.0'],
+          ['2.0.0+cached', null],
+        ],
+      },
+      {
+        wrapperVersion: '2.0.0-beta.7',
+        expectations: [
+          ['2.0.0-beta.6', '2.0.0-beta.7'],
+          ['2.0.0-beta.7', null],
+          ['2.0.0-beta.8', null],
+          ['2.0.0', null],
+          ['2.0.0-beta.007', '2.0.0-beta.7'],
+        ],
+      },
+      {
+        wrapperVersion: '2.0.0-beta.9007199254740993',
+        expectations: [
+          ['2.0.0-beta.9007199254740992', '2.0.0-beta.9007199254740993'],
+          ['2.0.0-beta.9007199254740994', null],
+        ],
+      },
+    ]
+
+    for (const { wrapperVersion, expectations } of cases) {
+      const launcher = createLauncher({
+        packageName: 'test',
+        displayName: 'Test',
+        wrapperVersion,
+      })
+      for (const [currentVersion, requiredVersion] of expectations) {
+        expect(
+          launcher.__testing.getRequiredWrapperVersion(currentVersion),
+        ).toBe(requiredVersion)
+      }
+    }
+  })
+
+  test('repairs an older cached binary from the wrapper release', async () => {
+    const fixtureRoot = mkdtempSync(join(tmpdir(), 'launcher-repair-'))
+    const configDir = join(fixtureRoot, 'config')
+    const archiveDir = join(fixtureRoot, 'archive')
+    const archivePath = join(fixtureRoot, 'release.tar.gz')
+    mkdirSync(configDir, { recursive: true })
+    mkdirSync(archiveDir, { recursive: true })
+
+    const launcher = createLauncher({
+      packageName: 'repair-test',
+      displayName: 'Repair Test',
+      wrapperVersion: '2.0.0',
+      includeTreeSitterWasm: false,
+      configDir,
+    })
+    const { CONFIG } = launcher.__testing
+    writeFileSync(CONFIG.binaryPath, 'stale binary')
+    writeFileSync(
+      CONFIG.metadataPath,
+      JSON.stringify({
+        version: '1.0.0',
+        target: process.platform + '-' + process.arch,
+      }),
+    )
+    writeFileSync(join(archiveDir, CONFIG.binaryName), 'replacement binary')
+
+    const tar = require('tar') as typeof import('tar')
+    await tar.c({ cwd: archiveDir, file: archivePath, gzip: true }, [
+      CONFIG.binaryName,
+    ])
+    const archive = readFileSync(archivePath)
+    try {
+      await withLocalReleaseServer(
+        {
+          statusCode: 200,
+          body: archive,
+          headers: {
+            'content-length': archive.byteLength,
+            'content-type': 'application/gzip',
+          },
+        },
+        async (requestedPaths) => {
+          await launcher.__testing.ensureBinaryReady()
+
+          expect(readFileSync(CONFIG.binaryPath, 'utf8')).toBe(
+            'replacement binary',
+          )
+          expect(
+            JSON.parse(readFileSync(CONFIG.metadataPath, 'utf8')),
+          ).toMatchObject({ version: '2.0.0' })
+          expect(requestedPaths[0]).toContain('/api/releases/download/2.0.0/')
+
+          await launcher.__testing.ensureBinaryReady()
+          expect(requestedPaths).toHaveLength(1)
+        },
+      )
+    } finally {
+      rmSync(fixtureRoot, { recursive: true, force: true })
+    }
+  })
+
+  test('accepts only non-empty string metadata versions', () => {
+    const launcher = createLauncher({
+      packageName: 'test',
+      displayName: 'Test',
+      wrapperVersion: '2.0.0',
+    })
+
+    expect(launcher.__testing.getMetadataVersion({ version: 1 })).toBeNull()
+    expect(launcher.__testing.getMetadataVersion({ version: '' })).toBeNull()
+    expect(launcher.__testing.getMetadataVersion(null)).toBeNull()
+  })
+
+  test('keeps a runnable cached binary when repair is unavailable', async () => {
+    const fixtureRoot = mkdtempSync(join(tmpdir(), 'launcher-offline-'))
+    const launcher = createLauncher({
+      packageName: 'offline-test',
+      displayName: 'Offline Test',
+      wrapperVersion: '2.0.0',
+      includeTreeSitterWasm: false,
+      configDir: fixtureRoot,
+    })
+    const { CONFIG } = launcher.__testing
+    writeFileSync(CONFIG.binaryPath, 'cached binary')
+    writeFileSync(
+      CONFIG.metadataPath,
+      JSON.stringify({
+        version: '1.0.0',
+        target: process.platform + '-' + process.arch,
+      }),
+    )
+
+    try {
+      await withLocalReleaseServer(
+        { statusCode: 404, body: 'missing' },
+        async () => {
+          await launcher.__testing.ensureBinaryReady()
+          expect(readFileSync(CONFIG.binaryPath, 'utf8')).toBe('cached binary')
+          expect(
+            JSON.parse(readFileSync(CONFIG.metadataPath, 'utf8')),
+          ).toMatchObject({ version: '1.0.0' })
+        },
+      )
+    } finally {
+      rmSync(fixtureRoot, { recursive: true, force: true })
+    }
+  })
+
+  test('gives the binary its launcher pid', () => {
+    const source = readFileSync(launcherPath, 'utf8')
+    const spawnFunction = source.slice(
+      source.indexOf('function spawnInstalledBinary'),
+      source.indexOf('function watchLaunch'),
+    )
+    expect(spawnFunction).not.toBe('')
+
+    expect(spawnFunction).toContain(
+      'ANVIL_LAUNCHER_PID: String(process.pid)',
+    )
+    // stderr is teed on Windows to keep native-crash output (see watchLaunch),
+    // but stdin/stdout must stay inherited or the TUI loses its tty.
+    expect(spawnFunction).toContain("['inherit', 'inherit', 'pipe']")
+    expect(spawnFunction).toContain("['inherit', 'inherit', 'inherit']")
+  })
+
+  test('cleans up process-stop listeners and timers', async () => {
+    const { stopRunningProcess } = createLauncher({
+      packageName: 'test',
+      displayName: 'Test',
+    })
+    const runningProcess = new EventEmitter() as EventEmitter & {
+      kill(signal: string): boolean
+    }
+    const signals: string[] = []
+    runningProcess.kill = (signal) => {
+      signals.push(signal)
+      runningProcess.emit('exit', 0, null)
+      return true
+    }
+
+    await stopRunningProcess(runningProcess)
+
+    expect(signals).toEqual(['SIGTERM'])
+    expect(runningProcess.listenerCount('exit')).toBe(0)
+  })
+
+  test('cleans up when stopping the process throws', async () => {
+    const { stopRunningProcess } = createLauncher({
+      packageName: 'test',
+      displayName: 'Test',
+    })
+    const runningProcess = new EventEmitter() as EventEmitter & {
+      kill(signal: string): boolean
+    }
+    runningProcess.kill = () => {
+      throw new Error('kill failed')
+    }
+
+    await expect(stopRunningProcess(runningProcess)).rejects.toThrow(
+      'kill failed',
+    )
+    expect(runningProcess.listenerCount('exit')).toBe(0)
+  })
+})

package/src/__tests__/renderer-cleanup.test.ts

@@ -0,0 +1,174 @@
+import { spawn } from 'child_process'
+import path from 'path'
+
+import { afterEach, describe, expect, test } from 'bun:test'
+import stripAnsi from 'strip-ansi'
+
+import { ensureCliTestEnv, isTmuxAvailable, sleep } from './test-utils'
+
+ensureCliTestEnv()
+
+const FIXTURE = path.join(
+  import.meta.dir,
+  'helpers',
+  'renderer-cleanup-fixture.tsx',
+)
+const LAUNCHER_FIXTURE = path.join(
+  import.meta.dir,
+  'helpers',
+  'launcher-disconnect-fixture.cjs',
+)
+const tmuxAvailable = isTmuxAvailable()
+const sessions: string[] = []
+
+function tmux(args: string[]): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const child = spawn('tmux', args, { stdio: 'pipe' })
+    let stdout = ''
+    let stderr = ''
+    child.stdout?.on('data', (chunk) => {
+      stdout += chunk
+    })
+    child.stderr?.on('data', (chunk) => {
+      stderr += chunk
+    })
+    child.on('close', (code) => {
+      if (code === 0) resolve(stdout)
+      else reject(new Error(stderr))
+    })
+  })
+}
+
+async function runFixture(
+  mode:
+    | 'clean'
+    | 'fatal'
+    | 'rejection'
+    | 'unprintable-rejection'
+    | 'launcher-disconnect'
+    | 'sigint'
+    | 'sigterm'
+    | 'sighup',
+): Promise<{
+  output: string
+  exitCode: number
+}> {
+  const session = `renderer-cleanup-${mode}-${Date.now()}`
+  sessions.push(session)
+  await tmux([
+    'new-session',
+    '-d',
+    '-s',
+    session,
+    '-x',
+    '100',
+    '-y',
+    '20',
+    mode === 'launcher-disconnect'
+      ? `node ${LAUNCHER_FIXTURE} observe ${FIXTURE}`
+      : `bun ${FIXTURE} ${mode}`,
+  ])
+  await tmux(['set-option', '-t', session, 'remain-on-exit', 'on'])
+
+  let paneDead = false
+  for (let attempt = 0; attempt < 100; attempt++) {
+    const status = await tmux([
+      'display-message',
+      '-p',
+      '-t',
+      session,
+      '#{pane_dead} #{pane_dead_status}',
+    ])
+    if (status.startsWith('1 ')) {
+      paneDead = true
+      break
+    }
+    await sleep(50)
+  }
+  expect(paneDead).toBe(true)
+
+  const status = await tmux([
+    'display-message',
+    '-p',
+    '-t',
+    session,
+    '#{pane_dead_status}',
+  ])
+  const output = stripAnsi(await tmux(['capture-pane', '-p', '-t', session]))
+  return { output, exitCode: Number(status.trim()) }
+}
+
+afterEach(async () => {
+  await Promise.all(
+    sessions
+      .splice(0)
+      .map((session) =>
+        tmux(['kill-session', '-t', session]).catch(() => undefined),
+      ),
+  )
+})
+
+describe.skipIf(!tmuxAvailable)('renderer cleanup', () => {
+  test('clean exit restores the main screen after a frame-active shutdown', async () => {
+    const result = await runFixture('clean')
+
+    expect(result.exitCode).toBe(0)
+    expect(result.output).toContain('CLEAN_EXIT_VISIBLE')
+    expect(result.output).not.toContain(
+      'ALTERNATE_SCREEN_CONTENT_SHOULD_NOT_SURVIVE',
+    )
+  })
+
+  test('fatal errors remain visible after a frame-active shutdown', async () => {
+    const result = await runFixture('fatal')
+
+    expect(result.exitCode).toBe(1)
+    expect(result.output).toContain('fatal-cleanup-fixture')
+    expect(result.output).not.toContain(
+      'ALTERNATE_SCREEN_CONTENT_SHOULD_NOT_SURVIVE',
+    )
+  })
+
+  test('unhandled rejections remain visible after a frame-active shutdown', async () => {
+    const result = await runFixture('rejection')
+
+    expect(result.exitCode).toBe(1)
+    expect(result.output).toContain('rejection-cleanup-fixture')
+    expect(result.output).not.toContain(
+      'ALTERNATE_SCREEN_CONTENT_SHOULD_NOT_SURVIVE',
+    )
+  })
+
+  test('unprintable rejection reasons cannot break fatal cleanup', async () => {
+    const result = await runFixture('unprintable-rejection')
+
+    expect(result.exitCode).toBe(1)
+    expect(result.output).toContain('Unhandled rejection: <unprintable error>')
+    expect(result.output).not.toContain(
+      'ALTERNATE_SCREEN_CONTENT_SHOULD_NOT_SURVIVE',
+    )
+  })
+
+  test('launcher death restores the main screen and exits the orphaned CLI', async () => {
+    const result = await runFixture('launcher-disconnect')
+
+    expect(result.exitCode).toBe(0)
+    expect(result.output).toContain('CLEAN_EXIT_VISIBLE')
+    expect(result.output).toContain('CLI_EXITED_AFTER_LAUNCHER')
+    expect(result.output).not.toContain(
+      'ALTERNATE_SCREEN_CONTENT_SHOULD_NOT_SURVIVE',
+    )
+  })
+
+  for (const mode of ['sigint', 'sigterm', 'sighup'] as const) {
+    test(`${mode.toUpperCase()} restores the main screen during an active frame`, async () => {
+      const result = await runFixture(mode)
+
+      expect(result.exitCode).toBe(0)
+      expect(result.output).toContain('CLEAN_EXIT_VISIBLE')
+      expect(result.output).not.toContain(
+        'ALTERNATE_SCREEN_CONTENT_SHOULD_NOT_SURVIVE',
+      )
+    })
+  }
+})