@astrale-os/cli 0.8.1-alpha.0 → 0.8.1-alpha.3

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

@@ -1,23 +1,12 @@
-import { describe, expect, mock, test } from 'bun:test'
+import { describe, expect, test } from 'bun:test'
 
-import type { IdentityStore } from '../../lib/identity'
+import type { IdentityStore } from '../../identity/index'
 
 import { AuthError } from '../../errors'
-import {
-  ADMIN_INSTANCE,
-  adminInstanceMethod,
-  callOwnedInstances,
-  findOwnedInstance,
-  type OwnedInstanceInfo,
-} from '../../lib/admin-instance'
+import { findOwnedInstance, type OwnedInstanceInfo } from '../../lib/admin-instance'
 import { assertAlphaCreateIdentity } from '../instance/create'
 
 describe('admin-backed instance commands', () => {
-  test('target the merged Instance class', () => {
-    expect(ADMIN_INSTANCE).toBe('/:admin.astrale.ai:class.Instance')
-    expect(adminInstanceMethod('list')).toBe('/:admin.astrale.ai:class.Instance:list')
-  })
-
   test('findOwnedInstance matches owner inventory by slug or stable node id', () => {
     const owned = {
       id: 'instance-node',
@@ -37,28 +26,6 @@ describe('admin-backed instance commands', () => {
     expect(findOwnedInstance([owned], 'other')).toBeUndefined()
   })
 
-  test('owner-scoped discovery calls listMine with an empty input', async () => {
-    const owned: OwnedInstanceInfo[] = [
-      {
-        id: 'instance-node',
-        slug: 'demo',
-        url: 'https://demo.eu.astrale.ai',
-        state: 'ready',
-      },
-    ]
-    const call = mock(async () => owned)
-
-    await expect(callOwnedInstances({ call })).resolves.toEqual([
-      {
-        id: 'instance-node',
-        slug: 'demo',
-        url: 'https://demo.eu.astrale.ai',
-        state: 'ready',
-      },
-    ])
-    expect(call).toHaveBeenCalledWith('/:admin.astrale.ai:class.Instance:listMine', {})
-  })
-
   test('instance create preflight points fresh installs at WorkOS login', () => {
     const store: IdentityStore = {
       default: 'manager',

package/src/commands/__tests__/call-describe.test.ts

@@ -0,0 +1,67 @@
+import { Path } from '@astrale-os/sdk/graph/path'
+import { describe, expect, test } from 'bun:test'
+
+import { describeCallableFromSchema } from '../call-describe'
+
+const schema = {
+  classes: {
+    Manager: {
+      methods: {
+        createInstance: {
+          auth: 'authorized',
+          description: 'Create one child Instance.',
+          input: { type: 'object', required: ['operationId', 'slug'] },
+          output: { mode: 'value' },
+        },
+      },
+    },
+  },
+  functions: {
+    journal: {
+      description: 'Read the authorized Kernel journal.',
+      input: { type: 'object' },
+    },
+  },
+}
+
+describe('describeCallableFromSchema', () => {
+  test('reads a static Class method from the Domain schema', () => {
+    const described = describeCallableFromSchema(
+      Path.parse('/:host.astrale.ai:class.Manager:createInstance'),
+      schema,
+    )
+    expect(described).toMatchObject({
+      origin: 'host.astrale.ai',
+      class: 'Manager',
+      method: 'createInstance',
+      dispatch: 'static',
+      description: 'Create one child Instance.',
+      auth: 'authorized',
+    })
+    expect(described?.input).toMatchObject({ required: ['operationId', 'slug'] })
+  })
+
+  test('finds an instance method when the receiver Path is not a Class projection', () => {
+    expect(
+      describeCallableFromSchema(
+        Path.parse('/:host.astrale.ai:core.manager::createInstance'),
+        schema,
+      ),
+    ).toMatchObject({
+      origin: 'host.astrale.ai',
+      class: 'Manager',
+      method: 'createInstance',
+      dispatch: 'instance',
+    })
+  })
+
+  test('reads a standalone Function from the Domain schema', () => {
+    expect(
+      describeCallableFromSchema(Path.parse('/:kernel.astrale.ai:function.journal'), schema),
+    ).toMatchObject({
+      origin: 'kernel.astrale.ai',
+      function: 'journal',
+      description: 'Read the authorized Kernel journal.',
+    })
+  })
+})

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

@@ -1,72 +1,25 @@
 import { describe, expect, test } from 'bun:test'
 
-import { parseKeyValue, coerceValue } from '../call'
-
-describe('coerceValue', () => {
-  test('parses JSON objects', () => {
-    expect(coerceValue('{"a":1}')).toEqual({ a: 1 })
-  })
-
-  test('parses JSON arrays', () => {
-    expect(coerceValue('[1,2,3]')).toEqual([1, 2, 3])
-  })
-
-  test('falls through on invalid JSON object', () => {
-    expect(coerceValue('{not-json}')).toBe('{not-json}')
-  })
-
-  test('parses booleans', () => {
-    expect(coerceValue('true')).toBe(true)
-    expect(coerceValue('false')).toBe(false)
-  })
-
-  test('parses null', () => {
-    expect(coerceValue('null')).toBe(null)
-  })
-
-  test('parses numbers', () => {
-    expect(coerceValue('42')).toBe(42)
-    expect(coerceValue('3.14')).toBe(3.14)
-    expect(coerceValue('-1')).toBe(-1)
-    expect(coerceValue('0')).toBe(0)
-  })
-
-  test('returns strings for non-special values', () => {
-    expect(coerceValue('hello')).toBe('hello')
-    expect(coerceValue('')).toBe('')
-    expect(coerceValue('some text')).toBe('some text')
-  })
-
-  test('preserves hex, octal, and exotic numeric strings as strings', () => {
-    expect(coerceValue('0x1f')).toBe('0x1f')
-    expect(coerceValue('0o77')).toBe('0o77')
-    expect(coerceValue('0b101')).toBe('0b101')
-    expect(coerceValue('1e308')).toBe('1e308')
-    expect(coerceValue('Infinity')).toBe('Infinity')
-  })
-})
-
-describe('parseKeyValue', () => {
-  test('parses simple key=value pairs', () => {
-    expect(parseKeyValue(['name=test', 'count=5'])).toEqual({
-      name: 'test',
-      count: 5,
-    })
-  })
-
-  test('handles values with = in them', () => {
-    expect(parseKeyValue(['query=a=b'])).toEqual({ query: 'a=b' })
-  })
-
-  test('throws on missing =', () => {
-    expect(() => parseKeyValue(['noequals'])).toThrow('expected key=value')
-  })
-
-  test('parses JSON values', () => {
-    expect(parseKeyValue(['data={"x":1}'])).toEqual({ data: { x: 1 } })
-  })
-
-  test('handles empty value', () => {
-    expect(parseKeyValue(['key='])).toEqual({ key: '' })
+import { materializeCallResult } from '../call'
+
+describe('call command result lifetime', () => {
+  /** @evidence TEST-CLI-CALL-DRAINS-STREAM-IN-CONNECTION-ACTION */
+  test('drains a session-backed stream before returning it for presentation', async () => {
+    let sessionOpen = true
+    async function* stream() {
+      for (const value of ['first', 'second']) {
+        if (!sessionOpen) throw new Error('session closed before stream consumption')
+        yield value
+      }
+    }
+
+    const sessionStream = Object.assign(stream(), { async cancel() {} })
+    const materialized = await materializeCallResult({ kind: 'stream', stream: sessionStream })
+    sessionOpen = false
+
+    expect(materialized).toEqual({ kind: 'stream', values: ['first', 'second'] })
+    expect(Object.isFrozen(materialized)).toBe(true)
+    if (materialized.kind !== 'stream') throw new Error('expected a materialized stream')
+    expect(Object.isFrozen(materialized.values)).toBe(true)
   })
 })

package/src/commands/__tests__/domain-install-owned.test.ts

@@ -2,9 +2,6 @@ import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
 
 import type { OwnedInstanceInfo } from '../../lib/admin-instance'
 
-import { adminDomainMethod } from '../../lib/admin-domain'
-import { adminInstanceMethod } from '../../lib/admin-instance'
-
 class ExitError extends Error {
   constructor(readonly code: string | number | null | undefined) {
     super(`process.exit(${String(code)})`)
@@ -14,21 +11,23 @@ class ExitError extends Error {
 const calls: Array<{ path: string; params: unknown }> = []
 let inventory: OwnedInstanceInfo[] = []
 
-const clientCall = mock(async (path: string, params: unknown): Promise<unknown> => {
+const hostCall = mock(async (call: { target: string; input: unknown }): Promise<unknown> => {
+  const path = call.target
+  const params = call.input
   calls.push({ path, params })
-  if (path === adminInstanceMethod('listMine')) return inventory
   throw new Error(`Unexpected admin call: ${path}`)
 })
 
-mock.module('../../kernel', () => ({
+mock.module('../../connection', () => ({
+  createPathCall: (path: string, input: unknown) => ({
+    target: path,
+    input,
+  }),
   runKernelCommand: mock(),
-}))
-
-mock.module('../../kernel/client', () => ({
-  withAdminKernelClient: async (
+  withAdminClientSession: async (
     _opts: unknown,
-    run: (ctx: { client: { call: typeof clientCall } }) => Promise<unknown>,
-  ) => run({ client: { call: clientCall } }),
+    run: (ctx: { session: { call: typeof hostCall } }) => Promise<unknown>,
+  ) => run({ session: { call: hostCall } }),
 }))
 
 let stderr = ''
@@ -39,7 +38,7 @@ beforeEach(() => {
   calls.length = 0
   inventory = []
   stderr = ''
-  clientCall.mockClear()
+  hostCall.mockClear()
   originalExit = process.exit
   originalStderrWrite = process.stderr.write.bind(process.stderr)
   process.exit = ((code?: string | number | null) => {
@@ -57,20 +56,20 @@ afterEach(() => {
 })
 
 async function runInstall(instance: string): Promise<void> {
-  const command = (await import('../domain/install')).default
-  const action = command.action as (
-    target: string | undefined,
-    opts: Record<string, unknown>,
-  ) => Promise<void>
-  await action('crm.acme.dev', {
-    instance,
-    json: true,
-    noPrompt: true,
-  })
+  const { installViaAdmin } = await import('../domain/install')
+  await installViaAdmin(
+    'crm.acme.dev',
+    {
+      instance,
+      json: true,
+      noPrompt: true,
+    },
+    { listInstances: async () => inventory },
+  )
 }
 
 describe('admin domain install owner boundary', () => {
-  test('rejects a foreign target after listMine without attempting an install', async () => {
+  test('rejects a foreign target after the V2 graph inventory without attempting an install', async () => {
     inventory = [
       {
         id: 'owned-id',
@@ -86,7 +85,7 @@ describe('admin domain install owner boundary', () => {
       error: 'INSTANCE_NOT_MANAGED',
       message: 'Instance "foreign" is not admin-managed (managed: owned).',
     })
-    expect(calls).toEqual([{ path: adminInstanceMethod('listMine'), params: {} }])
+    expect(calls).toEqual([])
   })
 
   test.each([
@@ -116,7 +115,7 @@ describe('admin domain install owner boundary', () => {
     expect(payload.error).toBe('INSTANCE_NOT_READY')
     expect(payload.message).toContain(`Instance "owned" is ${status.state}`)
     expect(payload.hint).toBe(status.error ?? 'Run: astrale instance status owned')
-    expect(calls).toEqual([{ path: adminInstanceMethod('listMine'), params: {} }])
-    expect(calls.some((call) => call.path === adminDomainMethod('install'))).toBe(false)
+    expect(calls).toEqual([])
+    expect(calls).toEqual([])
   })
 })

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

@@ -1,6 +1,7 @@
 import { describe, expect, test } from 'bun:test'
 
-import { ADMIN_DOMAIN, adminDomainMethod, type DomainInfo } from '../../lib/admin-domain'
+import type { DomainInfo } from '../../lib/admin-domain'
+
 import { byDefaultThenName, domainProjection, type DomainRow } from '../domain/list'
 
 const strip = (s: string): string => s.replace(/\[[0-9;]*m/g, '')
@@ -17,11 +18,6 @@ function entry(over: Partial<DomainInfo>): DomainInfo {
 }
 
 describe('domain list — ordering', () => {
-  test('uses the semantic static method path', () => {
-    expect(ADMIN_DOMAIN).toBe('/:admin.astrale.ai:class.DomainEntry')
-    expect(adminDomainMethod('list')).toBe('/:admin.astrale.ai:class.DomainEntry:list')
-  })
-
   test('install-by-default sorts first, then alphabetical by origin', () => {
     const rows = [
       entry({ origin: 'zeta.astrale.ai' }),

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

@@ -0,0 +1,20 @@
+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', () => {
+    expect(directInstallCallInput('https://tasks.example.test', 'secret', 'op-1')).toEqual({
+      operation: 'op-1',
+      domains: [
+        {
+          source: {
+            kind: 'remote',
+            url: 'https://tasks.example.test',
+            token: 'secret',
+          },
+        },
+      ],
+    })
+  })
+})

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

@@ -0,0 +1,26 @@
+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__/logs.test.ts

@@ -1,117 +1,92 @@
 import { describe, expect, test } from 'bun:test'
 
-import { buildEventsParams, normalizePage, parseServiceName, parseTimeFlag } from '../logs'
+import { acceptJournalPage, buildJournalInput } from '../logs'
 
-describe('parseTimeFlag', () => {
-  test('passes through epoch-ms', () => {
-    expect(parseTimeFlag('--since', '1718841600000')).toBe(1718841600000)
-    expect(parseTimeFlag('--since', '0')).toBe(0)
-    expect(parseTimeFlag('--since', '-5')).toBe(-5)
-  })
-
-  test('parses ISO-8601 to epoch ms', () => {
-    expect(parseTimeFlag('--since', '2026-06-20T00:00:00Z')).toBe(
-      Date.parse('2026-06-20T00:00:00Z'),
-    )
-  })
-
-  test('throws on garbage', () => {
-    expect(() => parseTimeFlag('--since', 'not-a-time')).toThrow('--since')
-  })
-})
-
-describe('buildEventsParams', () => {
-  test('defaults limit when unset, no other fields', () => {
-    expect(buildEventsParams({})).toEqual({ limit: 200 })
-  })
-
-  test('maps typed flags into a JournalFilter', () => {
+describe('buildJournalInput', () => {
+  /** @evidence TEST-CLI-LOGS-MAPS-EXACT-JOURNAL-INPUT */
+  test('maps flags to the current public journal syscall contract', () => {
     expect(
-      buildEventsParams({
-        topic: 'op:*:failed',
-        principal: 'id_abc',
-        since: '1000',
-        until: '2000',
+      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',
-        cursor: '7',
       }),
     ).toEqual({
-      topic: 'op:*:failed',
-      principal: 'id_abc' as never,
-      since: 1000,
-      until: 2000,
+      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,
-      cursor: 7,
     })
   })
 
-  test('rejects a non-positive limit', () => {
-    expect(() => buildEventsParams({ limit: '0' })).toThrow('--limit')
-    expect(() => buildEventsParams({ limit: '-3' })).toThrow('--limit')
-    expect(() => buildEventsParams({ limit: 'x' })).toThrow('--limit')
-  })
-
-  test('rejects a non-positive cursor', () => {
-    expect(() => buildEventsParams({ cursor: '0' })).toThrow('--cursor')
-  })
-
-  test('omits empty topic/principal', () => {
-    expect(buildEventsParams({ topic: '', principal: '' })).toEqual({ limit: 200 })
+  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')
   })
 })
 
-describe('normalizePage', () => {
-  const entry = (seq: number) => ({
-    seq,
-    event: {
-      id: `e${seq}`,
-      topic: 'op:x',
-      payload: {},
-      metadata: { traceId: 't', timestamp: seq, principal: 'p', root: 'r' },
-    },
-  })
-
-  test('wraps a bare entry array and derives nextCursor from max seq', () => {
-    const page = normalizePage([entry(3), entry(7), entry(5)])
-    expect(page.entries).toHaveLength(3)
-    expect(page.nextCursor).toBe(7)
-  })
-
-  test('empty array → empty entries, null cursor', () => {
-    expect(normalizePage([])).toEqual({ entries: [], nextCursor: null })
-  })
-
-  test('accepts a paged { entries, nextCursor } shape', () => {
-    const page = normalizePage({ entries: [entry(1)], nextCursor: 42 })
-    expect(page.entries).toHaveLength(1)
-    expect(page.nextCursor).toBe(42)
-  })
-
-  test('paged shape without nextCursor falls back to max seq', () => {
-    expect(normalizePage({ entries: [entry(9)] }).nextCursor).toBe(9)
-  })
-
-  test('non-array, non-page input → empty', () => {
-    expect(normalizePage(null)).toEqual({ entries: [], nextCursor: null })
-    expect(normalizePage(undefined)).toEqual({ entries: [], nextCursor: null })
-    expect(normalizePage('nope')).toEqual({ entries: [], nextCursor: null })
-  })
-})
-
-describe('parseServiceName', () => {
-  test('bare name is returned as-is', () => {
-    expect(parseServiceName('my-notes')).toBe('my-notes')
-  })
+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',
+    })
 
-  test('host → first label', () => {
-    expect(parseServiceName('my-notes.svc.eu.astrale.ai')).toBe('my-notes')
+    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('full URL → hostname first label', () => {
-    expect(parseServiceName('https://my-notes.example.dev/path')).toBe('my-notes')
+  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('trims whitespace', () => {
-    expect(parseServiceName('  my-notes  ')).toBe('my-notes')
+  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__/ls.test.ts

@@ -1,25 +1,29 @@
+import type { Node } from '@astrale-os/sdk/graph/node'
+
+import { ClassPath } from '@astrale-os/sdk/graph/class'
+import { NodeId } from '@astrale-os/sdk/graph/node'
+import { normalizeProperties } from '@astrale-os/sdk/graph/properties'
 import { describe, expect, test } from 'bun:test'
 
-import { basename, classNameOf } from '../ls'
+import { displayName, listProjection } from '../ls'
 
-// Regression: the formatter used to read `item.slug` (never returned by the
-// kernel), blanking the name column and breaking `-q`/`-R`. The real fields are
-// `path` (absolute) and `class` (serialized ClassPath).
-describe('ls — display projection (slug-bug regression)', () => {
-  test('basename derives the display name from the absolute path', () => {
-    expect(basename('/example.astrale.ai')).toBe('example.astrale.ai')
-    expect(basename('/kernel.astrale.ai')).toBe('kernel.astrale.ai')
-    expect(basename('/')).toBe('/')
-    expect(basename(undefined)).toBe('')
-  })
+describe('ls display projection', () => {
+  const node = {
+    id: NodeId('note-1'),
+    class: ClassPath.parse('/:notes.example.dev:class.Note'),
+    props: normalizeProperties({ 'notes.example.dev:class.Note.property.title': 'Hello' }),
+  } satisfies Node
 
-  test('classNameOf parses the kind from the serialized class path', () => {
-    expect(classNameOf({ class: '/:kernel.astrale.ai:class.Domain' })).toBe('Domain')
-    expect(classNameOf({ class: '/:kernel.astrale.ai:class.Folder' })).toBe('Folder')
+  /** @evidence TEST-CLI-LS-PROJECTS-CANONICAL-NODES */
+  test('uses canonical properties for display and @id for pipeable output', () => {
+    expect(displayName(node)).toBe('Hello')
+    expect(listProjection([node])).toMatchObject({
+      rows: [{ name: 'Hello', class: 'Note', id: 'note-1' }],
+      paths: ['@note-1'],
+    })
   })
 
-  test('classNameOf falls back to the most specific label, then ?', () => {
-    expect(classNameOf({ __labels: ['Node', 'Domain', 'Container'] })).toBe('Container')
-    expect(classNameOf({})).toBe('?')
+  test('falls back to the canonical Node ID when no display property exists', () => {
+    expect(displayName({ ...node, props: normalizeProperties({}) })).toBe('@note-1')
   })
 })