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

package/src/commands/__tests__/read-commands.test.ts

@@ -1,377 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
-
-type GraphContext = {
-  graph: {
-    query: typeof queryMock
-    getOrThrow: typeof getOrThrowMock
-    mutate: typeof mutateMock
-  }
-  session: {
-    schema: {
-      inspect: typeof inspectMock
-      bundle: typeof bundleMock
-    }
-  }
-}
-
-type RunOpts = {
-  opts: Record<string, unknown>
-  fn: (context: GraphContext) => Promise<unknown>
-  format?: (
-    result: unknown,
-    opts: Record<string, unknown>,
-    machine: boolean,
-  ) => void | Promise<void>
-}
-
-class ExitError extends Error {
-  constructor(readonly code: string | number | null | undefined) {
-    super(`process.exit(${String(code)})`)
-  }
-}
-
-let stdout = ''
-let errors: string[] = []
-let originalStdoutWrite: typeof process.stdout.write
-let originalStderrWrite: typeof process.stderr.write
-let originalConsoleError: typeof console.error
-let originalExit: typeof process.exit
-let queryCalls: Array<{ ast: unknown; options: unknown }> = []
-let getTargets: string[] = []
-let mutations: unknown[] = []
-let queryResult: unknown
-let getResult: unknown
-let mutationResult: unknown
-let inspectResult: unknown
-let bundleResult: unknown
-let selfFailure: unknown
-let selfContexts: unknown[] = []
-
-const queryMock = mock(async (ast: unknown, options?: unknown) => {
-  queryCalls.push({ ast, options })
-  return queryResult
-})
-const getOrThrowMock = mock(async (target: { readonly raw?: string; toString(): string }) => {
-  getTargets.push(target.raw ?? target.toString())
-  return getResult
-})
-const mutateMock = mock(async (mutation: unknown) => {
-  mutations.push(mutation)
-  return mutationResult
-})
-const inspectMock = mock(async (_origin: string) => inspectResult)
-const bundleMock = mock(async (_origin: string) => bundleResult)
-const expandSelfInPathMock = mock(async (path: string, context: unknown) => {
-  selfContexts.push(context)
-  if (selfFailure !== undefined) throw selfFailure
-  if (path === '@self') {
-    return {
-      path: '@expanded-self',
-      meta: { original: '@self', expanded: '@expanded-self', selfId: 'expanded-self' },
-    }
-  }
-  return { path, meta: undefined }
-})
-const withSelfHintMock = mock(async (action: () => Promise<unknown>) => action())
-const commandContext = {
-  graph: { query: queryMock, getOrThrow: getOrThrowMock, mutate: mutateMock },
-  session: { schema: { inspect: inspectMock, bundle: bundleMock } },
-}
-const runKernelCommandMock = mock(async (run: RunOpts) => {
-  const result = await run.fn(commandContext)
-  await run.format?.(result, run.opts, true)
-})
-
-mock.module('../../connection', () => ({
-  expandSelfInPath: expandSelfInPathMock,
-  runKernelCommand: runKernelCommandMock,
-  withSelfHint: withSelfHintMock,
-}))
-
-beforeEach(() => {
-  stdout = ''
-  errors = []
-  queryCalls = []
-  getTargets = []
-  mutations = []
-  queryResult = {
-    result: {
-      kind: 'graph',
-      graph: { nodes: [], edges: [] },
-      selection: { kind: 'node', ids: [] },
-    },
-    page: {},
-  }
-  getResult = undefined
-  mutationResult = { createdNodes: {} }
-  inspectResult = {
-    origin: 'notes.example.dev',
-    revision: 'notes-v1',
-    generation: 'sha256:generation',
-  }
-  bundleResult = {
-    domain: inspectResult,
-    bundle: { origin: 'notes.example.dev', revision: 'notes-v1' },
-  }
-  selfFailure = undefined
-  selfContexts = []
-  queryMock.mockClear()
-  getOrThrowMock.mockClear()
-  mutateMock.mockClear()
-  inspectMock.mockClear()
-  bundleMock.mockClear()
-  expandSelfInPathMock.mockClear()
-  withSelfHintMock.mockClear()
-  runKernelCommandMock.mockClear()
-
-  originalStdoutWrite = process.stdout.write
-  originalStderrWrite = process.stderr.write
-  originalConsoleError = console.error
-  originalExit = process.exit
-  process.stdout.write = ((chunk: string | Uint8Array) => {
-    stdout += typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8')
-    return true
-  }) as typeof process.stdout.write
-  process.stderr.write = ((chunk: string | Uint8Array) => {
-    errors.push(typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8'))
-    return true
-  }) as typeof process.stderr.write
-  console.error = ((...values: unknown[]) => {
-    errors.push(values.map(String).join(' '))
-  }) as typeof console.error
-  process.exit = ((code?: string | number | null) => {
-    throw new ExitError(code)
-  }) as typeof process.exit
-})
-
-afterEach(() => {
-  process.stdout.write = originalStdoutWrite
-  process.stderr.write = originalStderrWrite
-  console.error = originalConsoleError
-  process.exit = originalExit
-})
-
-describe('query command', () => {
-  /** @evidence TEST-CLI-QUERY-DISPATCHES-CANONICAL-V6 */
-  test('dispatches the supported source/edge subset as Query V6 with its cursor', async () => {
-    const { queryCommand } = await import('../query')
-
-    await queryCommand(['/:notes.example.dev:class.Note'], {
-      json: true,
-      edge: '/:notes.example.dev:class.references',
-      direction: 'incoming',
-      limit: '25',
-      cursor: 'next-page',
-    })
-
-    expect(JSON.parse(JSON.stringify(queryCalls))).toEqual([
-      {
-        ast: {
-          format: 'astrale.graph.query',
-          version: 'v6',
-          source: {
-            kind: 'node',
-            terms: [{ kind: 'path', path: '/:notes.example.dev:class.Note' }],
-            binding: 'n0',
-          },
-          steps: [
-            {
-              op: 'expand',
-              from: 'n0',
-              via: [{ origin: 'notes.example.dev', kind: 'class', name: 'references' }],
-              direction: 'incoming',
-              bindings: { edge: 'e0', node: 'n1' },
-            },
-          ],
-          select: { kind: 'graph', binding: 'n1' },
-        },
-        options: { page: { size: 25, after: 'next-page' } },
-      },
-    ])
-  })
-
-  test('authors a Class source through the same canonical Query V6 call', async () => {
-    const { queryCommand } = await import('../query')
-
-    await queryCommand([], {
-      json: true,
-      class: '/:issues.astrale.ai:class.Issue',
-      limit: '20',
-    })
-
-    expect(JSON.parse(JSON.stringify(queryCalls))).toEqual([
-      {
-        ast: {
-          format: 'astrale.graph.query',
-          version: 'v6',
-          source: {
-            kind: 'node',
-            terms: [
-              {
-                kind: 'class',
-                class: { origin: 'issues.astrale.ai', kind: 'class', name: 'Issue' },
-              },
-            ],
-            binding: 'n0',
-          },
-          steps: [],
-          select: { kind: 'graph', binding: 'n0' },
-        },
-        options: { page: { size: 20 } },
-      },
-    ])
-  })
-
-  test('retains the opaque continuation in machine output without wrapping the graph result', async () => {
-    const { queryCommand } = await import('../query')
-    const result = {
-      kind: 'graph' as const,
-      graph: {
-        nodes: [{ id: 'issue-1', class: 'issues.astrale.ai:class.Issue', props: {} }],
-        edges: [],
-      },
-      selection: { kind: 'node' as const, ids: ['issue-1'] },
-    }
-    queryResult = {
-      result,
-      page: { next: 'opaque-next-page' },
-    }
-
-    await queryCommand([], {
-      json: true,
-      class: '/:issues.astrale.ai:class.Issue',
-      limit: '1',
-    })
-
-    expect(JSON.parse(stdout)).toEqual({
-      ...result,
-      page: { next: 'opaque-next-page' },
-    })
-  })
-
-  test('resolves @self inside the command session and never relabels transport failure as input', async () => {
-    const { queryCommand } = await import('../query')
-    await queryCommand(['@self'], { json: true, limit: '2' })
-    expect(selfContexts).toEqual([commandContext])
-
-    const aggregate = new AggregateError([], '')
-    selfFailure = aggregate
-    await expect(queryCommand(['@self'], { json: true, limit: '2' })).rejects.toBe(aggregate)
-    expect(errors.join('\n')).not.toContain('INVALID_INPUT')
-  })
-
-  /** @evidence TEST-CLI-QUERY-REJECTS-V1-BEFORE-CONNECTION */
-  test('rejects a legacy AST before opening the command connection', async () => {
-    const { queryCommand } = await import('../query')
-
-    await expect(
-      queryCommand([], { json: true, ast: '{"version":1,"from":["/"]}' }),
-    ).rejects.toEqual(new ExitError(1))
-
-    expect(runKernelCommandMock).not.toHaveBeenCalled()
-    expect(JSON.parse(errors.join('\n'))).toMatchObject({
-      error: 'INVALID_INPUT',
-      message: 'Invalid input: expected "astrale.graph.query" at /format.',
-    })
-  })
-})
-
-describe('get command', () => {
-  /** @evidence TEST-CLI-GET-RETURNS-CANONICAL-NODE */
-  test('point-reads the target and does not synthesize Path or backend fields', async () => {
-    const { getCommand } = await import('../get')
-    getResult = {
-      id: 'note-1',
-      class: 'notes.example.dev:class.Note',
-      props: { 'notes.example.dev:class.Note.property.title': 'Hello' },
-    }
-
-    await getCommand('/:notes.example.dev:class.Note', { json: true })
-
-    expect(getTargets).toEqual(['/:notes.example.dev:class.Note'])
-    expect(JSON.parse(stdout)).toEqual(getResult)
-    expect(stdout).not.toContain('__labels')
-    expect(stdout).not.toContain('classId')
-  })
-
-  test('resolves @self through the same point-read command context', async () => {
-    const { getCommand } = await import('../get')
-    await getCommand('@self', { json: true })
-    expect(selfContexts).toEqual([commandContext])
-    expect(getTargets).toEqual(['@expanded-self'])
-  })
-})
-
-describe('introspect command', () => {
-  test('uses the split SDK Schema API without recreating the retired introspection request', async () => {
-    const { introspectCommand } = await import('../introspect')
-
-    await introspectCommand(
-      'notes.example.dev',
-      { json: true },
-      {
-        runKernelCommand: runKernelCommandMock as never,
-      },
-    )
-
-    expect(inspectMock).toHaveBeenCalledWith('notes.example.dev')
-    expect(bundleMock).not.toHaveBeenCalled()
-    expect(JSON.parse(stdout)).toEqual(inspectResult)
-  })
-
-  test('requests the immutable bundle only when explicitly selected', async () => {
-    const { introspectCommand } = await import('../introspect')
-
-    await introspectCommand(
-      'notes.example.dev',
-      { json: true, bundle: true },
-      {
-        runKernelCommand: runKernelCommandMock as never,
-      },
-    )
-
-    expect(bundleMock).toHaveBeenCalledWith('notes.example.dev')
-    expect(inspectMock).not.toHaveBeenCalled()
-    expect(JSON.parse(stdout)).toEqual(bundleResult)
-  })
-})
-
-describe('mutate command', () => {
-  /** @evidence TEST-CLI-MUTATE-DISPATCHES-CANONICAL-V3 */
-  test('admits authoring input and dispatches one canonical Mutation V3 document', async () => {
-    const { mutateCommand } = await import('../mutate')
-    mutationResult = { createdNodes: { note: 'note-1' } }
-
-    await mutateCommand({
-      json: true,
-      data: JSON.stringify({
-        preconditions: [],
-        operations: [
-          {
-            op: 'node.create',
-            as: 'note',
-            class: 'notes.example.dev:class.Note',
-            props: {},
-          },
-        ],
-      }),
-    })
-
-    expect(JSON.parse(JSON.stringify(mutations))).toEqual([
-      {
-        format: 'astrale.graph.mutation',
-        version: 'v3',
-        preconditions: [],
-        operations: [
-          {
-            op: 'node.create',
-            as: 'note',
-            class: 'notes.example.dev:class.Note',
-            props: {},
-          },
-        ],
-      },
-    ])
-    expect(JSON.parse(stdout)).toEqual({ createdNodes: { note: 'note-1' } })
-  })
-})

package/src/commands/__tests__/setup-plan.test.ts

@@ -1,61 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-const cliRoot = join(import.meta.dir, '../../..')
-
-// `astrale setup --plan --json` is the agent-facing contract: a read-only gap
-// report where every unsatisfied step carries the command to fix it. These pin
-// that shape on a FRESH home (nothing configured) so it stays machine-parseable.
-
-let tmp: string
-
-beforeEach(async () => {
-  tmp = await mkdtemp(join(tmpdir(), 'astrale-setup-plan-'))
-})
-
-afterEach(async () => {
-  await rm(tmp, { recursive: true, force: true })
-})
-
-type PlanStep = { id: string; group: string; state: string; summary: string; fix?: string }
-type Plan = { connected: boolean; steps: PlanStep[] }
-
-async function runSetupPlan(...args: string[]): Promise<{ exitCode: number; plan: Plan }> {
-  const proc = Bun.spawn({
-    cmd: ['bun', join(cliRoot, 'bin/astrale.ts'), 'setup', '--plan', '--json', ...args],
-    env: { ...process.env, ASTRALE_HOME: tmp },
-    stdout: 'pipe',
-    stderr: 'pipe',
-  })
-  const [stdout, exitCode] = await Promise.all([new Response(proc.stdout).text(), proc.exited])
-  return { exitCode, plan: JSON.parse(stdout) as Plan }
-}
-
-describe('astrale setup --plan', () => {
-  test('reports a fresh home as not connected, with a fix per connect gap', async () => {
-    const { exitCode, plan } = await runSetupPlan()
-    expect(exitCode).toBe(0)
-    expect(plan.connected).toBe(false)
-
-    const byId = Object.fromEntries(plan.steps.map((s) => [s.id, s]))
-
-    // Not signed in, with the granular command an agent would run.
-    expect(byId.auth.state).toBe('gap')
-    expect(byId.auth.fix).toBe('astrale auth login')
-
-    // The admin control plane always has a baked default → satisfied.
-    expect(byId.admin.state).toBe('satisfied')
-
-    // No active instance yet.
-    expect(byId.instance.state).toBe('gap')
-    expect(byId.instance.fix).toContain('astrale instance create')
-  })
-
-  test('threads the positional slug into the instance fix hint', async () => {
-    const { plan } = await runSetupPlan('my-app')
-    const instance = plan.steps.find((s) => s.id === 'instance')
-    expect(instance?.fix).toBe('astrale instance create my-app')
-  })
-})

package/src/commands/__tests__/studio-descriptor.test.ts

@@ -1,22 +0,0 @@
-import { expect, test } from 'bun:test'
-import { realpathSync } from 'node:fs'
-
-import { encodeStudioCliDescriptor } from '../studio'
-
-test('Studio descriptor preserves the exact runtime and script entrypoint', () => {
-  expect(JSON.parse(encodeStudioCliDescriptor(process.execPath, import.meta.path))).toEqual({
-    version: 1,
-    executable: process.execPath,
-    args: [realpathSync(import.meta.path)],
-  })
-})
-
-test('Studio descriptor reinvokes a compiled executable without its virtual bunfs entry', () => {
-  expect(JSON.parse(encodeStudioCliDescriptor('/opt/bin/astrale', '/$bunfs/root/astrale'))).toEqual(
-    {
-      version: 1,
-      executable: '/opt/bin/astrale',
-      args: [],
-    },
-  )
-})

package/src/commands/__tests__/token-ttl.test.ts

@@ -1,66 +0,0 @@
-import type { AuthApi, Identity, IssuerId, MintedCredential } from '@astrale-os/sdk/auth'
-
-import { describe, expect, mock, test } from 'bun:test'
-
-import { AstraleError } from '../../errors'
-import { issueToken, parseTtl } from '../token'
-
-describe('parseTtl', () => {
-  test('defaults below the five-minute local source-credential lifetime', () => {
-    expect(parseTtl(undefined)).toBe(240)
-  })
-
-  test('rejects non-positive and non-integer values', () => {
-    expect(() => parseTtl('abc')).toThrow(AstraleError)
-    expect(() => parseTtl('0')).toThrow(AstraleError)
-    expect(() => parseTtl('-5')).toThrow(AstraleError)
-    expect(() => parseTtl('1.5')).toThrow(AstraleError)
-  })
-
-  test('admits a positive integer', () => {
-    expect(parseTtl('90')).toBe(90)
-  })
-})
-
-describe('issueToken', () => {
-  const kernel = 'https://kernel.test' as IssuerId
-  const identity = {
-    id: 'caller' as Identity['id'],
-    issuer: 'https://issuer.test' as Identity['issuer'],
-    subject: 'caller' as Identity['subject'],
-    frozen: false,
-    requiredClaims: [],
-  } satisfies Identity
-
-  test('mints a reusable top-level credential for the Kernel audience', async () => {
-    const mint = mock(async () => 'kernel-token' as MintedCredential)
-    const delegate = mock(async () => 'delegated-token' as MintedCredential)
-    const whoami = mock(async () => identity)
-    const auth = { mint, delegate, whoami } satisfies Pick<AuthApi, 'delegate' | 'mint' | 'whoami'>
-
-    await expect(issueToken(auth, kernel, kernel, 90)).resolves.toBe(
-      'kernel-token' as MintedCredential,
-    )
-    expect(mint).toHaveBeenCalledWith({ ttlSeconds: 90 })
-    expect(whoami).not.toHaveBeenCalled()
-    expect(delegate).not.toHaveBeenCalled()
-  })
-
-  test('delegates the selected identity only for an external audience', async () => {
-    const mint = mock(async () => 'kernel-token' as MintedCredential)
-    const delegate = mock(async () => 'delegated-token' as MintedCredential)
-    const whoami = mock(async () => identity)
-    const auth = { mint, delegate, whoami } satisfies Pick<AuthApi, 'delegate' | 'mint' | 'whoami'>
-
-    await expect(issueToken(auth, kernel, 'https://service.test' as IssuerId, 120)).resolves.toBe(
-      'delegated-token' as MintedCredential,
-    )
-    expect(mint).not.toHaveBeenCalled()
-    expect(whoami).toHaveBeenCalledTimes(1)
-    expect(delegate).toHaveBeenCalledWith(identity.id, {
-      audience: 'https://service.test',
-      ttlSeconds: 120,
-      attenuation: { kind: 'identity', self: true },
-    })
-  })
-})

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

@@ -1,95 +0,0 @@
-import { describe, expect, mock, test } from 'bun:test'
-
-import { cliStale, fetchNpmTargetVersion } from '../update'
-
-describe('CLI update staleness', () => {
-  test('trusts the release manifest for a script install without consulting npm latest', async () => {
-    const fetchPackageVersion = mock(async () => '0.8.1-alpha.7')
-    const result = await cliStale(
-      {},
-      {
-        update: async ({ channel }) => {
-          expect(channel).toBe('beta')
-          return {
-            status: 'up-to-date',
-            currentVersion: '1.0.0-beta.0',
-            latestVersion: '1.0.0-beta.0',
-            channel: 'beta',
-          }
-        },
-        fetchPackageVersion,
-      },
-    )
-
-    expect(result).toEqual({
-      stale: false,
-      managed: false,
-      current: '1.0.0-beta.0',
-      latest: '1.0.0-beta.0',
-      channel: 'beta',
-    })
-    expect(fetchPackageVersion).not.toHaveBeenCalled()
-  })
-
-  test('uses an explicit npm dist-tag only for package-managed installs', async () => {
-    const result = await cliStale(
-      { channel: 'canary' },
-      {
-        update: async () => ({
-          status: 'managed',
-          currentVersion: '1.0.0-beta.0',
-          executable: '/opt/homebrew/bin/node',
-        }),
-        fetchPackageVersion: async ({ channel }) => {
-          expect(channel).toBe('canary')
-          return '1.0.0-canary.0'
-        },
-      },
-    )
-
-    expect(result).toMatchObject({
-      managed: true,
-      latest: '1.0.0-canary.0',
-      channel: 'npm',
-    })
-  })
-
-  test('does not misclassify a script update failure as package-managed', async () => {
-    const fetchPackageVersion = mock(async () => '9.9.9')
-    const result = await cliStale(
-      {},
-      {
-        update: async () => {
-          throw new Error('release endpoint unavailable')
-        },
-        fetchPackageVersion,
-      },
-    )
-
-    expect(result).toMatchObject({
-      stale: false,
-      managed: false,
-      error: 'release endpoint unavailable',
-    })
-    expect(fetchPackageVersion).not.toHaveBeenCalled()
-  })
-
-  test('maps the default to beta and the stable channel to npm latest', async () => {
-    const originalFetch = globalThis.fetch
-    const fetchMock = mock(async (input: RequestInfo | URL) => {
-      const target = String(input).split('/').at(-1)
-      return Response.json({ version: target === 'beta' ? '1.0.0-beta.0' : '1.0.0' })
-    })
-    globalThis.fetch = fetchMock as unknown as typeof fetch
-    try {
-      expect(await fetchNpmTargetVersion({})).toBe('1.0.0-beta.0')
-      expect(await fetchNpmTargetVersion({ channel: 'stable' })).toBe('1.0.0')
-      expect(fetchMock.mock.calls.map(([input]) => String(input))).toEqual([
-        'https://registry.npmjs.org/@astrale-os/cli/beta',
-        'https://registry.npmjs.org/@astrale-os/cli/latest',
-      ])
-    } finally {
-      globalThis.fetch = originalFetch
-    }
-  })
-})

package/src/commands/__tests__/view-build.test.ts

@@ -1,58 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test'
-import { mkdir, mkdtemp, rm, utimes, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { devDistIsStale } from '../view'
-
-const temporaryDirectories: string[] = []
-
-afterEach(async () => {
-  await Promise.all(
-    temporaryDirectories.splice(0).map((path) => rm(path, { recursive: true, force: true })),
-  )
-})
-
-describe('view development runtime build', () => {
-  test('reuses a current official build and detects every runtime build input', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-view-build-'))
-    temporaryDirectories.push(root)
-    const entry = join(root, 'bin', 'astrale.ts')
-    const source = join(root, 'src', 'command.ts')
-    const vendor = join(root, 'vendor', 'dependency.tgz')
-    const buildScript = join(root, 'scripts', 'build.ts')
-    const packageJson = join(root, 'package.json')
-    const lockfile = join(root, 'pnpm-lock.yaml')
-    const dist = join(root, 'dist', 'astrale.js')
-
-    await Promise.all(
-      ['bin', 'src', 'vendor', 'scripts', 'dist'].map((directory) =>
-        mkdir(join(root, directory), { recursive: true }),
-      ),
-    )
-    const inputs = [entry, source, vendor, buildScript, packageJson, lockfile]
-    await Promise.all(inputs.map((file) => writeFile(file, 'input')))
-    await writeFile(dist, 'built')
-    const past = new Date(Date.now() - 2_000)
-    const present = new Date()
-    await Promise.all(inputs.map((file) => utimes(file, past, past)))
-    await utimes(dist, present, present)
-
-    expect(await devDistIsStale(entry, dist)).toBe(false)
-
-    for (const input of inputs) {
-      await utimes(input, new Date(Date.now() + 2_000), new Date(Date.now() + 2_000))
-      expect(await devDistIsStale(entry, dist)).toBe(true)
-      await utimes(input, past, past)
-    }
-  })
-
-  test('requires a build when dist/astrale.js is missing', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-view-build-missing-'))
-    temporaryDirectories.push(root)
-
-    expect(
-      await devDistIsStale(join(root, 'bin', 'astrale.ts'), join(root, 'dist', 'astrale.js')),
-    ).toBe(true)
-  })
-})