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

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

@@ -1,97 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { acceptJournalPage, buildJournalInput } from '../logs'
-
-describe('buildJournalInput', () => {
-  /** @evidence TEST-CLI-LOGS-MAPS-EXACT-JOURNAL-INPUT */
-  test('maps flags to the current public journal syscall contract', () => {
-    expect(
-      buildJournalInput({
-        topic: 'op:function.failed',
-        topicPrefix: 'security.',
-        principal: 'caller',
-        since: '2026-08-10T00:00:00Z',
-        until: '2026-08-11T00:00:00Z',
-        cursor: 'opaque-next',
-        limit: '50',
-      }),
-    ).toEqual({
-      topics: { exact: ['op:function.failed'], prefixes: ['security.'] },
-      principal: 'caller',
-      since: '2026-08-10T00:00:00Z',
-      until: '2026-08-11T00:00:00Z',
-      cursor: 'opaque-next',
-      limit: 50,
-    })
-  })
-
-  test('defaults only the finite limit and rejects invalid values', () => {
-    expect(buildJournalInput({})).toEqual({ limit: 200 })
-    expect(() => buildJournalInput({ limit: '0' })).toThrow('--limit')
-    expect(() => buildJournalInput({ limit: 'all' })).toThrow('--limit')
-    expect(() => buildJournalInput({ since: 'not-a-date' })).toThrow('--since')
-    expect(() =>
-      buildJournalInput({ since: '2026-01-01T00:00:00Z', until: '1999-01-01T00:00:00Z' }),
-    ).toThrow('--since')
-    expect(() => buildJournalInput({ cursor: 'junk' })).toThrow('--cursor')
-  })
-})
-
-describe('acceptJournalPage', () => {
-  /** @evidence TEST-CLI-LOGS-ADMITS-OPAQUE-CURSOR-PAGE */
-  test('retains current records and an opaque continuation cursor', () => {
-    const page = acceptJournalPage({
-      records: [
-        {
-          sequence: 7,
-          timestamp: '2026-08-11T12:00:00.000Z',
-          topic: 'op:function.completed',
-          payload: { durationMs: 4 },
-          principal: 'caller',
-        },
-      ],
-      cursor: 'next-page',
-    })
-
-    expect(page).toEqual({
-      records: [
-        {
-          sequence: 7,
-          timestamp: '2026-08-11T12:00:00.000Z',
-          topic: 'op:function.completed',
-          payload: { durationMs: 4 },
-          principal: 'caller',
-        },
-      ],
-      cursor: 'next-page',
-    })
-  })
-
-  test('rejects malformed record and cursor fields instead of formatting them loosely', () => {
-    expect(() => acceptJournalPage({ records: [{}] })).toThrow('record 0')
-    expect(() => acceptJournalPage({ records: [], cursor: 7 })).toThrow('cursor')
-  })
-
-  test('admits journal v2 records that use occurredAt instead of timestamp', () => {
-    const page = acceptJournalPage({
-      records: [
-        {
-          sequence: 10241,
-          topic: 'function.invoke',
-          occurredAt: '2026-08-19T16:51:10.049Z',
-          committedAt: '2026-08-19T16:51:10.070Z',
-          payload: { outcome: 'rejected' },
-          correlation: { invocationId: 'cf862a64-3aa1-4343-ba86-f9b516c4ff95' },
-        },
-      ],
-    })
-    expect(page.records[0]).toMatchObject({
-      sequence: 10241,
-      topic: 'function.invoke',
-      timestamp: '2026-08-19T16:51:10.049Z',
-      occurredAt: '2026-08-19T16:51:10.049Z',
-      committedAt: '2026-08-19T16:51:10.070Z',
-      correlationId: 'cf862a64-3aa1-4343-ba86-f9b516c4ff95',
-    })
-  })
-})

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

@@ -1,294 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
-
-type GraphContext = {
-  graph: {
-    query: typeof queryMock
-    getOrThrow: typeof getOrThrowMock
-    mutate: typeof mutateMock
-  }
-}
-
-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 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 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 },
-}
-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: {} }
-  selfFailure = undefined
-  selfContexts = []
-  queryMock.mockClear()
-  getOrThrowMock.mockClear()
-  mutateMock.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,
-      definition: '/: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('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('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,21 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { AstraleError } from '../../errors'
-import { parseTtl } from '../token'
-
-describe('parseTtl', () => {
-  test('defaults to 3600 seconds', () => {
-    expect(parseTtl(undefined)).toBe(3600)
-  })
-
-  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)
-  })
-})

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)
-  })
-})