@alumbwe/anvil 1.0.0 → 1.0.1

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

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

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