@astrale-os/cli 1.0.0-beta.9 → 1.0.0-npm-deprecated.0

package/src/admin/catalog/client.ts

@@ -1,218 +0,0 @@
-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 { 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,
-  type DomainInfo,
-  type PublishDomainInput,
-  type PublishDomainResult,
-} from './model'
-
-const PAGE_SIZE = 256
-const MAXIMUM_DOMAINS = 10_000
-const MAXIMUM_PAGES = Math.ceil(MAXIMUM_DOMAINS / PAGE_SIZE) + 1
-
-export interface AdminCatalogContext {
-  readonly session: ClientSession
-  readonly graph: AdminGraphApi
-}
-
-export interface AdminCatalogApi {
-  list(): Promise<DomainInfo[]>
-  require(identifier: string): Promise<DomainInfo>
-  publish(input: PublishDomainInput): Promise<PublishDomainResult>
-}
-
-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. */
-export async function connectAdminCatalog(
-  context: AdminCatalogContext,
-  dependencies: AdminCatalogDependencies = {},
-): Promise<AdminCatalogApi> {
-  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({ nodes: [Domain] }).select({
-          kind: 'nodes',
-          projection: { kind: 'value' },
-        }),
-        {
-          label: 'Admin Domain catalog',
-          maximum: MAXIMUM_DOMAINS,
-          maximumPages: MAXIMUM_PAGES,
-        },
-      ),
-      context.graph.neighbors(fleet, fleetInstallsByDefault, {
-        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))))
-  }
-
-  const requireDomain = async (identifier: string): Promise<DomainInfo> => {
-    const found = (await list()).find(
-      (domain) =>
-        domain.origin === identifier ||
-        domain.url === identifier ||
-        domain.id === identifier ||
-        (domain.id.startsWith('@') && domain.id.slice(1) === identifier),
-    )
-    if (found === undefined) throw new AdminDomainNotFoundError(identifier)
-    return found
-  }
-
-  return Object.freeze({
-    list,
-    require: requireDomain,
-    async publish(input: PublishDomainInput): Promise<PublishDomainResult> {
-      const existing = (await list()).find((domain) => domain.origin === input.origin)
-      const description = input.description ?? existing?.description
-      const registryChanged =
-        existing === undefined ||
-        existing.name !== input.name ||
-        existing.url !== input.url ||
-        existing.description !== description
-      let entry = existing
-      if (registryChanged) {
-        entry = domainFromSummary(
-          await invokeAdminMethod(context.session, binding, Fleet, 'publishDomain', fleet, {
-            operationId: operationId('publish'),
-            origin: input.origin,
-            name: input.name,
-            discoveryUrl: input.url,
-            ...(description === undefined ? {} : { description }),
-          }),
-          existing?.installByDefault === true,
-        )
-      }
-      if (entry === undefined) throw new TypeError('Admin Domain publication returned no entry.')
-
-      const defaultChanged =
-        input.installByDefault !== undefined &&
-        (entry.installByDefault ?? false) !== input.installByDefault
-      if (defaultChanged) {
-        entry = domainFromSummary(
-          await invokeAdminMethod(
-            context.session,
-            binding,
-            Domain,
-            'configureDefault',
-            Path.parse(entry.id),
-            {
-              operationId: operationId('configure-default'),
-              enabled: input.installByDefault,
-            },
-          ),
-          input.installByDefault === true,
-        )
-      }
-      return Object.freeze({
-        entry,
-        changed: registryChanged || defaultChanged,
-        isNew: existing === undefined,
-      })
-    },
-  })
-}
-
-type DynamicDefinition = ResolvedClass<'node'>
-
-function domainFromNode(
-  definition: DynamicDefinition,
-  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'),
-    ...(installByDefault ? { installByDefault: true } : {}),
-    createdAt: requiredProperty(definition, node, 'createdAt'),
-    updatedAt: requiredProperty(definition, 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'),
-    origin: requiredString(value.origin, 'Admin Domain origin'),
-    name: requiredString(value.name, 'Admin Domain name'),
-    url: requiredString(value.discoveryUrl, 'Admin Domain discovery URL'),
-    ...(value.description === undefined
-      ? {}
-      : { description: requiredString(value.description, 'Admin Domain description') }),
-    ...(installByDefault ? { installByDefault: true } : {}),
-    createdAt: requiredString(value.createdAt, 'Admin Domain creation time'),
-    updatedAt: requiredString(value.updatedAt, 'Admin Domain update time'),
-  })
-}
-
-function requiredProperty(definition: DynamicDefinition, node: Node, name: string): string {
-  return requiredString(
-    node.props[requireAdminProperty(definition, name).key],
-    `Admin Domain.${name}`,
-  )
-}
-
-function optionalProperty(
-  definition: DynamicDefinition,
-  node: Node,
-  name: string,
-): Readonly<Record<string, string>> {
-  const value = node.props[requireAdminProperty(definition, name).key]
-  return value === undefined ? {} : { [name]: requiredString(value, `Admin Domain.${name}`) }
-}
-
-function requiredString(input: unknown, label: string): string {
-  if (typeof input !== 'string' || input.length === 0) throw new TypeError(`${label} is invalid.`)
-  return input
-}
-
-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.`)
-  }
-  return input as Readonly<Record<string, unknown>>
-}
-
-function defaultOperationId(kind: 'publish' | 'configure-default'): string {
-  return `cli.domain.${kind}:${globalThis.crypto.randomUUID()}`
-}

package/src/admin/catalog/index.ts

@@ -1,13 +0,0 @@
-export {
-  connectAdminCatalog,
-  type AdminCatalogApi,
-  type AdminCatalogContext,
-  type AdminCatalogDependencies,
-} from './client'
-export {
-  AdminDomainNotFoundError,
-  type DomainInfo,
-  type InstallDomainResult,
-  type PublishDomainInput,
-  type PublishDomainResult,
-} from './model'

package/src/admin/catalog/model.ts

@@ -1,41 +0,0 @@
-/** CLI-stable projection of one Admin Domain catalog record. */
-export interface DomainInfo {
-  readonly id: string
-  readonly origin: string
-  readonly name: string
-  readonly url?: string
-  readonly description?: string
-  readonly installByDefault?: boolean
-  readonly createdAt: string
-  readonly updatedAt: string
-}
-
-export interface PublishDomainInput {
-  readonly origin: string
-  readonly name: string
-  readonly url: string
-  readonly description?: string
-  readonly installByDefault?: boolean
-}
-
-export interface PublishDomainResult {
-  readonly entry: DomainInfo
-  readonly changed: boolean
-  readonly isNew: boolean
-}
-
-export interface InstallDomainResult {
-  readonly name: string
-  readonly origin: string
-  readonly instanceId: string
-  readonly url: string
-  readonly ok: boolean
-  readonly error?: string | null
-}
-
-export class AdminDomainNotFoundError extends AstraleError {
-  constructor(readonly identifier: string) {
-    super('DOMAIN_NOT_FOUND', `No visible Admin Domain matches ${JSON.stringify(identifier)}.`)
-  }
-}
-import { AstraleError } from '../../errors'

package/src/admin/catalog/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "types": ["@types/node"]
-  },
-  "include": ["*.ts"],
-  "exclude": ["__tests__"]
-}

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

@@ -1,22 +0,0 @@
-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'
-
-/** Smallest Kernel graph capability needed by bounded Admin graph reads. */
-export type AdminGraphQueryApi = Pick<GraphApi, 'query'>
-
-/** Caller-scoped graph reads shared by the Admin catalog and Instance journeys. */
-export type AdminGraphApi = Pick<GraphApi, 'query' | 'neighbors'>
-
-export interface ReadAllNodesOptions {
-  readonly label: string
-  readonly maximum: number
-  readonly maximumPages: number
-}
-
-/** Collect one bounded Node selection and reject projection, cursor, or identity anomalies. */
-export function readAllNodes(
-  graph: AdminGraphQueryApi,
-  ast: QueryAST,
-  options: ReadAllNodesOptions,
-): Promise<readonly Node[]>

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

@@ -1,5 +0,0 @@
-# Admin Graph inventory helper
-
-This internal helper consumes only public `GraphApi.query` pages. It requires a Node selection,
-enforces explicit Node and page bounds, rejects repeated cursors and Node identities, and returns a
-frozen inventory. It owns no Admin schema meaning and performs no mutation or invocation.

package/src/admin/graph/.spec/icon.svg

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="#0891b2" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">
-  <circle cx="5" cy="12" r="2"/><circle cx="12" cy="6" r="2"/><circle cx="19" cy="12" r="2"/><circle cx="12" cy="18" r="2"/><path d="m7 11 3.5-3.5M13.5 7.5 17 11M17 13l-3.5 3.5M10.5 16.5 7 13"/>
-</svg>

package/src/admin/graph/.spec/layout.ts

@@ -1,3 +0,0 @@
-import { defineLayout } from '@astrale-os/spec/authoring'
-
-export default defineLayout({ entries: ['index.ts', 'nodes.ts'], exact: true })

package/src/admin/graph/index.ts

@@ -1,6 +0,0 @@
-export {
-  readAllNodes,
-  type AdminGraphApi,
-  type AdminGraphQueryApi,
-  type ReadAllNodesOptions,
-} from './nodes'

package/src/admin/graph/nodes.ts

@@ -1,56 +0,0 @@
-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'
-
-export type AdminGraphQueryApi = Pick<GraphApi, 'query'>
-export type AdminGraphApi = Pick<GraphApi, 'query' | 'neighbors'>
-
-export interface ReadAllNodesOptions {
-  readonly label: string
-  readonly maximum: number
-  readonly maximumPages: number
-}
-
-/** Collect one explicitly bounded Node-value projection without hiding cursors. */
-export async function readAllNodes(
-  graph: AdminGraphQueryApi,
-  ast: QueryAST,
-  options: ReadAllNodesOptions,
-): Promise<readonly Node[]> {
-  const nodes: Node[] = []
-  const ids = new Set<string>()
-  const cursors = new Set<string>()
-  let cursor: string | undefined
-  let pages = 0
-  const pageSize = Math.min(options.maximum, 256)
-  do {
-    pages += 1
-    if (pages > options.maximumPages) {
-      throw new TypeError(`${options.label} exceeded its page bound.`)
-    }
-    const response = await graph.query(ast, {
-      page: { size: pageSize, ...(cursor === undefined ? {} : { after: cursor }) },
-    })
-    const result = response.result
-    if (result.kind !== 'nodes')
-      throw new TypeError(`${options.label} returned the wrong projection.`)
-    for (const projection of result.nodes) {
-      if (projection.kind !== 'value') {
-        throw new TypeError(`${options.label} omitted requested Node values.`)
-      }
-      const node = projection.value
-      if (ids.has(String(node.id))) throw new TypeError(`${options.label} repeated a Node.`)
-      ids.add(String(node.id))
-      nodes.push(node)
-    }
-    if (nodes.length > options.maximum) {
-      throw new TypeError(`${options.label} exceeded its Node bound.`)
-    }
-    cursor = response.page.next
-    if (cursor !== undefined && cursors.has(cursor)) {
-      throw new TypeError(`${options.label} repeated a cursor.`)
-    }
-    if (cursor !== undefined) cursors.add(cursor)
-  } while (cursor !== undefined)
-  return Object.freeze(nodes)
-}

package/src/admin/index.ts

@@ -1,2 +0,0 @@
-export * as catalog from './catalog'
-export * as instance from './instance'

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

@@ -1,66 +0,0 @@
-import type { ClientSession } from '@astrale-os/sdk/client/session'
-import type { DomainBinding } from '@astrale-os/shell'
-
-import type { AdminGraphApi } from '../../graph/.spec/api.js'
-
-export type InstanceState = 'provisioning' | 'ready' | 'deleting' | 'failed' | 'deleted'
-
-export interface InstanceInfo {
-  readonly id: string
-  readonly slug: string
-  readonly url: string
-  readonly hostId?: string
-  readonly region?: string
-  readonly state?: InstanceState
-  readonly phase?: string
-  readonly error?: string | null
-  readonly createdAt?: string
-  readonly organizationId?: string
-}
-
-export interface OwnedInstanceInfo extends InstanceInfo {
-  readonly state: InstanceState
-}
-
-export interface DomainInstallReceipt {
-  readonly domain: string
-  readonly instance: string
-  readonly origin: string
-  readonly ok: boolean
-  readonly installedRevision?: string
-  readonly error?: string
-}
-
-export interface AdminInstanceContext {
-  readonly session: ClientSession
-  readonly graph: AdminGraphApi
-}
-
-export interface AdminInstanceApi {
-  list(): Promise<OwnedInstanceInfo[]>
-  create(slug: string, hostId?: string): Promise<InstanceInfo>
-  status(identifier: string): Promise<InstanceInfo>
-  delete(identifier: string): Promise<InstanceInfo>
-  installDomain(identifier: string, domain: string): Promise<DomainInstallReceipt>
-}
-
-export class AdminInstanceNotFoundError extends Error {
-  constructor(identifier: string)
-  readonly name: 'NotFoundError'
-  readonly identifier: string
-}
-
-export interface AdminInstanceDependencies {
-  readonly bind?: (session: ClientSession) => Promise<DomainBinding>
-  readonly operationId?: (kind: 'create' | 'status' | 'delete' | 'install-domain') => string
-}
-
-export function connectAdminInstances(
-  context: AdminInstanceContext,
-  dependencies?: AdminInstanceDependencies,
-): Promise<AdminInstanceApi>
-export function findOwnedInstance(
-  instances: readonly OwnedInstanceInfo[],
-  identifier: string,
-): OwnedInstanceInfo | undefined
-export function formatInstanceLocation(info: InstanceInfo): string

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

@@ -1,10 +0,0 @@
-# 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`.
-
-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.

package/src/admin/instance/.spec/icon.svg

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="#2563eb" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">
-  <rect x="4" y="4" width="16" height="16" rx="3"/><path d="M8 9h8M8 13h8M8 17h5"/><circle cx="17" cy="17" r="1" fill="#2563eb"/>
-</svg>

package/src/admin/instance/.spec/layout.ts

@@ -1,6 +0,0 @@
-import { defineLayout } from '@astrale-os/spec/authoring'
-
-export default defineLayout({
-  entries: ['__tests__/', 'client.ts', 'index.ts', 'model.ts', 'tsconfig.json'],
-  exact: true,
-})

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

@@ -1,166 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { adminBinding, adminSession } from '../../__tests__/fixture'
-import { connectAdminInstances } from '../client'
-
-function fixture(input: {
-  invoke?: (method: { owner: string; name: string }, receiver: unknown, input: unknown) => unknown
-}) {
-  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 binding = adminBinding()
-  return {
-    binding,
-    invoke: remote.invoke,
-    calls,
-    connect: () =>
-      connectAdminInstances(
-        { session: remote.session },
-        {
-          bind: async () => binding,
-          operationId: (kind) => `cli.instance.${kind}:test`,
-        },
-      ),
-  }
-}
-
-describe('V2 Admin Instance adapter', () => {
-  test('lists caller-visible Instances through the Admin-owned Fleet operation', async () => {
-    const contract = fixture({
-      invoke: (method) =>
-        method.name === 'listInstances'
-          ? [
-              {
-                id: '@instance-node',
-                slug: 'demo',
-                url: 'https://demo.eu.astrale.ai',
-                state: 'ready',
-                createdAt: '2026-08-12T00:00:00.000Z',
-                updatedAt: '2026-08-12T00:00:00.000Z',
-              },
-            ]
-          : undefined,
-    })
-
-    await expect((await contract.connect()).list()).resolves.toEqual([
-      {
-        id: '@instance-node',
-        slug: 'demo',
-        url: 'https://demo.eu.astrale.ai',
-        state: 'ready',
-        createdAt: '2026-08-12T00:00:00.000Z',
-      },
-    ])
-    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 () => {
-    const created = {
-      id: '@instance-node',
-      slug: 'demo',
-      url: 'https://demo.eu.astrale.ai',
-      state: 'ready',
-      createdAt: '2026-08-12T00:00:00.000Z',
-      updatedAt: '2026-08-12T00:00:00.000Z',
-    }
-    const contract = fixture({ invoke: () => created })
-
-    await expect((await contract.connect()).create('demo')).resolves.toMatchObject({
-      id: created.id,
-      slug: created.slug,
-      url: created.url,
-      state: created.state,
-      createdAt: created.createdAt,
-    })
-    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 contract = fixture({
-      invoke: (method) =>
-        method.name === 'listInstances'
-          ? [
-              {
-                id: '@instance-node',
-                slug: 'demo',
-                url: 'https://demo.eu.astrale.ai',
-                state: 'ready',
-                createdAt: '2026-08-12T00:00:00.000Z',
-                updatedAt: '2026-08-12T00:00:00.000Z',
-              },
-            ]
-          : {
-              id: '@instance-node',
-              slug: 'demo',
-              url: 'https://demo.eu.astrale.ai',
-              state: method.name === 'delete' ? 'deleted' : 'ready',
-            },
-    })
-    const api = await contract.connect()
-
-    await expect(api.status('demo')).resolves.toMatchObject({ state: 'ready' })
-    await expect(api.delete('@instance-node')).resolves.toMatchObject({ state: 'deleted' })
-    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 contract = fixture({
-      invoke: (method) =>
-        method.name === 'listInstances'
-          ? [
-              {
-                id: '@instance-node',
-                slug: 'demo',
-                url: 'https://demo.eu.astrale.ai',
-                state: 'ready',
-                createdAt: '2026-08-12T00:00:00.000Z',
-                updatedAt: '2026-08-12T00:00:00.000Z',
-              },
-            ]
-          : {
-              domain: '@crm-domain',
-              instance: '@instance-node',
-              origin: 'crm.acme.dev',
-              ok: true,
-              installedRevision: `sha256:${'a'.repeat(64)}`,
-            },
-    })
-    const api = await contract.connect()
-
-    await expect(api.installDomain('demo', '@crm-domain')).resolves.toMatchObject({
-      domain: '@crm-domain',
-      instance: '@instance-node',
-      origin: 'crm.acme.dev',
-      ok: true,
-    })
-    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' },
-    })
-  })
-})