@astrale-os/cli 1.0.0-beta.8 → 1.0.0-npm-deprecated.0

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

@@ -1,351 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { chmod, mkdir, mkdtemp, readFile, symlink, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import {
-  admitScriptInstall,
-  classifyUpdateExecution,
-  DEFAULT_UPDATE_CHANNEL,
-  InstallMetadataSchema,
-  readInstallMetadata,
-  releaseBase,
-  shouldUpdate,
-  updateAstrale,
-  writeInstallMetadata,
-  type InstallMetadata,
-  type UpdateExecution,
-} from '../update'
-
-async function makeFakeRelease(
-  root: string,
-  version: string,
-  options: { binaryVersion?: string; legacyManifest?: 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)
-
-  const asset = join(release, 'astrale-darwin-arm64.tar.gz')
-  const tar = Bun.spawn(['tar', '-C', payload, '-czf', asset, 'astrale'])
-  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)
-  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('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')
-    } 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
-    }
-  })
-})

package/src/lib/__tests__/use-target.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import type { IdentityStore } from '../../identity/index'
-import type { InstanceStore } from '../instance'
-
-import { resolveUseTarget } from '../use-target'
-
-const instances: InstanceStore = {
-  active: 'staging',
-  instances: {
-    staging: { url: 'https://staging.example.com', slug: 'stage' },
-    prod: { url: 'https://prod.example.com' },
-  },
-}
-
-const identities: IdentityStore = {
-  default: 'alice',
-  identities: {
-    alice: { subject: 'alice', createdAt: '2026-01-01T00:00:00.000Z', source: 'key' },
-    prod: { subject: 'prod-user', createdAt: '2026-01-01T00:00:00.000Z', source: 'key' },
-  },
-}
-
-describe('resolveUseTarget', () => {
-  test('resolves identity-only names', () => {
-    expect(resolveUseTarget('alice', instances, identities)).toEqual({
-      kind: 'identity',
-      name: 'alice',
-    })
-  })
-
-  test('resolves instance keys and slugs', () => {
-    expect(resolveUseTarget('staging', instances, identities)).toEqual({
-      kind: 'instance',
-      name: 'staging',
-    })
-    expect(resolveUseTarget('stage', instances, identities)).toEqual({
-      kind: 'instance',
-      name: 'staging',
-    })
-  })
-
-  test('refuses ambiguous names', () => {
-    expect(resolveUseTarget('prod', instances, identities)).toEqual({
-      kind: 'ambiguous',
-      name: 'prod',
-    })
-  })
-
-  test('reports missing names', () => {
-    expect(resolveUseTarget('missing', instances, identities)).toEqual({
-      kind: 'missing',
-      name: 'missing',
-    })
-  })
-})

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

@@ -1,34 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { validateName } from '../validation'
-
-describe('validateName', () => {
-  test('accepts valid names', () => {
-    expect(() => validateName('manager', 'Instance')).not.toThrow()
-    expect(() => validateName('my-instance', 'Instance')).not.toThrow()
-    expect(() => validateName('my_instance', 'Instance')).not.toThrow()
-    expect(() => validateName('my.instance', 'Instance')).not.toThrow()
-    expect(() => validateName('Instance123', 'Instance')).not.toThrow()
-    expect(() => validateName('a', 'Identity')).not.toThrow()
-  })
-
-  test('rejects empty string', () => {
-    expect(() => validateName('', 'Instance')).toThrow(/Invalid instance name/)
-  })
-
-  test('rejects whitespace', () => {
-    expect(() => validateName(' ', 'Instance')).toThrow(/Invalid instance name/)
-    expect(() => validateName('my instance', 'Instance')).toThrow(/Invalid instance name/)
-  })
-
-  test('rejects special characters', () => {
-    expect(() => validateName('my/instance', 'Instance')).toThrow(/Invalid instance name/)
-    expect(() => validateName('my@instance', 'Identity')).toThrow(/Invalid identity name/)
-    expect(() => validateName('name!', 'Instance')).toThrow()
-  })
-
-  test('includes entity type in error message', () => {
-    expect(() => validateName('', 'Instance')).toThrow('instance')
-    expect(() => validateName('', 'Identity')).toThrow('identity')
-  })
-})

package/src/lib/__tests__/view-assets.test.ts

@@ -1,146 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test'
-import {
-  mkdtemp,
-  mkdir,
-  readFile,
-  realpath,
-  rm,
-  symlink,
-  utimes,
-  writeFile,
-} from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { dirname, join, relative } from 'node:path'
-import { pathToFileURL } from 'node:url'
-
-import { ensureViewerAssets, viewerDistDir } from '../view/assets'
-
-const temporaryDirectories: string[] = []
-
-afterEach(async () => {
-  await Promise.all(
-    temporaryDirectories
-      .splice(0)
-      .map((directory) => rm(directory, { recursive: true, force: true })),
-  )
-})
-
-describe('viewer asset resolution', () => {
-  test('skips partial candidates and prefers complete package-owned assets', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-view-candidates-'))
-    temporaryDirectories.push(root)
-    const prefix = join(root, '.npm-global')
-    const packageRoot = join(prefix, 'lib', 'node_modules', '@astrale-os', 'cli')
-    const entry = join(prefix, 'bin', 'astrale')
-    const bundle = join(packageRoot, 'dist', 'astrale.js')
-    const published = join(packageRoot, 'viewer', 'dist')
-    const legacy = join(prefix, 'viewer', 'dist')
-
-    await mkdir(dirname(bundle), { recursive: true })
-    await mkdir(published, { recursive: true })
-    await mkdir(legacy, { recursive: true })
-    await writeFile(bundle, '')
-    await writeFile(join(published, 'main.js'), '')
-    await writeFile(join(legacy, 'main.js'), '')
-    await writeFile(join(legacy, 'index.html'), '')
-
-    expect(viewerDistDir(pathToFileURL(bundle).href, entry)).toBe(legacy)
-
-    await writeFile(join(published, 'index.html'), '')
-    expect(viewerDistDir(pathToFileURL(bundle).href, entry)).toBe(published)
-  })
-
-  test('builds missing viewer assets in a clean source checkout', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-view-source-'))
-    temporaryDirectories.push(root)
-    const module = join(root, 'src', 'lib', 'view', 'assets.ts')
-    const source = join(root, 'viewer')
-    const dist = join(source, 'dist')
-
-    await mkdir(dirname(module), { recursive: true })
-    await mkdir(source, { recursive: true })
-    await writeFile(module, '')
-    await writeFile(join(source, 'main.ts'), 'document.body.textContent = "viewer ready"\n')
-    await writeFile(join(source, 'index.html'), '<!doctype html><body></body>\n')
-
-    expect(await ensureViewerAssets(pathToFileURL(module).href, join(root, 'bin', 'astrale'))).toBe(
-      dist,
-    )
-    expect(await readFile(join(dist, 'index.html'), 'utf8')).toContain('<body>')
-    expect(await readFile(join(dist, 'main.js'), 'utf8')).toContain('viewer ready')
-  })
-
-  test('rebuilds stale viewer assets in a source checkout', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-view-stale-'))
-    temporaryDirectories.push(root)
-    const module = join(root, 'src', 'lib', 'view', 'assets.ts')
-    const source = join(root, 'viewer')
-    const dist = join(source, 'dist')
-
-    await mkdir(dirname(module), { recursive: true })
-    await mkdir(dist, { recursive: true })
-    await writeFile(module, '')
-    await writeFile(join(source, 'main.ts'), 'document.body.textContent = "fresh viewer"\n')
-    await writeFile(join(source, 'index.html'), '<!doctype html><body>fresh</body>\n')
-    await writeFile(join(dist, 'main.js'), 'document.body.textContent = "stale viewer"\n')
-    await writeFile(join(dist, 'index.html'), '<!doctype html><body>stale</body>\n')
-    const future = new Date(Date.now() + 2_000)
-    await utimes(join(source, 'main.ts'), future, future)
-
-    await ensureViewerAssets(pathToFileURL(module).href, join(root, 'bin', 'astrale'))
-
-    expect(await readFile(join(dist, 'main.js'), 'utf8')).toContain('fresh viewer')
-    expect(await readFile(join(dist, 'index.html'), 'utf8')).toContain('fresh')
-  })
-
-  test('uses the bundled module location when invoked through a global bin symlink', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-view-bundle-'))
-    temporaryDirectories.push(root)
-    const prefix = join(root, '.npm-global')
-    const packageRoot = join(prefix, 'lib', 'node_modules', '@astrale-os', 'cli')
-    const entry = join(prefix, 'bin', 'astrale')
-    const sourceEntry = join(root, 'entry.ts')
-    const viewer = join(packageRoot, 'viewer', 'dist')
-    const assetsPath = join(import.meta.dirname, '..', 'view', 'assets.ts')
-    const relativeAssetsPath = relative(
-      await realpath(dirname(sourceEntry)),
-      await realpath(assetsPath),
-    )
-    const assetsModule = relativeAssetsPath.startsWith('.')
-      ? relativeAssetsPath
-      : `./${relativeAssetsPath}`
-
-    await mkdir(join(prefix, 'bin'), { recursive: true })
-    await mkdir(viewer, { recursive: true })
-    await writeFile(join(viewer, 'main.js'), '')
-    await writeFile(join(viewer, 'index.html'), '')
-    await writeFile(
-      sourceEntry,
-      `import { viewerDistDir } from ${JSON.stringify(assetsModule)}\nconsole.log(viewerDistDir())\n`,
-    )
-    const build = await Bun.build({
-      entrypoints: [sourceEntry],
-      outdir: join(packageRoot, 'dist'),
-      target: 'node',
-      format: 'esm',
-    })
-    expect(build.success).toBe(true)
-    await symlink(
-      join('..', 'lib', 'node_modules', '@astrale-os', 'cli', 'dist', 'entry.js'),
-      entry,
-    )
-
-    const node = Bun.which('node')
-    expect(node).not.toBeNull()
-    const process = Bun.spawn([node!, entry], { stdout: 'pipe', stderr: 'pipe' })
-    const [stdout, stderr, exitCode] = await Promise.all([
-      new Response(process.stdout).text(),
-      new Response(process.stderr).text(),
-      process.exited,
-    ])
-
-    expect(exitCode).toBe(0)
-    expect(stderr).toBe('')
-    expect(stdout.trim()).toBe(await realpath(viewer))
-  })
-})