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

package/src/commands/__tests__/domain-list.test.ts

@@ -1,133 +0,0 @@
-import { defineSchema, schema as schemaApi } from '@astrale-os/sdk/schema'
-import { afterAll, describe, expect, test } from 'bun:test'
-
-import type { DomainInfo } from '../../lib/admin-domain'
-
-import { releaseFor } from '../../__tests__/fixtures/publication'
-import { byDefaultThenName, domainProjection, probe, type DomainRow } from '../domain/list'
-
-const strip = (s: string): string => s.replace(/\[[0-9;]*m/g, '')
-
-function entry(over: Partial<DomainInfo>): DomainInfo {
-  return {
-    id: over.origin ?? 'id',
-    origin: 'x.astrale.ai',
-    name: 'x',
-    createdAt: '',
-    updatedAt: '',
-    ...over,
-  }
-}
-
-describe('domain list — ordering', () => {
-  test('install-by-default sorts first, then alphabetical by origin', () => {
-    const rows = [
-      entry({ origin: 'zeta.astrale.ai' }),
-      entry({ origin: 'alpha.astrale.ai' }),
-      entry({ origin: 'mid.astrale.ai', installByDefault: true }),
-      entry({ origin: 'beta.astrale.ai', installByDefault: true }),
-    ]
-    rows.sort(byDefaultThenName)
-    expect(rows.map((r) => r.origin)).toEqual([
-      'beta.astrale.ai', // default group, alpha order
-      'mid.astrale.ai',
-      'alpha.astrale.ai', // non-default group, alpha order
-      'zeta.astrale.ai',
-    ])
-  })
-})
-
-describe('domain list — projection', () => {
-  test('row carries name/origin/url and a default marker; -q paths are install urls', () => {
-    const proj = domainProjection([
-      entry({
-        origin: 'crm.acme.dev',
-        name: 'crm',
-        url: 'https://crm.acme.dev',
-        installByDefault: true,
-      }),
-    ])
-    const row = proj.rows[0]
-    expect(strip(row.name)).toBe('crm')
-    expect(strip(row.origin)).toBe('crm.acme.dev')
-    expect(strip(row.url)).toBe('https://crm.acme.dev')
-    expect(strip(row.default)).toBe('default')
-    // The quiet/pipeable token is the install URL, not the origin.
-    expect(proj.paths).toEqual(['https://crm.acme.dev'])
-  })
-
-  test('an unpublished entry shows a placeholder url and falls back to origin for -q', () => {
-    const proj = domainProjection([entry({ origin: 'pending.dev', name: 'pending' })])
-    expect(strip(proj.rows[0].url)).toBe('(unpublished)')
-    expect(strip(proj.rows[0].default)).toBe('')
-    expect(proj.paths).toEqual(['pending.dev'])
-  })
-
-  test('STATUS cell is empty without --check, live/down with it', () => {
-    const base = entry({ origin: 'a.dev', url: 'https://a.dev' })
-    expect(strip(domainProjection([base]).rows[0].status)).toBe('')
-
-    const live: DomainRow = { ...base, reachable: true, checkError: null }
-    expect(strip(domainProjection([live]).rows[0].status)).toBe('● live')
-
-    const down: DomainRow = { ...base, reachable: false, checkError: 'Publication HTTP 502' }
-    expect(strip(domainProjection([down]).rows[0].status)).toBe('○ Publication HTTP 502')
-  })
-})
-
-describe('domain list — canonical Publication check', () => {
-  const servers: { stop(): void }[] = []
-  afterAll(() => {
-    for (const server of servers) server.stop()
-  })
-
-  test('reports the admitted schema revision in machine data', async () => {
-    const schema = defineSchema('catalog-check.example.dev', {})
-    const deployed = releaseFor(schema, 'https://catalog-check.example.dev').publication
-    const server = Bun.serve({
-      port: 0,
-      fetch(request) {
-        return new URL(request.url).pathname === '/.well-known/astrale/domain.json'
-          ? Response.json(deployed)
-          : new Response('not found', { status: 404 })
-      },
-    })
-    servers.push(server)
-
-    await expect(
-      probe(
-        entry({
-          origin: schema.origin,
-          url: `http://localhost:${server.port}`,
-        }),
-      ),
-    ).resolves.toMatchObject({
-      reachable: true,
-      schemaRevision: schemaApi.revision(schema),
-      checkError: null,
-    })
-  })
-
-  test('rejects a Publication whose origin differs from the catalog entry', async () => {
-    const schema = defineSchema('deployed.example.dev', {})
-    const deployed = releaseFor(schema, 'https://deployed.example.dev').publication
-    const server = Bun.serve({
-      port: 0,
-      fetch: () => Response.json(deployed),
-    })
-    servers.push(server)
-
-    await expect(
-      probe(
-        entry({
-          origin: 'catalog.example.dev',
-          url: `http://localhost:${server.port}`,
-        }),
-      ),
-    ).resolves.toMatchObject({
-      reachable: false,
-      checkError:
-        'Domain origin mismatch: deployed=deployed.example.dev expected=catalog.example.dev',
-    })
-  })
-})

package/src/commands/__tests__/domain-uninstall.test.ts

@@ -1,53 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { join } from 'node:path'
-
-import { uninstallCallInput } from '../domain/uninstall'
-
-const cliRoot = join(import.meta.dir, '../../..')
-
-describe('domain uninstall', () => {
-  test('sends the public Kernel uninstall request', () => {
-    expect(uninstallCallInput('grc.example', 'op-1')).toEqual({
-      operation: 'op-1',
-      origin: 'grc.example',
-    })
-  })
-
-  test('requires --yes outside a TTY before connecting to a Kernel', async () => {
-    const proc = Bun.spawn({
-      cmd: ['bun', join(cliRoot, 'bin/astrale.ts'), 'domain', 'uninstall', 'grc.example', '--json'],
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
-    const [stdout, stderr, exitCode] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-      proc.exited,
-    ])
-
-    expect(exitCode).toBe(1)
-    expect(stdout).toBe('')
-    expect(JSON.parse(stderr)).toMatchObject({
-      error: 'CONFIRMATION_REQUIRED',
-      message: 'Uninstalling Domain "grc.example" requires explicit confirmation.',
-    })
-  })
-
-  test('states that uninstall never deletes business data', async () => {
-    const proc = Bun.spawn({
-      cmd: ['bun', join(cliRoot, 'bin/astrale.ts'), 'domain', 'uninstall', '--help'],
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
-    const [stdout, stderr, exitCode] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-      proc.exited,
-    ])
-
-    expect(exitCode).toBe(0)
-    expect(stderr).toBe('')
-    expect(stdout).toContain('Uninstall never deletes business data.')
-    expect(stdout).toContain('business data still uses its schema')
-  })
-})

package/src/commands/__tests__/install-direct.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { directInstallCallInput } from '../domain/install'
-
-describe('directInstallCallInput', () => {
-  test('sends the current remote install syscall, not a legacy url list', () => {
-    const operation = '4a4c9a18-50f6-4d84-a7b7-2d83e3e45dc8'
-    expect(directInstallCallInput('https://tasks.example.test', operation, 'secret')).toEqual({
-      operation,
-      domains: [
-        {
-          source: {
-            kind: 'remote',
-            url: 'https://tasks.example.test',
-            token: 'secret',
-          },
-        },
-      ],
-    })
-  })
-})

package/src/commands/__tests__/install-identity-override.test.ts

@@ -1,76 +0,0 @@
-import { defineSchema } from '@astrale-os/sdk/schema'
-import { afterAll, describe, expect, test } from 'bun:test'
-
-import { releaseFor } from '../../__tests__/fixtures/publication'
-import { domainRefFromTarget, isIdentityOverride, probeDeclaredOrigin } from '../domain/install'
-
-describe('admin-path target classification', () => {
-  test('an http(s) url installs by url', () => {
-    expect(domainRefFromTarget('https://crm.acme.dev')).toEqual({ url: 'https://crm.acme.dev' })
-    expect(domainRefFromTarget('http://localhost:8787')).toEqual({ url: 'http://localhost:8787' })
-  })
-
-  test('a bare origin installs by catalog origin (the unique registry key)', () => {
-    expect(domainRefFromTarget('crm.acme.dev')).toEqual({ origin: 'crm.acme.dev' })
-    // A host:port that is not a url is still an origin, not a url.
-    expect(domainRefFromTarget('example.astrale.ai')).toEqual({ origin: 'example.astrale.ai' })
-  })
-})
-
-describe('identity-override detection', () => {
-  test('origin matching the serving host is not an override', () => {
-    expect(isIdentityOverride('crm.acme.dev', 'crm.acme.dev')).toBe(false)
-    expect(isIdentityOverride('CRM.Acme.Dev', 'crm.acme.dev')).toBe(false)
-  })
-
-  test('origin differing from the serving host is an override', () => {
-    // The spec §5 attack shape: a fork on workers.dev claiming a well-known origin.
-    expect(isIdentityOverride('shell.astrale.ai', 'crm.workers.dev')).toBe(true)
-    // The scaffold default also aliases until the placeholder origin is edited.
-    expect(isIdentityOverride('hldom.example.dev', 'hldom-example-dev.acme.workers.dev')).toBe(true)
-  })
-})
-
-describe('declared-origin Publication probe', () => {
-  const servers: { stop(): void }[] = []
-  afterAll(() => {
-    for (const s of servers) s.stop()
-  })
-
-  function servePublication(handler: (req: Request) => Response): string {
-    const server = Bun.serve({ port: 0, fetch: handler })
-    servers.push(server)
-    return `http://localhost:${server.port}`
-  }
-
-  test('reads origin from a well-formed canonical Publication', async () => {
-    const schema = defineSchema('crm.acme.dev', {})
-    const deployed = releaseFor(schema, 'https://crm.acme.dev').publication
-    const url = servePublication((req) =>
-      new URL(req.url).pathname === '/.well-known/astrale/domain.json'
-        ? Response.json(deployed)
-        : new Response('nope', { status: 404 }),
-    )
-    expect(await probeDeclaredOrigin(url)).toBe('crm.acme.dev')
-  })
-
-  test('does not accept the removed pre-Kernel-V2 domainName shape', async () => {
-    const legacy = servePublication(() =>
-      Response.json({ iss: 'https://x', domainName: 'crm.acme.dev' }),
-    )
-    expect(await probeDeclaredOrigin(legacy)).toBeUndefined()
-  })
-
-  test('degrades to undefined on invalid Publication, non-200, bad JSON, or dead host', async () => {
-    const noName = servePublication(() => Response.json({ iss: 'https://x' }))
-    expect(await probeDeclaredOrigin(noName)).toBeUndefined()
-
-    const error = servePublication(() => new Response('boom', { status: 500 }))
-    expect(await probeDeclaredOrigin(error)).toBeUndefined()
-
-    const badJson = servePublication(() => new Response('<html>', { status: 200 }))
-    expect(await probeDeclaredOrigin(badJson)).toBeUndefined()
-
-    expect(await probeDeclaredOrigin('http://127.0.0.1:1')).toBeUndefined()
-  })
-})

package/src/commands/__tests__/instance-bookmark.test.ts

@@ -1,166 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-const cliRoot = join(import.meta.dir, '../../..')
-
-let tmp: string
-
-beforeEach(async () => {
-  tmp = await mkdtemp(join(tmpdir(), 'astrale-instance-bookmark-'))
-})
-
-afterEach(async () => {
-  await rm(tmp, { recursive: true, force: true })
-})
-
-describe('instance bookmark command', () => {
-  test('normalizes managed instance public roots to /api when creating a bookmark', async () => {
-    const result = await runBookmark(
-      'testmarc',
-      '--url',
-      'https://testmarc.eu.astrale.ai',
-      '--skip-probe',
-    )
-
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toContain('Bookmarked "testmarc"')
-
-    const store = await readInstances()
-    expect(store.instances.testmarc.url).toBe('https://testmarc.eu.astrale.ai/api')
-  })
-
-  test('repairs an existing managed-root bookmark without clearing optional fields', async () => {
-    await mkdir(tmp, { recursive: true })
-    await writeFile(
-      join(tmp, 'instances.json'),
-      JSON.stringify(
-        {
-          active: 'testmarc',
-          instances: {
-            testmarc: {
-              url: 'https://testmarc.eu.astrale.ai',
-              issuer: 'https://issuer.example.com',
-              defaultIdentity: 'marc',
-              caFile: '/tmp/ca.pem',
-              createdAt: '2026-06-10T00:00:00.000Z',
-              kind: 'bookmark',
-              mode: 'remote',
-            },
-          },
-        },
-        null,
-        2,
-      ) + '\n',
-    )
-
-    const result = await runBookmark(
-      'testmarc',
-      '--url',
-      'https://testmarc.eu.astrale.ai',
-      '--skip-probe',
-    )
-
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toContain('Updated bookmark "testmarc"')
-
-    const store = await readInstances()
-    expect(store.instances.testmarc.url).toBe('https://testmarc.eu.astrale.ai/api')
-    expect(store.instances.testmarc.issuer).toBe('https://issuer.example.com')
-    expect(store.instances.testmarc.defaultIdentity).toBe('marc')
-    expect(store.instances.testmarc.caFile).toBe('/tmp/ca.pem')
-    expect(store.instances.testmarc.createdAt).toBe('2026-06-10T00:00:00.000Z')
-  })
-
-  test('warns when another bookmark uses different TLS trust for the same URL', async () => {
-    await writeFile(
-      join(tmp, 'instances.json'),
-      JSON.stringify({
-        active: 'stable',
-        instances: {
-          stable: {
-            url: 'https://local.example/kernel',
-            caFile: '/certs/stable.pem',
-          },
-        },
-      }),
-    )
-
-    const result = await runBookmark(
-      'stale',
-      '--url',
-      'https://local.example/kernel/',
-      '--ca',
-      '/certs/old.pem',
-      '--skip-probe',
-    )
-
-    expect(result.exitCode).toBe(0)
-    expect(result.stderr).toContain('TLS trust differs for the same Kernel URL')
-    expect(result.stderr).toContain('"stable" uses CA /certs/stable.pem')
-  })
-
-  test('active --json exposes the TLS and identity configuration', async () => {
-    await writeFile(
-      join(tmp, 'instances.json'),
-      JSON.stringify({
-        active: 'stable',
-        instances: {
-          stable: {
-            url: 'https://local.example/kernel',
-            issuer: 'https://issuer.example',
-            defaultIdentity: 'marc',
-            caFile: '/certs/stable.pem',
-            createdAt: '2026-08-20T00:00:00.000Z',
-          },
-        },
-      }),
-    )
-
-    const result = await runCli('instance', 'active', '--json')
-    expect(result.exitCode).toBe(0)
-    expect(JSON.parse(result.stdout)).toEqual({
-      name: 'stable',
-      url: 'https://local.example/kernel',
-      issuer: 'https://issuer.example',
-      defaultIdentity: 'marc',
-      caFile: '/certs/stable.pem',
-      createdAt: '2026-08-20T00:00:00.000Z',
-    })
-  })
-})
-
-async function readInstances(): Promise<{
-  active: string
-  instances: Record<string, Record<string, unknown>>
-}> {
-  return JSON.parse(await readFile(join(tmp, 'instances.json'), 'utf-8'))
-}
-
-async function runBookmark(...args: string[]): Promise<{
-  exitCode: number
-  stdout: string
-  stderr: string
-}> {
-  return runCli('instance', 'bookmark', ...args)
-}
-
-async function runCli(...args: string[]): Promise<{
-  exitCode: number
-  stdout: string
-  stderr: string
-}> {
-  const proc = Bun.spawn({
-    cmd: ['bun', join(cliRoot, 'bin/astrale.ts'), ...args],
-    env: { ...process.env, ASTRALE_HOME: tmp },
-    stdout: 'pipe',
-    stderr: 'pipe',
-  })
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited,
-  ])
-  return { exitCode, stdout, stderr }
-}

package/src/commands/__tests__/instance-list-admin.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { AstraleError } from '../../errors'
-import { adminInventoryUnavailable } from '../instance/list'
-
-describe('adminInventoryUnavailable', () => {
-  test('turns key-backed Admin exchange failures into a bookmark-only instruction', () => {
-    const error = adminInventoryUnavailable(
-      new AstraleError(
-        'TOKEN_EXCHANGE_SOURCE_INVALID',
-        'The source identity credential has no valid expiration.',
-      ),
-    )
-    expect(error.code).toBe('ADMIN_INVENTORY_UNAVAILABLE')
-    expect(error.message).toContain('Admin is not deployed')
-    expect(error.hint).toContain('instance list --bookmarked')
-  })
-
-  test('turns a missing Admin Domain issuer into the same instruction', () => {
-    const error = adminInventoryUnavailable(
-      new AstraleError('ADMIN_DOMAIN_ISSUER_MISSING', 'no Domain issuer'),
-    )
-    expect(error.code).toBe('ADMIN_INVENTORY_UNAVAILABLE')
-    expect(error.hint).toContain('Key-backed identities cannot mint an Admin Domain token')
-  })
-})

package/src/commands/__tests__/instance-list-rows.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import type { InstanceInfo } from '../../lib/admin-instance'
-
-import { buildInstanceRows, type Bookmark } from '../instance/list'
-
-const managed: InstanceInfo[] = [
-  { id: 'demo', slug: 'demo', url: 'https://demo.eu.astrale.ai', state: 'ready' },
-]
-
-function bookmark(overrides: Partial<Bookmark> = {}): Bookmark {
-  return {
-    name: 'demo',
-    url: 'https://demo.eu.astrale.ai/api',
-    issuer: null,
-    active: false,
-    defaultIdentity: null,
-    caFile: null,
-    createdAt: null,
-    ...overrides,
-  }
-}
-
-describe('buildInstanceRows', () => {
-  test('a bookmark of a managed instance does not produce a second row', () => {
-    const rows = buildInstanceRows(managed, [bookmark()], { managed: true, bookmarks: true })
-    expect(rows).toHaveLength(1)
-    expect(rows[0]).toMatchObject({ kind: 'managed' })
-  })
-
-  test('the active marker moves onto the merged managed row', () => {
-    const rows = buildInstanceRows(managed, [bookmark({ active: true })], {
-      managed: true,
-      bookmarks: true,
-    })
-    expect(rows).toHaveLength(1)
-    expect(rows[0]?.name).toContain('*')
-  })
-
-  test('a same-name bookmark with a different URL stays a separate row', () => {
-    const rows = buildInstanceRows(managed, [bookmark({ url: 'https://elsewhere.example.com' })], {
-      managed: true,
-      bookmarks: true,
-    })
-    expect(rows).toHaveLength(2)
-    expect(rows.map((row) => row.kind)).toEqual(['managed', 'bookmark'])
-  })
-
-  test('unrelated bookmarks are listed as before', () => {
-    const rows = buildInstanceRows(
-      managed,
-      [bookmark(), bookmark({ name: 'local', url: 'http://localhost:3001/api' })],
-      { managed: true, bookmarks: true },
-    )
-    expect(rows).toHaveLength(2)
-    expect(rows.map((row) => row.name)).toEqual(['demo', 'local'])
-  })
-
-  test('--bookmarked never merges (managed hidden)', () => {
-    const rows = buildInstanceRows(managed, [bookmark()], { managed: false, bookmarks: true })
-    expect(rows).toHaveLength(1)
-    expect(rows[0]).toMatchObject({ kind: 'bookmark' })
-  })
-})

package/src/commands/__tests__/instance-use.test.ts

@@ -1,67 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { IssuerUnreachableError } from '../../errors'
-import { InstanceStoreSchema, type ResolvedInstance } from '../../lib/instance'
-import { probeBookmark } from '../instance/use'
-
-const resolved: ResolvedInstance = {
-  name: 'stable',
-  kind: 'bookmark',
-  url: 'https://local.example/kernel',
-  issuer: 'https://issuer.example',
-  caFile: '/certs/stable.pem',
-}
-
-describe('instance use bookmark probe', () => {
-  test('uses the CA stored on the selected bookmark', async () => {
-    const scopedFetch = globalThis.fetch
-
-    await expect(
-      probeBookmark(resolved, {
-        readInstances: async () =>
-          InstanceStoreSchema.parse({
-            active: 'stable',
-            instances: {
-              stable: { url: resolved.url, caFile: resolved.caFile },
-            },
-          }),
-        fetchWithCaFile: (path) => {
-          expect(path).toBe('/certs/stable.pem')
-          return scopedFetch
-        },
-        checkIssuerReachability: async (url, issuer, fetchImpl) => {
-          expect(url).toBe(resolved.url)
-          expect(issuer).toBe(resolved.issuer)
-          expect(fetchImpl).toBe(scopedFetch)
-          return { issuer: resolved.issuer!, keys: [{ kid: 'key-1' }] }
-        },
-      }),
-    ).resolves.toBeUndefined()
-  })
-
-  test('names conflicting bookmark CAs in a failed TLS probe', async () => {
-    const failure = probeBookmark(resolved, {
-      readInstances: async () =>
-        InstanceStoreSchema.parse({
-          active: 'stable',
-          instances: {
-            stable: { url: resolved.url, caFile: resolved.caFile },
-            stale: { url: resolved.url, caFile: '/certs/old.pem' },
-          },
-        }),
-      fetchWithCaFile: () => fetch,
-      checkIssuerReachability: async () => {
-        throw new IssuerUnreachableError(resolved.url, 'certificate verify failed')
-      },
-    })
-
-    await expect(failure).rejects.toMatchObject({
-      code: 'ISSUER_UNREACHABLE',
-      message: `Issuer/JWKS probe failed for bookmark "stable" at ${resolved.url}.`,
-    })
-    await expect(failure).rejects.toHaveProperty(
-      'hint',
-      expect.stringContaining('"stale" (CA /certs/old.pem)'),
-    )
-  })
-})

package/src/commands/__tests__/introspect-parse.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { parseIntrospectTarget } from '../introspect'
-
-describe('parseIntrospectTarget', () => {
-  test('accepts a bare origin', () => {
-    const parsed = parseIntrospectTarget('host.astrale.ai')
-    expect(parsed.origin).toBe('host.astrale.ai')
-    expect(parsed.path.ast.steps).toEqual([])
-  })
-
-  test('accepts a Domain-rooted method Path', () => {
-    const parsed = parseIntrospectTarget('/:host.astrale.ai:class.Manager:createInstance')
-    expect(parsed.origin).toBe('host.astrale.ai')
-    expect(parsed.path.ast.steps.at(-1)?.kind).toBe('method')
-  })
-
-  test('rejects an @id', () => {
-    expect(() => parseIntrospectTarget('@abc')).toThrow('not an @id')
-  })
-})