@astrale-os/cli 1.0.0-beta.1 → 1.0.0-beta.10

package/src/admin/catalog/client.ts

@@ -1,11 +1,19 @@
-import type { DomainBinding } from '@astrale-os/kernel-client/domain'
-import type { ClientSession } from '@astrale-os/kernel-client/session'
+import type { ClientSession } from '@astrale-os/sdk/client/session'
 import type { Node } from '@astrale-os/sdk/graph/node'
+import type { ResolvedClass } from '@astrale-os/sdk/schema'
 
-import { bind } from '@astrale-os/kernel-client/domain'
 import { Path } from '@astrale-os/sdk/graph/path'
 import { Query } from '@astrale-os/sdk/query'
 
+import {
+  bindAdmin,
+  invokeAdminMethod,
+  requireAdminBinding,
+  requireAdminClass,
+  requireAdminCore,
+  requireAdminProperty,
+  type AdminBinding,
+} from '../binding'
 import { readAllNodes, type AdminGraphApi } from '../graph'
 import {
   AdminDomainNotFoundError,
@@ -14,16 +22,9 @@ import {
   type PublishDomainResult,
 } from './model'
 
-const ADMIN_ORIGIN = 'admin.astrale.ai'
 const PAGE_SIZE = 256
 const MAXIMUM_DOMAINS = 10_000
 const MAXIMUM_PAGES = Math.ceil(MAXIMUM_DOMAINS / PAGE_SIZE) + 1
-const DomainRef = Object.freeze({ origin: ADMIN_ORIGIN, kind: 'class' as const, name: 'Domain' })
-const fleetInstallsByDefault = Object.freeze({
-  origin: ADMIN_ORIGIN,
-  kind: 'class' as const,
-  name: 'fleet_installs_domain_by_default',
-})
 
 export interface AdminCatalogContext {
   readonly session: ClientSession
@@ -37,7 +38,7 @@ export interface AdminCatalogApi {
 }
 
 export interface AdminCatalogDependencies {
-  readonly bind?: (session: ClientSession) => Promise<DomainBinding>
+  readonly bind?: (session: ClientSession) => Promise<AdminBinding>
   readonly operationId?: (kind: 'publish' | 'configure-default') => string
 }
 
@@ -46,21 +47,22 @@ export async function connectAdminCatalog(
   context: AdminCatalogContext,
   dependencies: AdminCatalogDependencies = {},
 ): Promise<AdminCatalogApi> {
-  const binding = await (dependencies.bind ?? bindInstalledAdmin)(context.session)
-  if (binding.$.publication?.origin !== ADMIN_ORIGIN || binding.$.origin !== ADMIN_ORIGIN) {
-    throw new TypeError('Configured Admin target does not serve the Admin Domain.')
-  }
-  const Domain = binding.$.class('Domain')
-  const Fleet = binding.$.class('Fleet')
-  const fleet = binding.$.core.nodes.fleet?.path
-  if (fleet === undefined) throw new TypeError('Admin Domain has no singleton Fleet receiver.')
+  const binding = requireAdminBinding(await (dependencies.bind ?? bindAdmin)(context.session))
+  const Domain = requireAdminClass(binding, 'Domain', 'node')
+  const Fleet = requireAdminClass(binding, 'Fleet', 'node')
+  const fleetInstallsByDefault = requireAdminClass(
+    binding,
+    'fleet_installs_domain_by_default',
+    'edge',
+  )
+  const fleet = requireAdminCore(binding, 'fleet')
   const operationId = dependencies.operationId ?? defaultOperationId
 
   const list = async (): Promise<DomainInfo[]> => {
     const [nodes, defaultsPage] = await Promise.all([
       readAllNodes(
         context.graph,
-        Query.from({ kind: 'node', definitions: [DomainRef] }).select({
+        Query.from({ nodes: [Domain] }).select({
           kind: 'nodes',
           projection: { kind: 'value' },
         }),
@@ -108,13 +110,13 @@ export async function connectAdminCatalog(
       let entry = existing
       if (registryChanged) {
         entry = domainFromSummary(
-          await binding.$.invoke(Fleet.$.method('publishDomain') as never, fleet, {
+          await invokeAdminMethod(context.session, binding, Fleet, 'publishDomain', fleet, {
             operationId: operationId('publish'),
             origin: input.origin,
             name: input.name,
             discoveryUrl: input.url,
             ...(description === undefined ? {} : { description }),
-          } as never),
+          }),
           existing?.installByDefault === true,
         )
       }
@@ -125,13 +127,16 @@ export async function connectAdminCatalog(
         (entry.installByDefault ?? false) !== input.installByDefault
       if (defaultChanged) {
         entry = domainFromSummary(
-          await binding.$.invoke(
-            Domain.$.method('configureDefault') as never,
+          await invokeAdminMethod(
+            context.session,
+            binding,
+            Domain,
+            'configureDefault',
             Path.parse(entry.id),
             {
               operationId: operationId('configure-default'),
               enabled: input.installByDefault,
-            } as never,
+            },
           ),
           input.installByDefault === true,
         )
@@ -145,11 +150,7 @@ export async function connectAdminCatalog(
   })
 }
 
-async function bindInstalledAdmin(session: ClientSession): Promise<DomainBinding> {
-  return bind(session, await session.installed(ADMIN_ORIGIN))
-}
-
-type DynamicDefinition = ReturnType<DomainBinding['$']['class']>
+type DynamicDefinition = ResolvedClass<'node'>
 
 function domainFromNode(
   definition: DynamicDefinition,
@@ -185,7 +186,10 @@ function domainFromSummary(input: unknown, installByDefault: boolean): DomainInf
 }
 
 function requiredProperty(definition: DynamicDefinition, node: Node, name: string): string {
-  return requiredString(node.props[definition.$.property(name).key], `Admin Domain.${name}`)
+  return requiredString(
+    node.props[requireAdminProperty(definition, name).key],
+    `Admin Domain.${name}`,
+  )
 }
 
 function optionalProperty(
@@ -193,7 +197,7 @@ function optionalProperty(
   node: Node,
   name: string,
 ): Readonly<Record<string, string>> {
-  const value = node.props[definition.$.property(name).key]
+  const value = node.props[requireAdminProperty(definition, name).key]
   return value === undefined ? {} : { [name]: requiredString(value, `Admin Domain.${name}`) }
 }
 

package/src/admin/catalog/model.ts

@@ -33,10 +33,9 @@ export interface InstallDomainResult {
   readonly error?: string | null
 }
 
-export class AdminDomainNotFoundError extends Error {
-  readonly name = 'NotFoundError'
-
+export class AdminDomainNotFoundError extends AstraleError {
   constructor(readonly identifier: string) {
-    super(`No visible Admin Domain matches ${JSON.stringify(identifier)}.`)
+    super('DOMAIN_NOT_FOUND', `No visible Admin Domain matches ${JSON.stringify(identifier)}.`)
   }
 }
+import { AstraleError } from '../../errors'

package/src/admin/graph/.spec/api.d.ts

@@ -1,18 +1,12 @@
-import type { GraphQueryOptions, NeighborsOptions, NodePage } from '@astrale-os/kernel-client/graph'
-import type { ClassPath } from '@astrale-os/sdk/graph/class'
+import type { GraphApi } from '@astrale-os/sdk/client'
 import type { Node } from '@astrale-os/sdk/graph/node'
-import type { PathLike } from '@astrale-os/sdk/graph/path'
-import type { QueryAST, QueryResult } from '@astrale-os/sdk/query'
+import type { QueryAST } from '@astrale-os/sdk/query'
 
 /** Smallest Kernel graph capability needed by bounded Admin graph reads. */
-export interface AdminGraphQueryApi {
-  query(ast: QueryAST, options?: GraphQueryOptions): Promise<QueryResult>
-}
+export type AdminGraphQueryApi = Pick<GraphApi, 'query'>
 
 /** Caller-scoped graph reads shared by the Admin catalog and Instance journeys. */
-export interface AdminGraphApi extends AdminGraphQueryApi {
-  neighbors(source: PathLike, edge: ClassPath, options: NeighborsOptions): Promise<NodePage>
-}
+export type AdminGraphApi = Pick<GraphApi, 'query' | 'neighbors'>
 
 export interface ReadAllNodesOptions {
   readonly label: string

package/src/admin/graph/nodes.ts

@@ -1,4 +1,4 @@
-import type { GraphApi } from '@astrale-os/kernel-client/graph'
+import type { GraphApi } from '@astrale-os/sdk/client'
 import type { Node } from '@astrale-os/sdk/graph/node'
 import type { QueryAST } from '@astrale-os/sdk/query'
 

package/src/admin/instance/.spec/api.d.ts

@@ -1,5 +1,5 @@
-import type { DomainBinding } from '@astrale-os/kernel-client/domain'
-import type { ClientSession } from '@astrale-os/kernel-client/session'
+import type { ClientSession } from '@astrale-os/sdk/client/session'
+import type { DomainBinding } from '@astrale-os/shell'
 
 import type { AdminGraphApi } from '../../graph/.spec/api.js'
 

package/src/admin/instance/__tests__/client.test.ts

@@ -1,103 +1,28 @@
-import type { DomainBinding } from '@astrale-os/kernel-client/domain'
-import type { Node } from '@astrale-os/sdk/graph/node'
-import type { QueryAST } from '@astrale-os/sdk/query'
-
-import { ClassPath } from '@astrale-os/sdk/graph/class'
-import { NodeId } from '@astrale-os/sdk/graph/node'
-import { Path } from '@astrale-os/sdk/graph/path'
-import { describe, expect, mock, test } from 'bun:test'
-
-import type { AdminGraphApi } from '../../graph'
+import { describe, expect, test } from 'bun:test'
 
+import { adminBinding, adminSession } from '../../__tests__/fixture'
 import { connectAdminInstances } from '../client'
 
-const methods: Array<{ owner: string; name: string }> = []
-
-function definition(name: string) {
-  return {
-    name,
-    $: {
-      method(method: string) {
-        const value = { owner: name, name: method }
-        methods.push(value)
-        return value
-      },
-      property(property: string) {
-        return { key: property }
-      },
-    },
-  }
-}
-
-function node(id: string, props: Record<string, unknown>): Node {
-  return {
-    id: NodeId(id),
-    class: ClassPath.from('admin.astrale.ai', 'Instance'),
-    props: props as never,
-  }
-}
-
-function graphResult(nodes: readonly Node[], cursor?: string) {
-  return {
-    result: {
-      kind: 'nodes' as const,
-      nodes: nodes.map((value) => ({ kind: 'value' as const, value })),
-    },
-    page: cursor === undefined ? {} : { next: cursor },
-  }
-}
-
-function sourceName(ast: QueryAST): string | undefined {
-  const term = ast.source.terms[0]
-  return term?.kind === 'definition' ? term.definition.name : undefined
-}
-
 function fixture(input: {
-  instances?: readonly Node[]
-  hosts?: readonly Node[]
-  reserved?: Node | null
   invoke?: (method: { owner: string; name: string }, receiver: unknown, input: unknown) => unknown
 }) {
-  methods.length = 0
-  const Instance = definition('Instance')
-  const Host = definition('Host')
-  const Fleet = definition('Fleet')
-  const invoke = mock(async (method: unknown, receiver: unknown, value: unknown) =>
-    input.invoke?.(method as { owner: string; name: string }, receiver, value),
-  )
-  const binding = {
-    $: {
-      publication: { origin: 'admin.astrale.ai' },
-      origin: 'admin.astrale.ai',
-      class(name: string) {
-        if (name === 'Instance') return Instance
-        if (name === 'Host') return Host
-        if (name === 'Fleet') return Fleet
-        throw new Error(`Unexpected class ${name}`)
-      },
-      core: { nodes: { fleet: { path: Path.id(NodeId('fleet')) } } },
-      invoke,
-    },
-  } as unknown as DomainBinding
-  const query = mock(async (ast: QueryAST) => {
-    const name = sourceName(ast)
-    if (name === 'Instance') return graphResult(input.instances ?? [])
-    if (name === 'Host') return graphResult(input.hosts ?? [])
-    throw new Error(`Unexpected graph query ${String(name)}`)
+  const calls: Array<{
+    method: { owner: string; name: string }
+    receiver: string
+    value: unknown
+  }> = []
+  const remote = adminSession((method, receiver, value) => {
+    calls.push({ method, receiver: String(receiver), value })
+    return input.invoke?.(method, receiver, value)
   })
-  const neighbors = mock(async (source: unknown, edge: { name?: string }) => {
-    if (String(source) === '@fleet') return page(input.reserved ?? null)
-    if (edge.name === 'instance_runs_on_host') return page(input.hosts?.[0] ?? null)
-    throw new Error(`Unexpected neighbor query ${String(source)} ${String(edge)}`)
-  })
-  const graph = { query, neighbors } as unknown as AdminGraphApi
+  const binding = adminBinding()
   return {
     binding,
-    graph,
-    invoke,
+    invoke: remote.invoke,
+    calls,
     connect: () =>
       connectAdminInstances(
-        { session: {} as never, graph },
+        { session: remote.session },
         {
           bind: async () => binding,
           operationId: (kind) => `cli.instance.${kind}:test`,
@@ -106,15 +31,6 @@ function fixture(input: {
   }
 }
 
-function page(item: Node | null) {
-  return {
-    nodes: item === null ? [] : [item],
-    first: item,
-    graph: { nodes: item === null ? [] : [item], edges: [] },
-    cursor: null,
-  }
-}
-
 describe('V2 Admin Instance adapter', () => {
   test('lists caller-visible Instances through the Admin-owned Fleet operation', async () => {
     const contract = fixture({
@@ -128,8 +44,6 @@ describe('V2 Admin Instance adapter', () => {
                 state: 'ready',
                 createdAt: '2026-08-12T00:00:00.000Z',
                 updatedAt: '2026-08-12T00:00:00.000Z',
-                hostId: '@host-node',
-                region: 'fr-par',
               },
             ]
           : undefined,
@@ -142,15 +56,15 @@ describe('V2 Admin Instance adapter', () => {
         url: 'https://demo.eu.astrale.ai',
         state: 'ready',
         createdAt: '2026-08-12T00:00:00.000Z',
-        hostId: '@host-node',
-        region: 'fr-par',
       },
     ])
-    expect(contract.invoke).toHaveBeenCalledWith(
-      expect.objectContaining({ owner: 'Fleet', name: 'listInstances' }),
-      Path.id(NodeId('fleet')),
-      {},
-    )
+    expect(contract.calls).toEqual([
+      {
+        method: { owner: 'Fleet', name: 'listInstances' },
+        receiver: '/:admin.astrale.ai:core.fleet::listInstances',
+        value: {},
+      },
+    ])
   })
 
   test('delegates default placement to Fleet without reading Host inventory', async () => {
@@ -162,10 +76,7 @@ describe('V2 Admin Instance adapter', () => {
       createdAt: '2026-08-12T00:00:00.000Z',
       updatedAt: '2026-08-12T00:00:00.000Z',
     }
-    const contract = fixture({
-      hosts: [node('host-node', { id: 'host-paris', state: 'ready' })],
-      invoke: () => created,
-    })
+    const contract = fixture({ invoke: () => created })
 
     await expect((await contract.connect()).create('demo')).resolves.toMatchObject({
       id: created.id,
@@ -174,47 +85,17 @@ describe('V2 Admin Instance adapter', () => {
       state: created.state,
       createdAt: created.createdAt,
     })
-    expect(contract.invoke).toHaveBeenCalledWith(
-      expect.objectContaining({ owner: 'Fleet', name: 'createInstance' }),
-      Path.id(NodeId('fleet')),
-      { operationId: 'cli.instance.create:test', slug: 'demo' },
-    )
-    expect(contract.graph.query).not.toHaveBeenCalled()
-    expect(contract.graph.neighbors).not.toHaveBeenCalled()
-  })
-
-  test('resolves --host-id to an exact Host receiver and rejects the reserved Admin Host', async () => {
-    const reserved = node('admin-host', { id: 'admin', state: 'ready' })
-    const consumer = node('consumer-host', { id: 'consumer-paris', state: 'ready' })
-    const contract = fixture({
-      hosts: [reserved, consumer],
-      reserved,
-      invoke: () => ({
-        id: '@instance-node',
-        slug: 'demo',
-        url: 'https://demo.eu.astrale.ai',
-        state: 'ready',
-      }),
-    })
-    const api = await contract.connect()
-
-    await expect(api.create('demo', 'admin')).rejects.toMatchObject({ name: 'NotFoundError' })
-    await expect(api.create('demo', 'consumer-paris')).resolves.toMatchObject({ slug: 'demo' })
-    expect(contract.invoke).toHaveBeenCalledWith(
-      expect.objectContaining({ owner: 'Host', name: 'createInstance' }),
-      Path.id(NodeId('consumer-host')),
-      { operationId: 'cli.instance.create:test', slug: 'demo' },
-    )
+    expect(contract.calls).toEqual([
+      {
+        method: { owner: 'Fleet', name: 'createInstance' },
+        receiver: '/:admin.astrale.ai:core.fleet::createInstance',
+        value: { operationId: 'cli.instance.create:test', slug: 'demo' },
+      },
+    ])
   })
 
   test('refreshes and deletes through the resolved Instance receiver', async () => {
-    const instance = node('instance-node', {
-      slug: 'demo',
-      url: 'https://demo.eu.astrale.ai',
-      state: 'ready',
-    })
     const contract = fixture({
-      instances: [instance],
       invoke: (method) =>
         method.name === 'listInstances'
           ? [
@@ -238,22 +119,16 @@ describe('V2 Admin Instance adapter', () => {
 
     await expect(api.status('demo')).resolves.toMatchObject({ state: 'ready' })
     await expect(api.delete('@instance-node')).resolves.toMatchObject({ state: 'deleted' })
-    expect(contract.invoke.mock.calls.map(([method]) => method)).toEqual([
-      expect.objectContaining({ owner: 'Fleet', name: 'listInstances' }),
-      expect.objectContaining({ owner: 'Instance', name: 'status' }),
-      expect.objectContaining({ owner: 'Fleet', name: 'listInstances' }),
-      expect.objectContaining({ owner: 'Instance', name: 'delete' }),
+    expect(contract.calls.map(({ method }) => method)).toEqual([
+      { owner: 'Fleet', name: 'listInstances' },
+      { owner: 'Instance', name: 'status' },
+      { owner: 'Fleet', name: 'listInstances' },
+      { owner: 'Instance', name: 'delete' },
     ])
   })
 
   test('installs a resolved catalog Domain through Instance.installDomain', async () => {
-    const instance = node('instance-node', {
-      slug: 'demo',
-      url: 'https://demo.eu.astrale.ai',
-      state: 'ready',
-    })
     const contract = fixture({
-      instances: [instance],
       invoke: (method) =>
         method.name === 'listInstances'
           ? [
@@ -282,10 +157,10 @@ describe('V2 Admin Instance adapter', () => {
       origin: 'crm.acme.dev',
       ok: true,
     })
-    expect(contract.invoke).toHaveBeenCalledWith(
-      expect.objectContaining({ owner: 'Instance', name: 'installDomain' }),
-      Path.id(NodeId('instance-node')),
-      { operationId: 'cli.instance.install-domain:test', domain: '@crm-domain' },
-    )
+    expect(contract.calls.at(-1)).toEqual({
+      method: { owner: 'Instance', name: 'installDomain' },
+      receiver: '@instance-node::installDomain',
+      value: { operationId: 'cli.instance.install-domain:test', domain: '@crm-domain' },
+    })
   })
 })