@astrale-os/cli 1.0.0-beta.3 → 1.0.0-beta.30

package/src/admin/catalog/client.ts

@@ -1,10 +1,10 @@
-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 { Path } from '@astrale-os/sdk/graph/path'
 import { Query } from '@astrale-os/sdk/query'
 
-import { bindAdmin, type AdminBinding } from '../binding'
+import { AdminContract, callAdminMethod } from '../contract'
 import { readAllNodes, type AdminGraphApi } from '../graph'
 import {
   AdminDomainNotFoundError,
@@ -13,16 +13,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
@@ -36,30 +29,21 @@ export interface AdminCatalogApi {
 }
 
 export interface AdminCatalogDependencies {
-  readonly bind?: (session: ClientSession) => Promise<AdminBinding>
   readonly operationId?: (kind: 'publish' | 'configure-default') => string
 }
 
-/** Bind the discovered Admin revision and expose its Domain catalog journey. */
+/** Connect the Domain catalog journey without schema discovery or reflection. */
 export async function connectAdminCatalog(
   context: AdminCatalogContext,
   dependencies: AdminCatalogDependencies = {},
 ): Promise<AdminCatalogApi> {
-  const binding = await (dependencies.bind ?? bindAdmin)(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 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: [AdminContract.classes.Domain] }).select({
           kind: 'nodes',
           projection: { kind: 'value' },
         }),
@@ -69,16 +53,20 @@ export async function connectAdminCatalog(
           maximumPages: MAXIMUM_PAGES,
         },
       ),
-      context.graph.neighbors(fleet, fleetInstallsByDefault, {
-        direction: 'outgoing',
-        page: { size: PAGE_SIZE },
-      }),
+      context.graph.neighbors(
+        AdminContract.fleet,
+        AdminContract.edges.fleetInstallsDomainByDefault,
+        {
+          direction: 'outgoing',
+          page: { size: PAGE_SIZE },
+        },
+      ),
     ])
     const defaults = await defaultsPage.collect({ maximumPages: MAXIMUM_PAGES })
     if (defaults.cursor !== null)
       throw new TypeError('Admin default Domain catalog exceeded its bound.')
     const defaultIds = new Set(defaults.nodes.map((node) => String(node.id)))
-    return nodes.map((node) => domainFromNode(Domain, node, defaultIds.has(String(node.id))))
+    return nodes.map((node) => domainFromNode(node, defaultIds.has(String(node.id))))
   }
 
   const requireDomain = async (identifier: string): Promise<DomainInfo> => {
@@ -107,13 +95,13 @@ export async function connectAdminCatalog(
       let entry = existing
       if (registryChanged) {
         entry = domainFromSummary(
-          await binding.$.invoke(Fleet.$.method('publishDomain') as never, fleet, {
+          await callAdminMethod(context.session, AdminContract.fleet, 'publishDomain', {
             operationId: operationId('publish'),
             origin: input.origin,
             name: input.name,
             discoveryUrl: input.url,
             ...(description === undefined ? {} : { description }),
-          } as never),
+          }),
           existing?.installByDefault === true,
         )
       }
@@ -124,14 +112,10 @@ export async function connectAdminCatalog(
         (entry.installByDefault ?? false) !== input.installByDefault
       if (defaultChanged) {
         entry = domainFromSummary(
-          await binding.$.invoke(
-            Domain.$.method('configureDefault') as never,
-            Path.parse(entry.id),
-            {
-              operationId: operationId('configure-default'),
-              enabled: input.installByDefault,
-            } as never,
-          ),
+          await callAdminMethod(context.session, Path.parse(entry.id), 'configureDefault', {
+            operationId: operationId('configure-default'),
+            enabled: input.installByDefault,
+          }),
           input.installByDefault === true,
         )
       }
@@ -144,29 +128,23 @@ export async function connectAdminCatalog(
   })
 }
 
-type DynamicDefinition = ReturnType<AdminBinding['$']['class']>
-
-function domainFromNode(
-  definition: DynamicDefinition,
-  node: Node,
-  installByDefault: boolean,
-): DomainInfo {
+function domainFromNode(node: Node, installByDefault: boolean): DomainInfo {
   return Object.freeze({
     id: Path.id(node.id).raw,
-    origin: requiredProperty(definition, node, 'origin'),
-    name: requiredProperty(definition, node, 'name'),
-    url: requiredProperty(definition, node, 'discoveryUrl'),
-    ...optionalProperty(definition, node, 'description'),
+    origin: requiredProperty(node, 'origin'),
+    name: requiredProperty(node, 'name'),
+    url: requiredProperty(node, 'discoveryUrl'),
+    ...optionalProperty(node, 'description'),
     ...(installByDefault ? { installByDefault: true } : {}),
-    createdAt: requiredProperty(definition, node, 'createdAt'),
-    updatedAt: requiredProperty(definition, node, 'updatedAt'),
+    createdAt: requiredProperty(node, 'createdAt'),
+    updatedAt: requiredProperty(node, 'updatedAt'),
   })
 }
 
 function domainFromSummary(input: unknown, installByDefault: boolean): DomainInfo {
   const value = record(input, 'Admin Domain summary')
   return Object.freeze({
-    id: requiredString(value.id, 'Admin Domain id'),
+    id: requiredNodePath(value.id, 'Admin Domain id'),
     origin: requiredString(value.origin, 'Admin Domain origin'),
     name: requiredString(value.name, 'Admin Domain name'),
     url: requiredString(value.discoveryUrl, 'Admin Domain discovery URL'),
@@ -179,16 +157,15 @@ 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}`)
+function requiredProperty(node: Node, name: keyof typeof AdminContract.properties.domain): string {
+  return requiredString(node.props[AdminContract.properties.domain[name]], `Admin Domain.${name}`)
 }
 
 function optionalProperty(
-  definition: DynamicDefinition,
   node: Node,
-  name: string,
+  name: keyof typeof AdminContract.properties.domain,
 ): Readonly<Record<string, string>> {
-  const value = node.props[definition.$.property(name).key]
+  const value = node.props[AdminContract.properties.domain[name]]
   return value === undefined ? {} : { [name]: requiredString(value, `Admin Domain.${name}`) }
 }
 
@@ -197,6 +174,15 @@ function requiredString(input: unknown, label: string): string {
   return input
 }
 
+function requiredNodePath(input: unknown, label: string): string {
+  const value = requiredString(input, label)
+  try {
+    return Path.parse(value).raw
+  } catch {
+    throw new TypeError(`${label} is invalid.`)
+  }
+}
+
 function record(input: unknown, label: string): Readonly<Record<string, unknown>> {
   if (typeof input !== 'object' || input === null || Array.isArray(input)) {
     throw new TypeError(`${label} is invalid.`)

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/contract.ts

@@ -0,0 +1,47 @@
+import type { Input } from '@astrale-os/sdk/client'
+import type { ClientSession, SessionRequestOptions } from '@astrale-os/sdk/client/session'
+import type { ClassRef } from '@astrale-os/sdk/schema'
+
+import { call } from '@astrale-os/sdk/client'
+import { Path } from '@astrale-os/sdk/graph/path'
+import { K, PropertyKey } from '@astrale-os/sdk/schema'
+
+const origin = 'admin.astrale.ai'
+
+function classRef(name: string): ClassRef {
+  return Object.freeze({ origin, kind: 'class', name }) as ClassRef
+}
+
+const Domain = classRef('Domain')
+
+export const AdminContract = Object.freeze({
+  origin,
+  fleet: Path.parse('/:admin.astrale.ai:core.fleet'),
+  classes: Object.freeze({
+    Domain,
+  }),
+  edges: Object.freeze({
+    fleetInstallsDomainByDefault: classRef('fleet_installs_domain_by_default'),
+  }),
+  properties: Object.freeze({
+    domain: Object.freeze({
+      origin: PropertyKey.of(Domain, 'origin'),
+      name: K.classes.Named.properties.name.key,
+      discoveryUrl: PropertyKey.of(Domain, 'discoveryUrl'),
+      description: K.classes.Descriptable.properties.description.key,
+      createdAt: K.classes.Timestamped.properties.createdAt.key,
+      updatedAt: K.classes.Timestamped.properties.updatedAt.key,
+    }),
+  }),
+})
+
+/** Invoke one stable Admin instance Method without schema discovery or reflection. */
+export function callAdminMethod(
+  session: ClientSession,
+  receiver: Path,
+  method: string,
+  input: Input,
+  options?: SessionRequestOptions,
+): Promise<unknown> {
+  return session.call(call(Path.instanceMethod(receiver, method), input), options)
+}

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,7 +1,4 @@
-import type { DomainBinding } from '@astrale-os/kernel-client/domain'
-import type { ClientSession } from '@astrale-os/kernel-client/session'
-
-import type { AdminGraphApi } from '../../graph/.spec/api.js'
+import type { ClientSession } from '@astrale-os/sdk/client/session'
 
 export type InstanceState = 'provisioning' | 'ready' | 'deleting' | 'failed' | 'deleted'
 
@@ -11,10 +8,11 @@ export interface InstanceInfo {
   readonly url: string
   readonly hostId?: string
   readonly region?: string
-  readonly state?: InstanceState
+  readonly state: InstanceState
   readonly phase?: string
   readonly error?: string | null
   readonly createdAt?: string
+  readonly updatedAt?: string
   readonly organizationId?: string
 }
 
@@ -33,12 +31,11 @@ export interface DomainInstallReceipt {
 
 export interface AdminInstanceContext {
   readonly session: ClientSession
-  readonly graph: AdminGraphApi
 }
 
 export interface AdminInstanceApi {
   list(): Promise<OwnedInstanceInfo[]>
-  create(slug: string, hostId?: string): Promise<InstanceInfo>
+  create(slug: string): Promise<InstanceInfo>
   status(identifier: string): Promise<InstanceInfo>
   delete(identifier: string): Promise<InstanceInfo>
   installDomain(identifier: string, domain: string): Promise<DomainInstallReceipt>
@@ -51,7 +48,6 @@ export class AdminInstanceNotFoundError extends Error {
 }
 
 export interface AdminInstanceDependencies {
-  readonly bind?: (session: ClientSession) => Promise<DomainBinding>
   readonly operationId?: (kind: 'create' | 'status' | 'delete' | 'install-domain') => string
 }
 
@@ -63,4 +59,4 @@ export function findOwnedInstance(
   instances: readonly OwnedInstanceInfo[],
   identifier: string,
 ): OwnedInstanceInfo | undefined
-export function formatInstanceLocation(info: InstanceInfo): string
+export function formatInstanceState(info: InstanceInfo): string

package/src/admin/instance/.spec/architecture.md

@@ -1,10 +1,10 @@
 # CLI Admin Instance adapter
 
-The adapter discovers and binds the configured Admin Domain, proves its origin, and resolves the
-singleton Fleet receiver. Policy-visible `Instance` and `Host` Nodes come from bounded Graph queries;
-Host location is joined through `instance_runs_on_host`.
+The adapter calls the stable singleton Fleet receiver directly. Listing and automatic creation are
+one Admin Method call each; connection performs no schema discovery, introspection, or graph read.
+Every returned summary is decoded locally before it reaches a command.
 
-Automatic creation invokes `Fleet.createInstance`; explicit `--host-id` resolves one visible,
-non-reserved Host and invokes `Host.createInstance`. Status, deletion, and Domain installation
-invoke the exact Instance receiver. The adapter creates internal operation IDs but preserves the
-existing CLI projection and selection-required experience.
+Automatic creation invokes `Fleet.createInstance`. Status, deletion, and Domain installation first
+resolve a caller-visible Instance through Fleet and then invoke that exact Instance receiver. The
+adapter creates internal operation IDs but preserves the existing CLI projection and
+selection-required experience.