@astrale-os/cli 1.0.0-beta.32 → 1.0.0-beta.43

package/src/lib/__tests__/studio-server-deps.test.ts

@@ -1,111 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { readFileSync, readdirSync, statSync } from 'node:fs'
-import { join, relative } from 'node:path'
-import { Project } from 'ts-morph'
-
-/**
- * The Domain Studio SERVER ships as raw source inside the published CLI package
- * (package.json `files`: studio/server, studio/shared) and runs UNBUNDLED under
- * Bun — unlike the CLI itself, which is bundled into dist/astrale.js with all its
- * deps inlined. So at `astrale studio` runtime, the server can only resolve the
- * third-party packages that the CLI declares in its own `dependencies` (the
- * studio's package.json deps are NOT installed for an `npm i -g @astrale-os/cli`
- * consumer — they're client/build-only, inlined into studio/client/dist).
- *
- * This test enforces that invariant. If it fails, either add the package to the
- * CLI's `dependencies` or drop the import — do NOT add it to studio/package.json
- * (that won't ship to npm consumers).
- */
-
-const CLI_ROOT = new URL('../../../', import.meta.url).pathname
-
-interface PackageManifest {
-  dependencies?: Record<string, string>
-  scripts?: Record<string, string>
-}
-
-const cliPackage = JSON.parse(
-  readFileSync(join(CLI_ROOT, 'package.json'), 'utf8'),
-) as PackageManifest
-const studioPackage = JSON.parse(
-  readFileSync(join(CLI_ROOT, 'studio/package.json'), 'utf8'),
-) as PackageManifest
-
-/** Base package of a bare specifier: `@scope/pkg/sub` → `@scope/pkg`, `pkg/sub` → `pkg`. */
-function basePackage(spec: string): string {
-  const parts = spec.split('/')
-  return spec.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0]!
-}
-
-function isBuiltin(spec: string): boolean {
-  return spec.startsWith('node:') || spec === 'bun' || spec.startsWith('bun:')
-}
-
-function runtimeFiles(directory: string): string[] {
-  return readdirSync(directory).flatMap((entry) => {
-    const path = join(directory, entry)
-    if (statSync(path).isDirectory()) return runtimeFiles(path)
-    return /\.(?:ts|tsx)$/.test(path) && !/\.test\.(?:ts|tsx)$/.test(path) ? [path] : []
-  })
-}
-
-const studioPath = (path: string) => relative(CLI_ROOT, path).replaceAll('\\', '/')
-
-describe('studio server runtime deps', () => {
-  const deps = new Set(Object.keys(cliPackage.dependencies ?? {}))
-
-  const project = new Project({ skipAddingFilesFromTsConfig: true })
-  project.addSourceFilesAtPaths([
-    join(CLI_ROOT, 'studio/server/**/*.ts'),
-    join(CLI_ROOT, 'studio/server/**/*.tsx'),
-    join(CLI_ROOT, 'studio/shared/**/*.ts'),
-    join(CLI_ROOT, 'studio/shared/**/*.tsx'),
-  ])
-  const runtimeSourceFiles = project
-    .getSourceFiles()
-    .filter((sourceFile) => !/\.test\.(?:ts|tsx)$/.test(sourceFile.getBaseName()))
-
-  // getImportStringLiterals covers static imports, re-exports, and dynamic import().
-  const offenders: Record<string, string[]> = {}
-  for (const sf of runtimeSourceFiles) {
-    const specs = sf.getImportStringLiterals().map((l) => l.getLiteralValue())
-    for (const spec of specs) {
-      if (spec.startsWith('.') || spec.startsWith('/') || isBuiltin(spec)) continue
-      const pkg = basePackage(spec)
-      if (!deps.has(pkg)) (offenders[pkg] ??= []).push(sf.getFilePath().replace(CLI_ROOT, ''))
-    }
-  }
-
-  test('only import Node/Bun builtins or packages in the CLI dependencies', () => {
-    expect(
-      offenders,
-      `studio server imports packages NOT in the CLI's package.json dependencies — ` +
-        `they won't be installed for an \`npm i -g @astrale-os/cli\` consumer:\n` +
-        JSON.stringify(offenders, null, 2),
-    ).toEqual({})
-  })
-
-  test('parses every shipped Studio server and shared runtime source', () => {
-    const expected = [
-      ...runtimeFiles(join(CLI_ROOT, 'studio/server')),
-      ...runtimeFiles(join(CLI_ROOT, 'studio/shared')),
-    ]
-      .map(studioPath)
-      .sort()
-    const parsed = runtimeSourceFiles
-      .map((sourceFile) => studioPath(sourceFile.getFilePath()))
-      .sort()
-
-    expect(parsed).toEqual(expected)
-  })
-})
-
-describe('studio test gate', () => {
-  test('the root and Studio suites include all client, server, and shared tests', () => {
-    expect(cliPackage.scripts?.test).toBe(
-      'node scripts/qualification/source-boundary.mjs --target && bun test src studio/client/src studio/server studio/shared && node --test scripts/*.test.mjs',
-    )
-    expect(cliPackage.scripts?.['test:studio']).toBe('pnpm --dir studio test')
-    expect(studioPackage.scripts?.test).toBe('bun test client/src server shared')
-  })
-})

package/src/lib/__tests__/table.test.ts

@@ -1,53 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { renderTable } from '../table'
-
-const ESC = String.fromCharCode(27)
-const strip = (s: string): string => s.replace(new RegExp(`${ESC}\\[[0-9;]*m`, 'g'), '')
-
-const COLS = [
-  { key: 'name', header: 'NAME' },
-  { key: 'kind', header: 'KIND' },
-]
-
-describe('renderTable', () => {
-  test('aligns the KIND column across rows of different name widths', () => {
-    const out = strip(
-      renderTable(
-        [
-          { name: 'example.astrale.ai', kind: 'Domain' },
-          { name: 'workspace', kind: 'Folder' },
-        ],
-        { columns: COLS },
-      ),
-    )
-    const [a, b] = out.split('\n')
-    expect(a.indexOf('Domain')).toBe(b.indexOf('Folder'))
-  })
-
-  test('empty rows render as (empty)', () => {
-    expect(strip(renderTable([], { columns: COLS }))).toContain('(empty)')
-  })
-
-  test('drops a column that is empty across every row (with header)', () => {
-    const out = strip(renderTable([{ name: 'a', kind: '' }], { columns: COLS, showHeader: true }))
-    expect(out).toContain('NAME')
-    expect(out).not.toContain('KIND')
-  })
-
-  test('computes width on visible length, ignoring ANSI in cells', () => {
-    const colored = `${ESC}[32mok${ESC}[39m`
-    const out = strip(
-      renderTable(
-        [
-          { name: colored, kind: 'x' },
-          { name: 'wider-name', kind: 'y' },
-        ],
-        { columns: COLS },
-      ),
-    )
-    const [a, b] = out.split('\n')
-    // KIND aligns despite the ANSI codes that were in row 0's name cell.
-    expect(a.indexOf('x')).toBe(b.indexOf('y'))
-  })
-})

package/src/lib/__tests__/update.test.ts

@@ -1,511 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { chmod, mkdir, mkdtemp, readFile, rename, rm, symlink, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { dirname, join } from 'node:path'
-
-import {
-  admitScriptInstall,
-  classifyUpdateExecution,
-  DEFAULT_UPDATE_CHANNEL,
-  InstallMetadataSchema,
-  readInstallMetadata,
-  releaseBase,
-  replaceStandaloneCohort,
-  shouldUpdate,
-  updateAstrale,
-  writeInstallMetadata,
-  type InstallMetadata,
-  type UpdateExecution,
-} from '../update'
-
-async function makeFakeRelease(
-  root: string,
-  version: string,
-  options: { binaryVersion?: string; legacyManifest?: boolean; omitViewerIndex?: boolean } = {},
-): Promise<string> {
-  const release = join(root, 'release')
-  const payload = join(root, 'payload')
-  const binaryVersion = options.binaryVersion ?? version
-  await mkdir(release, { recursive: true })
-  await mkdir(payload, { recursive: true })
-  await writeFile(
-    join(payload, 'astrale'),
-    `#!/usr/bin/env sh\nif [ "$1" = "--version" ]; then echo "${binaryVersion}"; exit 0; fi\necho astrale\n`,
-  )
-  await chmod(join(payload, 'astrale'), 0o755)
-  await mkdir(join(payload, 'viewer', 'dist'), { recursive: true })
-  await writeFile(join(payload, 'viewer', 'dist', 'main.js'), 'viewer main\n')
-  if (!options.omitViewerIndex) {
-    await writeFile(join(payload, 'viewer', 'dist', 'index.html'), '<!doctype html>\n')
-  }
-
-  const asset = join(release, 'astrale-darwin-arm64.tar.gz')
-  const tar = Bun.spawn(['tar', '-C', payload, '-czf', asset, 'astrale', 'viewer'])
-  expect(await tar.exited).toBe(0)
-  const shaProc = Bun.spawn(['shasum', '-a', '256', asset], { stdout: 'pipe' })
-  const sha = (await new Response(shaProc.stdout).text()).trim().split(/\s+/)[0]
-  expect(await shaProc.exited).toBe(0)
-  await writeFile(join(release, 'sha256sums.txt'), `${sha}  astrale-darwin-arm64.tar.gz\n`)
-  await writeFile(
-    join(release, 'manifest.json'),
-    JSON.stringify(
-      {
-        version,
-        binaryVersion: options.binaryVersion,
-        channel: 'alpha',
-        repo: 'astrale-os/cli',
-        assets: options.legacyManifest
-          ? {
-              'darwin-arm64': 'astrale-darwin-arm64.tar.gz',
-            }
-          : {
-              'darwin-arm64': {
-                name: 'astrale-darwin-arm64.tar.gz',
-                sha256: sha,
-              },
-            },
-      },
-      null,
-      2,
-    ),
-  )
-  return release
-}
-
-async function makeInstall(
-  root: string,
-  version: string,
-): Promise<{ meta: InstallMetadata; path: string; execution: UpdateExecution }> {
-  const bin = join(root, 'bin', 'astrale')
-  await mkdir(join(root, 'bin'), { recursive: true })
-  await writeFile(
-    bin,
-    `#!/usr/bin/env sh\nif [ "$1" = "--version" ]; then echo "${version}"; exit 0; fi\necho old\n`,
-  )
-  await chmod(bin, 0o755)
-  await mkdir(join(root, 'bin', 'viewer', 'dist'), { recursive: true })
-  await writeFile(join(root, 'bin', 'viewer', 'dist', 'main.js'), 'old viewer main\n')
-  await writeFile(join(root, 'bin', 'viewer', 'dist', 'index.html'), 'old viewer html\n')
-  const path = join(root, 'home', 'install.json')
-  const meta: InstallMetadata = {
-    method: 'script',
-    channel: 'alpha',
-    version,
-    repo: 'astrale-os/cli',
-    bin,
-  }
-  await writeInstallMetadata(meta, path)
-  return { meta, path, execution: { kind: 'standalone', executable: bin } }
-}
-
-describe('update helpers', () => {
-  test('classifies only a Bun-compiled executable as standalone', () => {
-    expect(
-      classifyUpdateExecution({
-        bunVersion: '1.3.14',
-        executable: '/tmp/astrale',
-        entry: '/$bunfs/root/astrale',
-      }),
-    ).toEqual({ kind: 'standalone', executable: '/tmp/astrale' })
-    expect(
-      classifyUpdateExecution({
-        bunVersion: '1.3.14',
-        executable: '/opt/homebrew/bin/bun',
-        entry: '/tmp/astrale.ts',
-      }),
-    ).toEqual({ kind: 'package-managed', executable: '/opt/homebrew/bin/bun' })
-    expect(
-      classifyUpdateExecution({
-        executable: '/opt/homebrew/bin/node',
-        entry: '/tmp/astrale.js',
-      }),
-    ).toEqual({ kind: 'package-managed', executable: '/opt/homebrew/bin/node' })
-  })
-
-  test('defaults missing install metadata to the beta channel', () => {
-    expect(DEFAULT_UPDATE_CHANNEL).toBe('beta')
-    expect(
-      InstallMetadataSchema.parse({
-        method: 'script',
-        bin: '/tmp/astrale',
-      }).channel,
-    ).toBe('beta')
-  })
-
-  test('releaseBase resolves exact versions and channels', () => {
-    const meta: InstallMetadata = {
-      method: 'script',
-      channel: 'alpha',
-      repo: 'astrale-os/cli',
-      bin: '/tmp/astrale',
-    }
-    expect(releaseBase(meta, {})).toBe('https://github.com/astrale-os/cli/releases/download/alpha')
-    expect(releaseBase(meta, { channel: 'canary' })).toBe(
-      'https://github.com/astrale-os/cli/releases/download/canary',
-    )
-    expect(releaseBase(meta, { version: '0.4.1' })).toBe(
-      'https://github.com/astrale-os/cli/releases/download/cli/v0.4.1',
-    )
-  })
-
-  test('shouldUpdate is exact and predictable', () => {
-    expect(shouldUpdate('0.4.0', '0.4.0')).toBe(false)
-    expect(shouldUpdate('0.4.0', '0.4.1')).toBe(true)
-  })
-})
-
-describe('script install admission', () => {
-  test('a metadata commit failure restores the exact previous file', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const path = join(root, 'install.json')
-    const original = '{"exact":"previous metadata"}\n'
-    await writeFile(path, original)
-
-    await expect(
-      writeInstallMetadata(
-        {
-          method: 'script',
-          channel: 'beta',
-          version: '1.1.0',
-          repo: 'astrale-os/cli',
-          bin: '/tmp/astrale',
-        },
-        path,
-        {
-          mkdir,
-          rm,
-          writeFile,
-          rename: async (from, to) => {
-            if (String(from).endsWith('.next')) throw new Error('injected metadata commit failure')
-            await rename(from, to)
-          },
-        },
-      ),
-    ).rejects.toThrow('injected metadata commit failure')
-
-    expect(await readFile(path, 'utf8')).toBe(original)
-    await expect(readFile(`${path}.next`, 'utf8')).rejects.toMatchObject({ code: 'ENOENT' })
-    await expect(readFile(`${path}.previous`, 'utf8')).rejects.toMatchObject({ code: 'ENOENT' })
-  })
-
-  test('rejects malformed JSON with the stable metadata error', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const path = join(root, 'install.json')
-    await writeFile(path, '{')
-
-    await expect(readInstallMetadata(path)).rejects.toMatchObject({
-      code: 'UPDATE_BAD_INSTALL_METADATA',
-    })
-  })
-
-  test('admits a symlink only when it resolves to the recorded binary', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const { meta } = await makeInstall(root, '1.0.0')
-    const alias = join(root, 'astrale-alias')
-    await symlink(meta.bin, alias)
-
-    const admitted = await admitScriptInstall(meta, {
-      kind: 'standalone',
-      executable: alias,
-    })
-
-    expect(admitted.metadata).toEqual(meta)
-  })
-
-  test('rejects a standalone binary that does not own the recorded target', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const { meta } = await makeInstall(root, '1.0.0')
-    const other = join(root, 'other-astrale')
-    await writeFile(other, '#!/bin/sh\n')
-
-    await expect(
-      admitScriptInstall(meta, { kind: 'standalone', executable: other }),
-    ).rejects.toMatchObject({ code: 'UPDATE_INSTALL_MISMATCH' })
-  })
-})
-
-describe('updateAstrale', () => {
-  test('a package-managed process never consults or mutates a coexisting script install', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const { path, meta } = await makeInstall(root, '1.0.0')
-    const before = await readFile(meta.bin, 'utf8')
-    process.env.ASTRALE_UPDATE_BASE = 'file:///definitely-not-a-release'
-    try {
-      const result = await updateAstrale({
-        currentVersion: '2.0.0',
-        installPath: path,
-        execution: { kind: 'package-managed', executable: '/opt/homebrew/bin/node' },
-      })
-
-      expect(result).toEqual({
-        status: 'managed',
-        currentVersion: '2.0.0',
-        executable: '/opt/homebrew/bin/node',
-      })
-      expect(await readFile(meta.bin, 'utf8')).toBe(before)
-    } finally {
-      delete process.env.ASTRALE_UPDATE_BASE
-    }
-  })
-
-  test('check compares the installed release identity from metadata', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const { path, execution } = await makeInstall(root, 'main-abc123')
-    const release = await makeFakeRelease(root, 'main-abc123', { binaryVersion: '1.0.0' })
-    process.env.ASTRALE_UPDATE_BASE = `file://${release}`
-    try {
-      const result = await updateAstrale({
-        check: true,
-        currentVersion: '1.0.0',
-        platform: { os: 'darwin', arch: 'arm64' },
-        installPath: path,
-        execution,
-      })
-
-      expect(result).toMatchObject({
-        status: 'up-to-date',
-        currentVersion: 'main-abc123',
-        latestVersion: 'main-abc123',
-      })
-    } finally {
-      delete process.env.ASTRALE_UPDATE_BASE
-    }
-  })
-
-  test('check reports available update without replacing the binary', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const { path, meta, execution } = await makeInstall(root, '1.0.0')
-    const release = await makeFakeRelease(root, '1.1.0')
-    process.env.ASTRALE_UPDATE_BASE = `file://${release}`
-    try {
-      const result = await updateAstrale({
-        check: true,
-        currentVersion: '1.0.0',
-        platform: { os: 'darwin', arch: 'arm64' },
-        installPath: path,
-        execution,
-      })
-
-      expect(result).toMatchObject({
-        status: 'available',
-        currentVersion: '1.0.0',
-        latestVersion: '1.1.0',
-      })
-      expect(await readFile(meta.bin, 'utf8')).toContain('echo old')
-    } finally {
-      delete process.env.ASTRALE_UPDATE_BASE
-    }
-  })
-
-  test('supports legacy string asset manifests', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const { path, meta, execution } = await makeInstall(root, '1.0.0')
-    const release = await makeFakeRelease(root, '1.1.0', { legacyManifest: true })
-    process.env.ASTRALE_UPDATE_BASE = `file://${release}`
-    try {
-      const check = await updateAstrale({
-        check: true,
-        currentVersion: '1.0.0',
-        platform: { os: 'darwin', arch: 'arm64' },
-        installPath: path,
-        execution,
-      })
-
-      expect(check).toMatchObject({
-        status: 'available',
-        latestVersion: '1.1.0',
-      })
-
-      const result = await updateAstrale({
-        currentVersion: '1.0.0',
-        platform: { os: 'darwin', arch: 'arm64' },
-        installPath: path,
-        execution,
-      })
-
-      expect(result).toMatchObject({
-        status: 'updated',
-        currentVersion: '1.1.0',
-      })
-      const versionProc = Bun.spawn([meta.bin, '--version'], { stdout: 'pipe' })
-      expect(await new Response(versionProc.stdout).text()).toBe('1.1.0\n')
-      expect(await versionProc.exited).toBe(0)
-    } finally {
-      delete process.env.ASTRALE_UPDATE_BASE
-    }
-  })
-
-  test('updates the binary and install metadata', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const { path, meta, execution } = await makeInstall(root, '1.0.0')
-    const release = await makeFakeRelease(root, '1.1.0')
-    process.env.ASTRALE_UPDATE_BASE = `file://${release}`
-    try {
-      const result = await updateAstrale({
-        currentVersion: '1.0.0',
-        platform: { os: 'darwin', arch: 'arm64' },
-        installPath: path,
-        execution,
-      })
-
-      expect(result).toMatchObject({
-        status: 'updated',
-        previousVersion: '1.0.0',
-        currentVersion: '1.1.0',
-      })
-      const versionProc = Bun.spawn([meta.bin, '--version'], { stdout: 'pipe' })
-      expect(await new Response(versionProc.stdout).text()).toBe('1.1.0\n')
-      expect(await versionProc.exited).toBe(0)
-      const updatedMeta = JSON.parse(await readFile(path, 'utf8')) as InstallMetadata
-      expect(updatedMeta.version).toBe('1.1.0')
-      expect(await readFile(join(dirname(meta.bin), 'viewer', 'dist', 'main.js'), 'utf8')).toBe(
-        'viewer main\n',
-      )
-      expect(await readFile(join(dirname(meta.bin), 'viewer', 'dist', 'index.html'), 'utf8')).toBe(
-        '<!doctype html>\n',
-      )
-    } finally {
-      delete process.env.ASTRALE_UPDATE_BASE
-    }
-  })
-
-  test('a partial Viewer archive leaves the installed cohort and metadata unchanged', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const { path, meta, execution } = await makeInstall(root, '1.0.0')
-    const release = await makeFakeRelease(root, '1.1.0', { omitViewerIndex: true })
-    process.env.ASTRALE_UPDATE_BASE = `file://${release}`
-    const beforeBinary = await readFile(meta.bin, 'utf8')
-    const beforeMetadata = await readFile(path, 'utf8')
-    try {
-      await expect(
-        updateAstrale({
-          currentVersion: '1.0.0',
-          platform: { os: 'darwin', arch: 'arm64' },
-          installPath: path,
-          execution,
-        }),
-      ).rejects.toThrow()
-
-      expect(await readFile(meta.bin, 'utf8')).toBe(beforeBinary)
-      expect(await readFile(join(dirname(meta.bin), 'viewer', 'dist', 'main.js'), 'utf8')).toBe(
-        'old viewer main\n',
-      )
-      expect(await readFile(join(dirname(meta.bin), 'viewer', 'dist', 'index.html'), 'utf8')).toBe(
-        'old viewer html\n',
-      )
-      expect(await readFile(path, 'utf8')).toBe(beforeMetadata)
-    } finally {
-      delete process.env.ASTRALE_UPDATE_BASE
-    }
-  })
-
-  test('a Viewer commit failure rolls back binary, Viewer, and metadata', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const { path, meta, execution } = await makeInstall(root, '1.0.0')
-    const release = await makeFakeRelease(root, '1.1.0')
-    process.env.ASTRALE_UPDATE_BASE = `file://${release}`
-    const beforeBinary = await readFile(meta.bin, 'utf8')
-    const beforeMetadata = await readFile(path, 'utf8')
-    try {
-      await expect(
-        updateAstrale(
-          {
-            currentVersion: '1.0.0',
-            platform: { os: 'darwin', arch: 'arm64' },
-            installPath: path,
-            execution,
-          },
-          {
-            replaceStandaloneCohort: (installed, next, viewer) =>
-              replaceStandaloneCohort(installed, next, viewer, {
-                rename: async (from, to) => {
-                  if (String(from).endsWith('viewer.next')) {
-                    throw Object.assign(new Error('injected Viewer commit failure'), {
-                      code: 'EIO',
-                    })
-                  }
-                  await rename(from, to)
-                },
-              }),
-          },
-        ),
-      ).rejects.toThrow('injected Viewer commit failure')
-
-      expect(await readFile(meta.bin, 'utf8')).toBe(beforeBinary)
-      expect(await readFile(join(dirname(meta.bin), 'viewer', 'dist', 'main.js'), 'utf8')).toBe(
-        'old viewer main\n',
-      )
-      expect(await readFile(join(dirname(meta.bin), 'viewer', 'dist', 'index.html'), 'utf8')).toBe(
-        'old viewer html\n',
-      )
-      expect(await readFile(path, 'utf8')).toBe(beforeMetadata)
-    } finally {
-      delete process.env.ASTRALE_UPDATE_BASE
-    }
-  })
-
-  test('a metadata failure after cohort commit restores binary, Viewer, and metadata', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const { path, meta, execution } = await makeInstall(root, '1.0.0')
-    const release = await makeFakeRelease(root, '1.1.0')
-    process.env.ASTRALE_UPDATE_BASE = `file://${release}`
-    const beforeBinary = await readFile(meta.bin, 'utf8')
-    const beforeMetadata = await readFile(path, 'utf8')
-    try {
-      await expect(
-        updateAstrale(
-          {
-            currentVersion: '1.0.0',
-            platform: { os: 'darwin', arch: 'arm64' },
-            installPath: path,
-            execution,
-          },
-          {
-            writeInstallMetadata: async () => {
-              throw new Error('injected metadata write failure')
-            },
-          },
-        ),
-      ).rejects.toThrow('injected metadata write failure')
-
-      expect(await readFile(meta.bin, 'utf8')).toBe(beforeBinary)
-      expect(await readFile(join(dirname(meta.bin), 'viewer', 'dist', 'main.js'), 'utf8')).toBe(
-        'old viewer main\n',
-      )
-      expect(await readFile(join(dirname(meta.bin), 'viewer', 'dist', 'index.html'), 'utf8')).toBe(
-        'old viewer html\n',
-      )
-      expect(await readFile(path, 'utf8')).toBe(beforeMetadata)
-    } finally {
-      delete process.env.ASTRALE_UPDATE_BASE
-    }
-  })
-
-  test('updates canary-style releases whose binary reports the package version', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const { path, meta, execution } = await makeInstall(root, 'main-old123')
-    const release = await makeFakeRelease(root, 'main-new456', { binaryVersion: '1.0.0' })
-    process.env.ASTRALE_UPDATE_BASE = `file://${release}`
-    try {
-      const result = await updateAstrale({
-        currentVersion: '1.0.0',
-        platform: { os: 'darwin', arch: 'arm64' },
-        installPath: path,
-        execution,
-      })
-
-      expect(result).toMatchObject({
-        status: 'updated',
-        previousVersion: 'main-old123',
-        currentVersion: 'main-new456',
-      })
-      const versionProc = Bun.spawn([meta.bin, '--version'], { stdout: 'pipe' })
-      expect(await new Response(versionProc.stdout).text()).toBe('1.0.0\n')
-      expect(await versionProc.exited).toBe(0)
-      const updatedMeta = JSON.parse(await readFile(path, 'utf8')) as InstallMetadata
-      expect(updatedMeta.version).toBe('main-new456')
-    } finally {
-      delete process.env.ASTRALE_UPDATE_BASE
-    }
-  })
-})