@astrale-os/cli 1.0.0-beta.17 → 1.0.0-beta.18

package/dist/public/connect-core.js

@@ -8242,14 +8242,14 @@ function isPidAlive(pid) {
 function sleep(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
-// node_modules/.pnpm/@astrale-os+kernel-dsl@0.2.0-beta.10/node_modules/@astrale-os/kernel-dsl/dist/value/limits.js
+// node_modules/.pnpm/@astrale-os+kernel-dsl@0.2.0-beta.12/node_modules/@astrale-os/kernel-dsl/dist/value/limits.js
 var defaultLimits = Object.freeze({
   maxBytes: 16 * 1024 * 1024,
   maxDepth: 64,
   maxMembers: 1e5,
   maxStringBytes: 1024 * 1024
 });
-// node_modules/.pnpm/@astrale-os+kernel-dsl@0.2.0-beta.10/node_modules/@astrale-os/kernel-dsl/dist/value/canonical.js
+// node_modules/.pnpm/@astrale-os+kernel-dsl@0.2.0-beta.12/node_modules/@astrale-os/kernel-dsl/dist/value/canonical.js
 var encoder2 = new TextEncoder;
 // node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
 var CharacterCodes;
@@ -8429,7 +8429,7 @@ var ParseErrorCode;
   ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
 })(ParseErrorCode || (ParseErrorCode = {}));
 
-// node_modules/.pnpm/@astrale-os+kernel-dsl@0.2.0-beta.10/node_modules/@astrale-os/kernel-dsl/dist/value/decode.js
+// node_modules/.pnpm/@astrale-os+kernel-dsl@0.2.0-beta.12/node_modules/@astrale-os/kernel-dsl/dist/value/decode.js
 var decoder2 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 // node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -23659,7 +23659,7 @@ var log = {
   dim: (msg) => console.log(source_default.dim(msg))
 };
 var IS_CI = !!(process.env.CI || process.env.CONTINUOUS_INTEGRATION || process.env.NO_SPINNER);
-// node_modules/.pnpm/@astrale-os+kernel-core@0.9.0-beta.13/node_modules/@astrale-os/kernel-core/dist/dns-label.js
+// node_modules/.pnpm/@astrale-os+kernel-core@0.9.0-beta.15/node_modules/@astrale-os/kernel-core/dist/dns-label.js
 var DNS_LABEL_RE = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
 function isDnsLabel(value) {
   return DNS_LABEL_RE.test(value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/cli",
-  "version": "1.0.0-beta.17",
+  "version": "1.0.0-beta.18",
   "description": "Astrale CLI — connect to existing Astrale kernels",
   "keywords": [
     "astrale",
@@ -62,7 +62,7 @@
   },
   "devDependencies": {
     "@astrale-os/ox": ">=0.1.3 <1.0.0",
-    "@astrale-os/sdk": "0.5.0-beta.38",
+    "@astrale-os/sdk": "0.5.0-beta.49",
     "@astrale-os/shell": "0.4.2-beta.3",
     "@astrale/commitlint-config": "npm:@jsr/astrale__commitlint-config@~2.0.1",
     "@commitlint/cli": "21.2.2",

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

@@ -38,9 +38,7 @@ describe('direct domain install operation identity', () => {
           recovery = input.recovery
           requests.push(
             await input.fn({
-              session: {
-                call: async (call: { input: unknown }) => call.input,
-              },
+              session: { schema: { install: async (input: unknown) => input } },
             } as never),
           )
         },
@@ -51,7 +49,7 @@ describe('direct domain install operation identity', () => {
     expect(requests).toEqual([
       {
         operation: GENERATED,
-        domains: [{ source: { kind: 'remote', url: 'https://crm.test' } }],
+        domains: [{ publication: { url: 'https://crm.test' } }],
       },
     ])
     expect(recovery).toEqual({
@@ -78,9 +76,7 @@ describe('direct domain install operation identity', () => {
         runKernelCommand: async (input) => {
           requests.push(
             await input.fn({
-              session: {
-                call: async (call: { input: unknown }) => call.input,
-              },
+              session: { schema: { install: async (input: unknown) => input } },
             } as never),
           )
         },
@@ -92,7 +88,7 @@ describe('direct domain install operation identity', () => {
     expect(requests).toEqual([
       {
         operation: RETRY,
-        domains: [{ source: { kind: 'remote', url: 'https://crm.test' } }],
+        domains: [{ publication: { url: 'https://crm.test' } }],
       },
     ])
   })

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

@@ -1,21 +1,128 @@
+import type { InstallResult } from '@astrale-os/sdk/client/schema'
+
+import { defineSchema, schema } from '@astrale-os/sdk/schema'
 import { describe, expect, test } from 'bun:test'
 
-import { directInstallCallInput } from '../domain/install'
+import { directInstallCallInput, directInstallPresentation } from '../domain/install'
+
+const currentRevision = schema.revision(defineSchema('tasks.astrale.ai', {}))
 
 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,
+    const input = directInstallCallInput('https://tasks.example.test', operation, 'secret')
+
+    expect(String(input.operation)).toBe(operation)
+    expect(input.domains).toEqual([
+      {
+        publication: {
+          url: 'https://tasks.example.test',
+          token: 'secret',
+        },
+      },
+    ])
+  })
+
+  test('presents a committed install from its receipt', () => {
+    const operation = directInstallCallInput(
+      'https://tasks.example.test',
+      '4a4c9a18-50f6-4d84-a7b7-2d83e3e45dc8',
+    ).operation
+    const result = {
+      changed: true,
+      receipt: {
+        operation,
+        transitions: [
+          {
+            intent: {
+              transition: 'transition-1',
+              operation,
+              origin: 'tasks.astrale.ai',
+              previous: null,
+              generation: {
+                origin: 'tasks.astrale.ai',
+                revision: currentRevision,
+                generation: 'sha256:generation',
+              },
+            },
+            phase: 'cutover',
+            state: 'committed',
+          },
+        ],
+      },
+    } satisfies InstallResult
+
+    expect(directInstallPresentation(result, 'ignored')).toEqual({
+      operation: '4a4c9a18-50f6-4d84-a7b7-2d83e3e45dc8',
+      origin: 'tasks.astrale.ai',
+      revision: currentRevision,
+      status: 'installed',
+    })
+  })
+
+  test('presents an idempotent install from the current Domain observation', () => {
+    const operation = '4a4c9a18-50f6-4d84-a7b7-2d83e3e45dc8'
+    const result = {
+      changed: false,
       domains: [
         {
-          source: {
-            kind: 'remote',
-            url: 'https://tasks.example.test',
-            token: 'secret',
-          },
+          origin: 'tasks.astrale.ai',
+          revision: currentRevision,
+          generation: 'sha256:generation',
+          publication: null,
+          readiness: 'sha256:readiness',
+          capabilities: { requested: {}, materialized: {} },
+          bindings: { callables: [], views: [] },
         },
       ],
+    } satisfies InstallResult
+
+    expect(directInstallPresentation(result, operation)).toEqual({
+      operation,
+      origin: 'tasks.astrale.ai',
+      revision: currentRevision,
+      status: 'already current',
     })
   })
+
+  test('rejects a changed result without a committed transition', () => {
+    const result = {
+      changed: true,
+      receipt: { operation: '4a4c9a18-50f6-4d84-a7b7-2d83e3e45dc8', transitions: [] },
+    } as unknown as InstallResult
+
+    expect(() => directInstallPresentation(result, 'ignored')).toThrow(
+      'Kernel install returned no committed Domain transition.',
+    )
+  })
+
+  test('rejects a committed transition without an installed generation', () => {
+    const operation = directInstallCallInput(
+      'https://tasks.example.test',
+      '4a4c9a18-50f6-4d84-a7b7-2d83e3e45dc8',
+    ).operation
+    const result = {
+      changed: true,
+      receipt: {
+        operation,
+        transitions: [
+          {
+            intent: {
+              transition: 'transition-1',
+              operation,
+              origin: 'tasks.astrale.ai',
+              previous: null,
+              generation: null,
+            },
+            phase: 'cutover',
+            state: 'committed',
+          },
+        ],
+      },
+    } satisfies InstallResult
+
+    expect(() => directInstallPresentation(result, 'ignored')).toThrow(
+      'Kernel install returned a committed transition without a Domain generation.',
+    )
+  })
 })

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

@@ -1,6 +1,44 @@
+import type { DomainBundle, DomainInfo } from '@astrale-os/sdk/client/schema'
+
+import { bundle, defineSchema, func, method, nodeClass, schema } from '@astrale-os/sdk/schema'
 import { describe, expect, test } from 'bun:test'
 
-import { parseIntrospectTarget } from '../introspect'
+import { introspectCommand, parseIntrospectTarget } from '../introspect'
+
+const source = defineSchema('host.astrale.ai', {
+  classes: {
+    Manager: nodeClass({
+      methods: {
+        createInstance: method({
+          auth: 'authenticated',
+          input: { type: 'object', properties: {}, additionalProperties: false },
+          output: { type: 'object', additionalProperties: true },
+          static: true,
+        }),
+      },
+    }),
+  },
+  functions: {
+    journal: func({
+      auth: 'authenticated',
+      input: { type: 'object', properties: {}, additionalProperties: false },
+      output: { type: 'object', additionalProperties: true },
+    }),
+  },
+})
+
+const info = {
+  origin: source.origin,
+  revision: schema.revision(source),
+  generation: 'sha256:generation',
+  publication: null,
+  readiness: 'sha256:readiness',
+  capabilities: { requested: {}, materialized: {} },
+  bindings: { callables: [], views: [] },
+} satisfies DomainInfo
+
+const installed = bundle.create(source)
+const bundled = { domain: info, bundle: installed } satisfies DomainBundle
 
 describe('parseIntrospectTarget', () => {
   test('accepts a bare origin', () => {
@@ -18,4 +56,45 @@ describe('parseIntrospectTarget', () => {
   test('rejects an @id', () => {
     expect(() => parseIntrospectTarget('@abc')).toThrow('not an @id')
   })
+
+  test('routes bare, bundle, Method, and Function commands through the current Schema API', async () => {
+    const calls: string[] = []
+    const schema = {
+      inspect: async (origin: string) => {
+        calls.push(`inspect:${origin}`)
+        return info
+      },
+      bundle: async (origin: string) => {
+        calls.push(`bundle:${origin}`)
+        return bundled
+      },
+    }
+    const results: unknown[] = []
+    const runKernelCommand = async (input: {
+      fn: (context: unknown) => Promise<unknown>
+    }): Promise<void> => {
+      results.push(await input.fn({ session: { schema } }))
+    }
+    const dependencies = { runKernelCommand: runKernelCommand as never }
+
+    await introspectCommand('host.astrale.ai', { json: true }, dependencies)
+    await introspectCommand('host.astrale.ai', { bundle: true, json: true }, dependencies)
+    await introspectCommand(
+      '/:host.astrale.ai:class.Manager:createInstance',
+      { json: true },
+      dependencies,
+    )
+    await introspectCommand('/:host.astrale.ai:function.journal', { json: true }, dependencies)
+
+    expect(results[0]).toBe(info)
+    expect(results[1]).toBe(bundled)
+    expect(results[2]).toMatchObject({ class: 'Manager', method: 'createInstance' })
+    expect(results[3]).toMatchObject({ function: 'journal' })
+    expect(calls).toEqual([
+      'inspect:host.astrale.ai',
+      'bundle:host.astrale.ai',
+      'bundle:host.astrale.ai',
+      'bundle:host.astrale.ai',
+    ])
+  })
 })

package/src/commands/domain/install.ts

@@ -1,11 +1,11 @@
-import { Path } from '@astrale-os/sdk/graph/path'
-import { K } from '@astrale-os/sdk/schema'
+import type { InstallRequest, InstallResult, OperationId } from '@astrale-os/sdk/client/schema'
+
 import chalk from 'chalk'
 
 import type { KernelCommandOpts } from '../../connection'
 import type { CommandDefinition } from '../../program/index'
 
-import { createPathCall, runKernelCommand, withAdminClientSession } from '../../connection'
+import { runKernelCommand, withAdminClientSession } from '../../connection'
 import { formatKernelError } from '../../connection/errors'
 import { AstraleError } from '../../errors'
 import {
@@ -23,35 +23,61 @@ import { confirmWithInput, promptText, selectFrom } from '../../lib/prompt'
 import { isHttpUrl } from '../../lib/validation'
 
 /** Public Kernel install syscall input for one remote URL. */
-export function directInstallCallInput(url: string, operation: string, token?: string) {
+export function directInstallCallInput(
+  url: string,
+  operation: string,
+  token?: string,
+): InstallRequest {
+  const domain = Object.freeze({
+    publication: Object.freeze({
+      url,
+      ...(token === undefined ? {} : { token }),
+    }),
+  })
   return Object.freeze({
-    operation,
-    domains: [
-      Object.freeze({
-        source: Object.freeze({
-          kind: 'remote' as const,
-          url,
-          ...(token === undefined ? {} : { token }),
-        }),
-      }),
-    ],
+    operation: acceptOperationId(operation),
+    domains: Object.freeze([domain] as const),
   })
 }
 
-type DirectInstallResult = {
+export interface DirectInstallPresentation {
   readonly operation: string
-  readonly transitions: readonly {
-    readonly intent: {
-      readonly origin: string
-      readonly target?: { readonly schemaRevision?: string } | null
+  readonly origin: string
+  readonly revision: string
+  readonly status: 'installed' | 'already current'
+}
+
+/** Stable CLI presentation derived from the canonical binary install result. */
+export function directInstallPresentation(
+  result: InstallResult,
+  requestedOperation: string,
+): DirectInstallPresentation {
+  if (result.changed) {
+    const installed = result.receipt.transitions[0]?.intent
+    if (!installed) throw new Error('Kernel install returned no committed Domain transition.')
+    if (!installed.generation) {
+      throw new Error('Kernel install returned a committed transition without a Domain generation.')
     }
-  }[]
+    return Object.freeze({
+      operation: result.receipt.operation,
+      origin: installed.origin,
+      revision: installed.generation.revision,
+      status: 'installed' as const,
+    })
+  }
+  const installed = result.domains[0]
+  return Object.freeze({
+    operation: requestedOperation,
+    origin: installed.origin,
+    revision: installed.revision,
+    status: 'already current' as const,
+  })
 }
 
 const OPERATION_ID_PATTERN =
   /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u
 
-function acceptOperationId(input: unknown): string {
+function acceptOperationId(input: unknown): OperationId {
   if (typeof input !== 'string' || !OPERATION_ID_PATTERN.test(input)) {
     throw new AstraleError(
       'INVALID_FLAG',
@@ -59,10 +85,10 @@ function acceptOperationId(input: unknown): string {
       'Omit --operation for a fresh install; use it only with the exact UUID printed for recovery.',
     )
   }
-  return input
+  return input as OperationId
 }
 
-function createOperationId(): string {
+function createOperationId(): OperationId {
   return acceptOperationId(globalThis.crypto.randomUUID())
 }
 
@@ -407,27 +433,20 @@ export async function installDirect(
   const url = target as string
   const retry = directInstallRetry(url, operation, opts)
 
-  await direct.runKernelCommand<DirectInstallResult>({
+  await direct.runKernelCommand<InstallResult>({
     opts,
     label: `Installing domain from ${url} (operation ${operation})`,
     recovery: { operation, retry },
     fn: async ({ session }) =>
-      (await session.call(
-        createPathCall(
-          Path.project(K.functions.install.ref).raw,
-          directInstallCallInput(url, operation, opts.token),
-        ),
-      )) as DirectInstallResult,
+      session.schema.install(directInstallCallInput(url, operation, opts.token)),
     format: (result, fmtOpts, isRaw) => {
       if (isRaw) {
         output(result, fmtOpts)
         return
       }
-      const installed = result.transitions[0]?.intent
-      if (!installed) throw new Error('Kernel install returned no committed Domain transition.')
-      const revision = installed.target?.schemaRevision ?? result.operation
-      log.success(`Domain installed: ${installed.origin}@${revision}`)
-      log.dim(`  operation:   ${result.operation}`)
+      const installed = directInstallPresentation(result, operation)
+      log.success(`Domain ${installed.status}: ${installed.origin}@${installed.revision}`)
+      log.dim(`  operation:   ${installed.operation}`)
       // Belt-and-braces: the kernel-confirmed origin is authoritative. If it
       // aliases the host and the pre-install gate never consented to THAT
       // origin (lying or unavailable Publication), say so loudly after the fact.

package/src/commands/introspect.ts

@@ -1,3 +1,5 @@
+import type { DomainBundle, DomainInfo, SchemaApi } from '@astrale-os/sdk/client/schema'
+
 import { Path } from '@astrale-os/sdk/graph/path'
 
 import type { KernelCommandOpts } from '../connection'
@@ -11,7 +13,18 @@ import { describeCallableFromBundle, missingCallableDescription } from './call-d
 
 type IntrospectOpts = KernelCommandOpts & { bundle?: boolean }
 
-export async function introspectCommand(target: string, opts: IntrospectOpts): Promise<void> {
+interface IntrospectDependencies {
+  readonly runKernelCommand: typeof runKernelCommand
+}
+
+const defaultIntrospectDependencies = Object.freeze({ runKernelCommand })
+
+export async function introspectCommand(
+  target: string,
+  opts: IntrospectOpts,
+  dependencies: Partial<IntrospectDependencies> = {},
+): Promise<void> {
+  const introspect = { ...defaultIntrospectDependencies, ...dependencies }
   let origin: string
   let path: Path
   try {
@@ -21,30 +34,14 @@ export async function introspectCommand(target: string, opts: IntrospectOpts): P
   }
   const wantsCallable = isCallablePath(path)
 
-  await runKernelCommand({
+  await introspect.runKernelCommand({
     opts,
     label: `Introspect ${origin}`,
     fn: async ({ session }) => {
       const includeBundle = wantsCallable || opts.bundle === true
-      const result = await session.schema.introspect({
-        from: { kind: 'installation', origin },
-        select: {
-          state: true,
-          target: true,
-          source: true,
-          readiness: true,
-          capabilities: true,
-          ...(includeBundle ? { bundle: true as const } : {}),
-        },
-      })
-      if (result === null) {
-        throw new AstraleError(
-          'DOMAIN_NOT_INSTALLED',
-          `Domain ${origin} is not installed on this Kernel.`,
-        )
-      }
+      const result = await readInstalledDomain(session.schema, origin, includeBundle)
       if (wantsCallable) {
-        const described = describeCallableFromBundle(path, result.bundle)
+        const described = describeCallableFromBundle(path, (result as DomainBundle).bundle)
         if (described === undefined) throw missingCallableDescription(path.raw)
         return described
       }
@@ -54,6 +51,29 @@ export async function introspectCommand(target: string, opts: IntrospectOpts): P
   })
 }
 
+export function readInstalledDomain(
+  schema: Pick<SchemaApi, 'inspect' | 'bundle'>,
+  origin: string,
+  includeBundle: true,
+): Promise<DomainBundle>
+export function readInstalledDomain(
+  schema: Pick<SchemaApi, 'inspect' | 'bundle'>,
+  origin: string,
+  includeBundle: false,
+): Promise<DomainInfo>
+export function readInstalledDomain(
+  schema: Pick<SchemaApi, 'inspect' | 'bundle'>,
+  origin: string,
+  includeBundle: boolean,
+): Promise<DomainInfo | DomainBundle>
+export function readInstalledDomain(
+  schema: Pick<SchemaApi, 'inspect' | 'bundle'>,
+  origin: string,
+  includeBundle: boolean,
+): Promise<DomainInfo | DomainBundle> {
+  return includeBundle ? schema.bundle(origin) : schema.inspect(origin)
+}
+
 export function parseIntrospectTarget(target: string): { origin: string; path: Path } {
   if (target.startsWith('@')) {
     throw new AstraleError(

package/studio/package.json

@@ -21,7 +21,7 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@astrale-os/sdk": "0.5.0-beta.38",
+    "@astrale-os/sdk": "0.5.0-beta.49",
     "@astrale-os/shell": "0.4.2-beta.3",
     "@dagrejs/dagre": "^3.0.0",
     "@radix-ui/react-collapsible": "^1.1.0",