@astrale-os/cli 1.0.0-beta.4 → 1.0.0-beta.6

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

@@ -1,34 +1,47 @@
 import { Path } from '@astrale-os/sdk/graph/path'
+import { bundle, defineSchema, func, method, nodeClass } from '@astrale-os/sdk/schema'
 import { describe, expect, test } from 'bun:test'
 
-import { describeCallableFromSchema } from '../call-describe'
+import { describeCallableFromBundle } 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' },
-        },
-      },
-    },
+const createInstance = method({
+  auth: 'authenticated',
+  description: 'Create one child Instance.',
+  input: {
+    type: 'object',
+    properties: { operationId: { type: 'string' }, slug: { type: 'string' } },
+    required: ['operationId', 'slug'],
+    additionalProperties: false,
   },
-  functions: {
-    journal: {
-      description: 'Read the authorized Kernel journal.',
-      input: { type: 'object' },
-    },
+  output: { type: 'object', additionalProperties: true },
+  static: true,
+})
+const inspectInstance = method({
+  auth: 'authenticated',
+  description: 'Inspect one child Instance.',
+  input: { type: 'object', properties: {}, additionalProperties: false },
+  output: { type: 'object', additionalProperties: true },
+})
+const journal = func({
+  auth: 'authenticated',
+  description: 'Read the authorized Kernel journal.',
+  input: { type: 'object', properties: {}, additionalProperties: false },
+  output: { type: 'object', additionalProperties: true },
+})
+const source = defineSchema('host.astrale.ai', {
+  classes: {
+    Manager: nodeClass({ methods: { createInstance } }),
+    Instance: nodeClass({ methods: { inspectInstance } }),
   },
-}
+  functions: { journal },
+})
+const installed = bundle.create(source)
 
-describe('describeCallableFromSchema', () => {
-  test('reads a static Class method from the Domain schema', () => {
-    const described = describeCallableFromSchema(
+describe('describeCallableFromBundle', () => {
+  test('reads a static Class method from the resolved Domain', () => {
+    const described = describeCallableFromBundle(
       Path.parse('/:host.astrale.ai:class.Manager:createInstance'),
-      schema,
+      installed,
     )
     expect(described).toMatchObject({
       origin: 'host.astrale.ai',
@@ -36,30 +49,30 @@ describe('describeCallableFromSchema', () => {
       method: 'createInstance',
       dispatch: 'static',
       description: 'Create one child Instance.',
-      auth: 'authorized',
+      auth: 'authenticated',
     })
     expect(described?.input).toMatchObject({ required: ['operationId', 'slug'] })
   })
 
-  test('finds an instance method when the receiver Path is not a Class projection', () => {
+  test('finds one instance method when the receiver Path is not a Class projection', () => {
     expect(
-      describeCallableFromSchema(
-        Path.parse('/:host.astrale.ai:core.manager::createInstance'),
-        schema,
+      describeCallableFromBundle(
+        Path.parse('/:host.astrale.ai:core.manager::inspectInstance'),
+        installed,
       ),
     ).toMatchObject({
       origin: 'host.astrale.ai',
-      class: 'Manager',
-      method: 'createInstance',
+      class: 'Instance',
+      method: 'inspectInstance',
       dispatch: 'instance',
     })
   })
 
-  test('reads a standalone Function from the Domain schema', () => {
+  test('reads a standalone Function from the resolved Domain', () => {
     expect(
-      describeCallableFromSchema(Path.parse('/:kernel.astrale.ai:function.journal'), schema),
+      describeCallableFromBundle(Path.parse('/:host.astrale.ai:function.journal'), installed),
     ).toMatchObject({
-      origin: 'kernel.astrale.ai',
+      origin: 'host.astrale.ai',
       function: 'journal',
       description: 'Read the authorized Kernel journal.',
     })

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

@@ -1,9 +1,7 @@
-import { defineDomain } from '@astrale-os/sdk'
-import { issuer } from '@astrale-os/sdk/auth'
-import { createDeployment } from '@astrale-os/sdk/deployment'
-import { defineSchema } from '@astrale-os/sdk/schema/v1'
+import { defineSchema } from '@astrale-os/sdk/schema'
 import { afterEach, describe, expect, mock, test } from 'bun:test'
 
+import { releaseFor } from '../../__tests__/fixtures/publication'
 import { installDirect } from '../domain/install'
 
 const GENERATED = '4a4c9a18-50f6-4d84-a7b7-2d83e3e45dc8'
@@ -12,16 +10,7 @@ const RETRY = '139137b5-af47-47ce-92b2-b64a2b0c63d7'
 const originalFetch = globalThis.fetch
 
 const schema = defineSchema('crm.test', {})
-const definition = defineDomain({
-  schema,
-  handlers: { functions: {}, classes: {}, interfaces: {} },
-})
-const deployed = createDeployment({
-  definition,
-  issuer: issuer.accept('https://crm.test'),
-  bundleHref: 'https://crm.test/domain.bundle.json',
-  bindings: { callables: [] },
-}).publication
+const deployed = releaseFor(schema, 'https://crm.test').publication
 
 function publicationResponse(): Response {
   return Response.json(deployed)

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

@@ -1,4 +1,4 @@
-import { ResponseError } from '@astrale-os/kernel-client'
+import { ResponseError } from '@astrale-os/sdk/client'
 import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
 
 import type { OwnedInstanceInfo } from '../../lib/admin-instance'

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

@@ -1,11 +1,9 @@
-import { defineDomain } from '@astrale-os/sdk'
-import { issuer } from '@astrale-os/sdk/auth'
-import { createDeployment } from '@astrale-os/sdk/deployment'
-import { defineSchema } from '@astrale-os/sdk/schema/v1'
+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, '')
@@ -85,16 +83,7 @@ describe('domain list — canonical Publication check', () => {
 
   test('reports the admitted schema revision in machine data', async () => {
     const schema = defineSchema('catalog-check.example.dev', {})
-    const definition = defineDomain({
-      schema,
-      handlers: { functions: {}, classes: {}, interfaces: {} },
-    })
-    const deployed = createDeployment({
-      definition,
-      issuer: issuer.accept('https://catalog-check.example.dev'),
-      bundleHref: 'https://catalog-check.example.dev/domain.bundle.json',
-      bindings: { callables: [] },
-    }).publication
+    const deployed = releaseFor(schema, 'https://catalog-check.example.dev').publication
     const server = Bun.serve({
       port: 0,
       fetch(request) {
@@ -114,23 +103,14 @@ describe('domain list — canonical Publication check', () => {
       ),
     ).resolves.toMatchObject({
       reachable: true,
-      schemaRevision: definition.domain.$.revision,
+      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 definition = defineDomain({
-      schema,
-      handlers: { functions: {}, classes: {}, interfaces: {} },
-    })
-    const deployed = createDeployment({
-      definition,
-      issuer: issuer.accept('https://deployed.example.dev'),
-      bundleHref: 'https://deployed.example.dev/domain.bundle.json',
-      bindings: { callables: [] },
-    }).publication
+    const deployed = releaseFor(schema, 'https://deployed.example.dev').publication
     const server = Bun.serve({
       port: 0,
       fetch: () => Response.json(deployed),

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

@@ -1,9 +1,7 @@
-import { defineDomain } from '@astrale-os/sdk'
-import { issuer } from '@astrale-os/sdk/auth'
-import { createDeployment } from '@astrale-os/sdk/deployment'
-import { defineSchema } from '@astrale-os/sdk/schema/v1'
+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', () => {
@@ -47,16 +45,7 @@ describe('declared-origin Publication probe', () => {
 
   test('reads origin from a well-formed canonical Publication', async () => {
     const schema = defineSchema('crm.acme.dev', {})
-    const definition = defineDomain({
-      schema,
-      handlers: { functions: {}, classes: {}, interfaces: {} },
-    })
-    const deployed = createDeployment({
-      definition,
-      issuer: issuer.accept('https://crm.acme.dev'),
-      bundleHref: 'https://crm.acme.dev/domain.bundle.json',
-      bindings: { callables: [] },
-    }).publication
+    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)

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

@@ -36,6 +36,8 @@ 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 })
@@ -49,7 +51,9 @@ const mutateMock = mock(async (mutation: unknown) => {
   mutations.push(mutation)
   return mutationResult
 })
-const expandSelfInPathMock = mock(async (path: string) => {
+const expandSelfInPathMock = mock(async (path: string, context: unknown) => {
+  selfContexts.push(context)
+  if (selfFailure !== undefined) throw selfFailure
   if (path === '@self') {
     return {
       path: '@expanded-self',
@@ -59,10 +63,11 @@ const expandSelfInPathMock = mock(async (path: string) => {
   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({
-    graph: { query: queryMock, getOrThrow: getOrThrowMock, mutate: mutateMock },
-  })
+  const result = await run.fn(commandContext)
   await run.format?.(result, run.opts, true)
 })
 
@@ -88,6 +93,8 @@ beforeEach(() => {
   }
   getResult = undefined
   mutationResult = { createdNodes: {} }
+  selfFailure = undefined
+  selfContexts = []
   queryMock.mockClear()
   getOrThrowMock.mockClear()
   mutateMock.mockClear()
@@ -161,7 +168,7 @@ describe('query command', () => {
     ])
   })
 
-  test('authors a Definition source through the same canonical Query V6 call', async () => {
+  test('authors a Class source through the same canonical Query V6 call', async () => {
     const { queryCommand } = await import('../query')
 
     await queryCommand([], {
@@ -179,8 +186,8 @@ describe('query command', () => {
             kind: 'node',
             terms: [
               {
-                kind: 'definition',
-                definition: { origin: 'issues.astrale.ai', kind: 'class', name: 'Issue' },
+                kind: 'class',
+                class: { origin: 'issues.astrale.ai', kind: 'class', name: 'Issue' },
               },
             ],
             binding: 'n0',
@@ -193,6 +200,17 @@ describe('query command', () => {
     ])
   })
 
+  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')
@@ -215,7 +233,7 @@ describe('get command', () => {
     const { getCommand } = await import('../get')
     getResult = {
       id: 'note-1',
-      class: '/:notes.example.dev:class.Note',
+      class: 'notes.example.dev:class.Note',
       props: { 'notes.example.dev:class.Note.property.title': 'Hello' },
     }
 
@@ -226,6 +244,13 @@ describe('get command', () => {
     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', () => {
@@ -242,7 +267,7 @@ describe('mutate command', () => {
           {
             op: 'node.create',
             as: 'note',
-            class: '/:notes.example.dev:class.Note',
+            class: 'notes.example.dev:class.Note',
             props: {},
           },
         ],
@@ -258,7 +283,7 @@ describe('mutate command', () => {
           {
             op: 'node.create',
             as: 'note',
-            class: '/:notes.example.dev:class.Note',
+            class: 'notes.example.dev:class.Note',
             props: {},
           },
         ],

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

@@ -35,9 +35,11 @@ describe('CLI update staleness', () => {
     const result = await cliStale(
       { channel: 'canary' },
       {
-        update: async () => {
-          throw new Error('package managed')
-        },
+        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'
@@ -52,6 +54,26 @@ describe('CLI update staleness', () => {
     })
   })
 
+  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) => {

package/src/commands/call-describe.ts

@@ -1,8 +1,9 @@
 import type { Path } from '@astrale-os/sdk/graph/path'
+import type { ResolvedFunction, ResolvedMethod } from '@astrale-os/sdk/schema'
 
-import { AstraleError } from '../errors'
+import { bundle, schema } from '@astrale-os/sdk/schema'
 
-type JsonRecord = Record<string, unknown>
+import { AstraleError } from '../errors'
 
 export interface CallableDescription {
   readonly path: string
@@ -18,40 +19,40 @@ export interface CallableDescription {
   readonly candidates?: readonly CallableDescription[]
 }
 
-/** Resolve one callable's input/output from an installed Domain schema document. */
-export function describeCallableFromSchema(
+/** Resolve one callable from an admitted installed Domain bundle. */
+export function describeCallableFromBundle(
   path: Path,
-  schema: unknown,
+  input: unknown,
 ): CallableDescription | undefined {
   if (path.ast.anchor.kind !== 'domain') return undefined
   const origin = path.ast.anchor.origin
   const last = path.ast.steps.at(-1)
-  const document = asRecord(schema)
-  if (document === undefined || last === undefined) return undefined
+  if (last === undefined) return undefined
+  const domain = schema.resolve(bundle.accept(input).root)
+  if (domain.origin !== origin) return undefined
 
   if (last.kind === 'method') {
-    const owner = path.ast.steps.at(-2)
-    if (
-      owner?.kind === 'projection' &&
-      (owner.projection.kind === 'class' || owner.projection.kind === 'interface')
-    ) {
-      const bag = asRecord(
-        owner.projection.kind === 'class' ? document.classes : document.interfaces,
+    const ownerStep = path.ast.steps.at(-2)
+    if (ownerStep?.kind === 'projection' && ownerStep.projection.kind === 'class') {
+      const owner = domain.classes[ownerStep.projection.name]
+      if (owner?.kind !== 'node') return undefined
+      const method = namedMethod(
+        last.dispatch === 'static' ? owner.static.methods : owner.methods,
+        last.name,
+        last.dispatch,
       )
-      const definition = asRecord(bag?.[owner.projection.name])
-      const method = asRecord(asRecord(definition?.methods)?.[last.name])
-      if (method !== undefined) {
-        return Object.freeze({
-          path: path.raw,
-          origin,
-          class: owner.projection.name,
-          method: last.name,
-          dispatch: last.dispatch,
-          ...callableFields(method),
-        })
-      }
+      return method === undefined
+        ? undefined
+        : description(path, origin, owner.ref.name, method, last.dispatch)
     }
-    const matches = findNamedMethods(document, origin, path.raw, last.name, last.dispatch)
+
+    const matches = Object.values(domain.classes).flatMap((owner) => {
+      if (owner.kind !== 'node') return []
+      const method = namedMethod(owner.methods, last.name, last.dispatch)
+      return method === undefined
+        ? []
+        : [description(path, origin, owner.ref.name, method, last.dispatch)]
+    })
     if (matches.length === 1) return matches[0]
     if (matches.length > 1) {
       return Object.freeze({
@@ -66,13 +67,13 @@ export function describeCallableFromSchema(
   }
 
   if (last.kind === 'projection' && last.projection.kind === 'function') {
-    const fn = asRecord(asRecord(document.functions)?.[last.projection.name])
-    if (fn === undefined) return undefined
+    const callable = domain.functions[last.projection.name]
+    if (callable === undefined) return undefined
     return Object.freeze({
       path: path.raw,
       origin,
-      function: last.projection.name,
-      ...callableFields(fn),
+      function: callable.ref.name,
+      ...callableFields(callable),
     })
   }
   return undefined
@@ -86,46 +87,37 @@ export function missingCallableDescription(path: string): AstraleError {
   )
 }
 
-function findNamedMethods(
-  schema: JsonRecord,
+function namedMethod(
+  methods: Iterable<ResolvedMethod>,
+  name: string,
+  dispatch: 'static' | 'instance',
+): ResolvedMethod | undefined {
+  const expectedStatic = dispatch === 'static'
+  return [...methods].find((method) => method.name === name && method.static === expectedStatic)
+}
+
+function description(
+  path: Path,
   origin: string,
-  path: string,
-  method: string,
+  className: string,
+  callable: ResolvedMethod,
   dispatch: 'static' | 'instance',
-): CallableDescription[] {
-  const matches: CallableDescription[] = []
-  for (const bag of [schema.classes, schema.interfaces]) {
-    const definitions = asRecord(bag)
-    if (definitions === undefined) continue
-    for (const [className, definition] of Object.entries(definitions)) {
-      const methodDef = asRecord(asRecord(asRecord(definition)?.methods)?.[method])
-      if (methodDef === undefined) continue
-      matches.push(
-        Object.freeze({
-          path,
-          origin,
-          class: className,
-          method,
-          dispatch,
-          ...callableFields(methodDef),
-        }),
-      )
-    }
-  }
-  return matches
+): CallableDescription {
+  return Object.freeze({
+    path: path.raw,
+    origin,
+    class: className,
+    method: callable.name,
+    dispatch,
+    ...callableFields(callable),
+  })
 }
 
-function callableFields(value: JsonRecord): Partial<CallableDescription> {
+function callableFields(callable: ResolvedFunction | ResolvedMethod): Partial<CallableDescription> {
   return {
-    ...(typeof value.description === 'string' ? { description: value.description } : {}),
-    ...(value.auth === undefined ? {} : { auth: value.auth }),
-    ...(value.input === undefined ? {} : { input: value.input }),
-    ...(value.output === undefined ? {} : { output: value.output }),
+    ...(callable.description === undefined ? {} : { description: callable.description }),
+    auth: callable.auth,
+    input: callable.input,
+    output: callable.output,
   }
 }
-
-function asRecord(input: unknown): JsonRecord | undefined {
-  return input !== null && typeof input === 'object' && !Array.isArray(input)
-    ? (input as JsonRecord)
-    : undefined
-}