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

package/dist/types/state/identities.d.ts

@@ -1,42 +0,0 @@
-import type { FileLockOptions } from './files';
-export type IdentitySource = 'key' | 'idp';
-export type IdentityMode = 'local' | 'remote';
-export interface Registration {
-    readonly iss: string;
-    readonly sub: string;
-    readonly registeredAt: string;
-}
-export interface Identity {
-    readonly subject: string;
-    readonly createdAt: string;
-    readonly source?: IdentitySource;
-    readonly mode?: IdentityMode;
-    readonly kid?: string;
-    readonly idp?: string;
-    readonly issuer?: string;
-    readonly audience?: string;
-    readonly claims?: Readonly<Record<string, unknown>>;
-    readonly registrations?: Readonly<Record<string, Registration>>;
-}
-export interface IdentityStore {
-    readonly default: string;
-    readonly identities: Readonly<Record<string, Identity>>;
-}
-export declare const IDENTITY_STORE_VERSION: 1;
-export type IdentityStateErrorCode = 'IDENTITY_STATE_INVALID' | 'IDENTITY_STATE_VERSION_UNSUPPORTED' | 'IDENTITY_STATE_UNREADABLE' | 'IDENTITY_STATE_BACKUP_CONFLICT';
-export declare class IdentityStateError extends Error {
-    readonly code: IdentityStateErrorCode;
-    readonly path: string;
-    constructor(code: IdentityStateErrorCode, path: string, message: string, cause?: unknown);
-}
-export interface IdentityStoreOptions {
-    readonly path?: string;
-    readonly now?: () => Date;
-    readonly lock?: FileLockOptions;
-}
-export interface IdentityUpdate<Value> {
-    readonly next: IdentityStore;
-    readonly value: Value;
-}
-export declare function readIdentityStore(options?: IdentityStoreOptions): Promise<IdentityStore>;
-export declare function updateIdentityStore<Value>(transition: (current: IdentityStore) => IdentityUpdate<Value> | Promise<IdentityUpdate<Value>>, options?: IdentityStoreOptions): Promise<Value>;

package/dist/types/state/index.d.ts

@@ -1,8 +0,0 @@
-export { atomicWrite, withFileLock } from './files';
-export type { FileLockOptions } from './files';
-export { ExchangeCredentialCache } from './exchange-credentials';
-export type { exchange } from './exchange-credentials';
-export { IDENTITY_STORE_VERSION, readIdentityStore, updateIdentityStore } from './identities';
-export type { Identity, IdentityMode, IdentitySource, IdentityStore, IdentityStoreOptions, IdentityUpdate, Registration, } from './identities';
-export { ASTRALE_HOME, CONFIG_PATH, DATA_DIR, IDENTITIES_PATH, IDPS_PATH, IDP_SESSIONS_DIR, EXCHANGE_CREDENTIALS_PATH, INSTALL_PATH, INSTANCES_PATH, KEYS_DIR, createPaths, paths, } from './paths';
-export type { PathEnvironment, Paths } from './paths';

package/dist/types/state/paths.d.ts

@@ -1,32 +0,0 @@
-export interface PathEnvironment {
-    readonly ASTRALE_HOME?: string;
-    readonly ASTRALE_KEYS_DIR?: string;
-    readonly ASTRALE_DATA_DIR?: string;
-}
-export interface Paths {
-    readonly home: string;
-    readonly keys: string;
-    readonly data: string;
-    readonly config: string;
-    readonly install: string;
-    readonly identities: string;
-    readonly instances: string;
-    readonly idps: string;
-    readonly idpSessionsDir: string;
-    readonly exchangeCredentials: string;
-    idpDir(name: string): string;
-    idpSession(identityName: string): string;
-}
-/** Resolve every CLI state path once from explicit input and the captured environment. */
-export declare function createPaths(home?: string, environment?: PathEnvironment): Paths;
-export declare const paths: Paths;
-export declare const ASTRALE_HOME: string;
-export declare const KEYS_DIR: string;
-export declare const DATA_DIR: string;
-export declare const CONFIG_PATH: string;
-export declare const INSTALL_PATH: string;
-export declare const IDENTITIES_PATH: string;
-export declare const INSTANCES_PATH: string;
-export declare const IDPS_PATH: string;
-export declare const IDP_SESSIONS_DIR: string;
-export declare const EXCHANGE_CREDENTIALS_PATH: string;

package/src/__tests__/fixtures/publication.ts

@@ -1,20 +0,0 @@
-import type { schema } from '@astrale-os/sdk/schema'
-
-import { defineApplication } from '@astrale-os/sdk/application'
-import { compile } from '@astrale-os/sdk/deployment/build'
-import { addressing, assemble } from '@astrale-os/sdk/deployment/release'
-import { defineRuntime } from '@astrale-os/sdk/runtime'
-
-/** Build a canonical empty-runtime Release for cross-boundary CLI tests. */
-export function releaseFor<const Schema extends schema.DomainSchema>(
-  source: Schema,
-  issuer: string,
-) {
-  const runtime = defineRuntime<Schema>()({
-    integrations: {},
-    initialize: () => ({ providers: {} }),
-    actions: [],
-    workflows: [],
-  })
-  return assemble(compile(defineApplication({ schema: source, runtime })), addressing(issuer))
-}

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

@@ -1,3 +0,0 @@
-/** CLI-private V2 Admin adapters; no package export or duplicate control-plane semantics. */
-export * as catalog from '../catalog/.spec/api.js'
-export * as instance from '../instance/.spec/api.js'

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

@@ -1,15 +0,0 @@
-# CLI Admin adapters
-
-This private aggregate translates the frozen CLI command journey into the discovered V2
-`admin.astrale.ai` contract. It binds the exact served Domain revision through Kernel Client,
-uses `GraphApi` for policy-visible inventory, and invokes receiver-oriented Methods through
-`DomainBinding`. It does not import Admin implementation code, hard-code one schema revision, call
-Host directly, or persist remote graph truth.
-
-`instance` owns create/list/status/delete/install projection and explicitly excludes the reserved
-Admin Host from consumer placement. `catalog` owns Domain inventory, publication, and default-set
-configuration. `graph` is their bounded cursor helper and is not re-exported by the aggregate.
-
-Commander grammar, help text, output shapes, bookmark behavior, and current interactive host
-selection remain owned by the existing command surface; these adapters change only its remote
-semantic owner.

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

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="#7c3aed" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">
-  <path d="M12 3 4.5 7v10L12 21l7.5-4V7z"/><path d="M8 10h8M8 14h5"/><circle cx="17" cy="16" r="2.5"/>
-</svg>

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

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

package/src/admin/__tests__/binding.test.ts

@@ -1,31 +0,0 @@
-import type { ClientSession } from '@astrale-os/sdk/client/session'
-
-import { bundle, defineSchema, schema as schemaApi } from '@astrale-os/sdk/schema'
-import { expect, mock, test } from 'bun:test'
-
-import { releaseFor } from '../../__tests__/fixtures/publication'
-import { bindAdmin } from '../binding'
-
-const schema = defineSchema('admin.astrale.ai', {})
-const release = releaseFor(schema, 'https://admin.beta.astrale.ai')
-
-test('binds the installed Admin Domain instead of the source Kernel publication', async () => {
-  const installation = mock(async () => ({
-    state: 'ready' as const,
-    target: 'sha256:admin-target' as const,
-    source: { kind: 'remote' as const, publication: release.publication },
-    bundle: bundle.create(schema),
-    readiness: 'sha256:admin-readiness' as const,
-    capabilities: { requested: [], materialized: [] },
-  }))
-  const session = {
-    installation,
-    bind: (domain: unknown) => ({ domain, graph: {} }),
-  } as unknown as ClientSession
-
-  const binding = await bindAdmin(session)
-
-  expect(installation).toHaveBeenCalledWith('admin.astrale.ai')
-  expect(binding.domain.origin).toBe('admin.astrale.ai')
-  expect(binding.domain.revision).toBe(schemaApi.revision(schema))
-})

package/src/admin/__tests__/fixture.ts

@@ -1,101 +0,0 @@
-import type { ClientSession } from '@astrale-os/sdk/client/session'
-import type { CallableReference } from '@astrale-os/sdk/client/session'
-
-import {
-  callableAddress,
-  core,
-  defineSchema,
-  edgeClass,
-  method,
-  nodeClass,
-  property,
-  schema,
-} from '@astrale-os/sdk/schema'
-import { mock } from 'bun:test'
-
-import type { AdminBinding } from '../binding'
-
-const operation = () =>
-  method({
-    auth: 'authenticated',
-    input: { type: 'object', additionalProperties: true },
-    output: { type: 'object', additionalProperties: true },
-  })
-
-const Domain = nodeClass({
-  properties: {
-    origin: property({ type: 'string' }, { required: true }),
-    name: property({ type: 'string' }, { required: true }),
-    discoveryUrl: property({ type: 'string' }, { required: true }),
-    description: property({ type: 'string' }),
-    createdAt: property({ type: 'string' }, { required: true }),
-    updatedAt: property({ type: 'string' }, { required: true }),
-  },
-  methods: { configureDefault: operation() },
-})
-const Fleet = nodeClass({
-  methods: {
-    publishDomain: operation(),
-    listInstances: operation(),
-    createInstance: operation(),
-  },
-})
-const Host = nodeClass({
-  properties: {
-    id: property({ type: 'string' }, { required: true }),
-    state: property({ type: 'string' }, { required: true }),
-  },
-  methods: { createInstance: operation() },
-})
-const Instance = nodeClass({
-  methods: {
-    status: operation(),
-    delete: operation(),
-    installDomain: operation(),
-  },
-})
-const fleet_installs_domain_by_default = edgeClass.directed({
-  source: { as: 'fleet', accepts: [Fleet], outgoing: '0..*' },
-  target: { as: 'domain', accepts: [Domain], incoming: '0..*' },
-})
-const fleet_reserves_admin_host = edgeClass.directed({
-  source: { as: 'fleet', accepts: [Fleet], outgoing: '0..1' },
-  target: { as: 'host', accepts: [Host], incoming: '0..1' },
-})
-
-export const AdminTestSchema = defineSchema('admin.astrale.ai', {
-  classes: {
-    Domain,
-    Fleet,
-    Host,
-    Instance,
-    fleet_installs_domain_by_default,
-    fleet_reserves_admin_host,
-  },
-  core: { nodes: { fleet: core.node(() => Fleet, {}) }, edges: [] },
-})
-
-export const AdminTestDomain = schema.resolve(AdminTestSchema)
-
-export function adminBinding(): AdminBinding {
-  return { domain: AdminTestDomain, graph: {} } as unknown as AdminBinding
-}
-
-export function adminSession(
-  implementation?: (
-    method: { readonly owner: string; readonly name: string },
-    receiver: unknown,
-    input: unknown,
-  ) => unknown,
-) {
-  const invoke = mock(async (reference: CallableReference, input: unknown) => {
-    const address = callableAddress(reference.callable)
-    if (address.kind !== 'method') throw new Error('Expected an Admin Method.')
-    return implementation?.(
-      { owner: address.owner.name, name: address.name },
-      reference.target,
-      input,
-    )
-  })
-  return { invoke, session: { invoke } as unknown as ClientSession }
-}

package/src/admin/binding.ts

@@ -1,98 +0,0 @@
-import type { Input } from '@astrale-os/sdk/client'
-import type { ClientSession } from '@astrale-os/sdk/client/session'
-import type {
-  ResolvedClass,
-  ResolvedCoreDefinition,
-  ResolvedMethod,
-  ResolvedProperty,
-} from '@astrale-os/sdk/schema'
-import type { DomainBinding } from '@astrale-os/shell'
-
-import { reference } from '@astrale-os/sdk/client/session'
-import { Path } from '@astrale-os/sdk/graph/path'
-import { bindDomain } from '@astrale-os/shell'
-
-const ADMIN_ORIGIN = 'admin.astrale.ai'
-
-export type AdminBinding = DomainBinding
-
-/** Bind the exact Admin revision installed on this source Kernel. */
-export async function bindAdmin(session: ClientSession): Promise<AdminBinding> {
-  const installed = await session.installation(ADMIN_ORIGIN)
-  return requireAdminBinding(await bindDomain(session, installed.bundle.root))
-}
-
-/** Admit an injected dynamic binding as the Admin Domain. */
-export function requireAdminBinding(binding: AdminBinding): AdminBinding {
-  if (binding.domain.origin !== ADMIN_ORIGIN) {
-    throw new TypeError('Configured Admin target does not serve the Admin Domain.')
-  }
-  return binding
-}
-
-/** Resolve one required Admin Class without rebuilding its schema contract. */
-export function requireAdminClass(
-  binding: AdminBinding,
-  name: string,
-  kind: 'node',
-): ResolvedClass<'node'>
-export function requireAdminClass(
-  binding: AdminBinding,
-  name: string,
-  kind: 'edge',
-): ResolvedClass<'edge'>
-export function requireAdminClass(
-  binding: AdminBinding,
-  name: string,
-  kind: 'node' | 'edge',
-): ResolvedClass<'node'> | ResolvedClass<'edge'> {
-  const selected = binding.domain.classes[name]
-  if (selected?.kind !== kind) throw new TypeError(`Admin ${name} is not a ${kind} Class.`)
-  return selected
-}
-
-/** Resolve one required Admin Core Node as its canonical projection Path. */
-export function requireAdminCore(binding: AdminBinding, name: string): Path {
-  const selected = binding.domain.core.nodes[name] as ResolvedCoreDefinition | undefined
-  if (selected === undefined) throw new TypeError(`Admin has no Core Node ${name}.`)
-  return Path.project(selected.ref)
-}
-
-/** Resolve one effective Property by unambiguous member name. */
-export function requireAdminProperty(
-  owner: ResolvedClass,
-  name: string,
-): ResolvedProperty<unknown> {
-  const selected = [...owner.properties].find((property) => property.name === name)
-  if (selected === undefined) {
-    throw new TypeError(`Admin ${owner.ref.name}.${name} Property is absent.`)
-  }
-  return selected
-}
-
-/** Invoke one resolved executable instance Method through Kernel Client. */
-export async function invokeAdminMethod(
-  session: ClientSession,
-  binding: AdminBinding,
-  owner: ResolvedClass<'node'>,
-  name: string,
-  receiver: Path,
-  input: Input,
-): Promise<unknown> {
-  const method = [...owner.methods].find((candidate) => candidate.name === name)
-  if (method === undefined || !isExecutableInstanceMethod(method)) {
-    throw new TypeError(`Admin ${owner.ref.name}.${name} is not an executable instance Method.`)
-  }
-  return session.invoke(reference(binding.domain, method)(receiver), input)
-}
-
-type ExecutableInstanceMethod = ResolvedMethod<
-  unknown,
-  unknown,
-  false,
-  Exclude<ResolvedMethod['inheritance'], 'abstract'>
->
-
-function isExecutableInstanceMethod(method: ResolvedMethod): method is ExecutableInstanceMethod {
-  return method.static === false && method.inheritance !== 'abstract'
-}

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

@@ -1,65 +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 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 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 class AdminDomainNotFoundError extends Error {
-  constructor(identifier: string)
-  readonly name: 'NotFoundError'
-  readonly identifier: string
-}
-
-export interface AdminCatalogDependencies {
-  readonly bind?: (session: ClientSession) => Promise<DomainBinding>
-  readonly operationId?: (kind: 'publish' | 'configure-default') => string
-}
-
-export function connectAdminCatalog(
-  context: AdminCatalogContext,
-  dependencies?: AdminCatalogDependencies,
-): Promise<AdminCatalogApi>

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

@@ -1,6 +0,0 @@
-# CLI Admin catalog adapter
-
-The adapter reads policy-visible `Domain` Nodes through bounded Graph pages and derives default
-membership from the Fleet relation. Publication invokes `Fleet.publishDomain`; a requested default
-change is a separate explicit `Domain.configureDefault` call. Unchanged publication input is a
-no-op, and an omitted description preserves the current value.

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

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="#059669" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">
-  <path d="M5 4h14v16H5zM8 8h8M8 12h8M8 16h5"/><circle cx="17" cy="16" r="2"/>
-</svg>

package/src/admin/catalog/.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/catalog/__tests__/client.test.ts

@@ -1,142 +0,0 @@
-import type { Node } from '@astrale-os/sdk/graph/node'
-import type { QueryAST } from '@astrale-os/sdk/query'
-
-import { NodeId } from '@astrale-os/sdk/graph/node'
-import { describe, expect, mock, test } from 'bun:test'
-
-import type { AdminGraphApi } from '../../graph'
-
-import { AdminTestDomain, adminBinding, adminSession } from '../../__tests__/fixture'
-import { connectAdminCatalog } from '../client'
-
-function domainNode(id: string, origin: string): Node {
-  return {
-    id: NodeId(id),
-    class: AdminTestDomain.classes.Domain.key,
-    props: AdminTestDomain.classes.Domain.properties.from({
-      origin,
-      name: origin.split('.')[0]!,
-      discoveryUrl: `https://${origin}`,
-      createdAt: '2026-08-12T00:00:00.000Z',
-      updatedAt: '2026-08-12T00:00:00.000Z',
-    }),
-  }
-}
-
-function fixture(input: {
-  domains?: readonly Node[]
-  defaults?: readonly Node[]
-  invoke?: (method: { owner: string; name: string }, receiver: unknown, value: 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()
-  const query = mock(async (_ast: QueryAST) => ({
-    result: {
-      kind: 'nodes' as const,
-      nodes: (input.domains ?? []).map((value) => ({ kind: 'value' as const, value })),
-    },
-    page: {},
-  }))
-  const defaultNodes = input.defaults ?? []
-  const neighbors = mock(async () => ({
-    nodes: defaultNodes,
-    first: defaultNodes[0] ?? null,
-    graph: { nodes: defaultNodes, edges: [] },
-    cursor: null,
-    collect: async () => ({ nodes: defaultNodes, cursor: null }),
-  }))
-  const graph = { query, neighbors } as unknown as AdminGraphApi
-  return {
-    invoke: remote.invoke,
-    calls,
-    connect: () =>
-      connectAdminCatalog(
-        { session: remote.session, graph },
-        {
-          bind: async () => binding,
-          operationId: (kind) => `cli.domain.${kind}:test`,
-        },
-      ),
-  }
-}
-
-function summary(origin: string) {
-  return {
-    id: '@crm-domain',
-    origin,
-    name: 'crm',
-    discoveryUrl: `https://${origin}`,
-    createdAt: '2026-08-12T00:00:00.000Z',
-    updatedAt: '2026-08-12T00:00:00.000Z',
-  }
-}
-
-describe('V2 Admin Domain catalog adapter', () => {
-  test('lists Domain nodes through GraphApi and joins the Fleet default relation', async () => {
-    const crm = domainNode('crm-domain', 'crm.acme.dev')
-    const notes = domainNode('notes-domain', 'notes.acme.dev')
-    const api = await fixture({ domains: [crm, notes], defaults: [crm] }).connect()
-
-    await expect(api.list()).resolves.toEqual([
-      expect.objectContaining({
-        id: '@crm-domain',
-        origin: 'crm.acme.dev',
-        installByDefault: true,
-      }),
-      expect.objectContaining({ id: '@notes-domain', origin: 'notes.acme.dev' }),
-    ])
-  })
-
-  test('publishes through Fleet then configures the Domain default explicitly', async () => {
-    const contract = fixture({ invoke: () => summary('crm.acme.dev') })
-    const api = await contract.connect()
-
-    await expect(
-      api.publish({
-        origin: 'crm.acme.dev',
-        name: 'crm',
-        url: 'https://crm.acme.dev',
-        installByDefault: true,
-      }),
-    ).resolves.toMatchObject({ changed: true, isNew: true, entry: { installByDefault: true } })
-    expect(contract.calls).toEqual([
-      {
-        method: { owner: 'Fleet', name: 'publishDomain' },
-        receiver: '/:admin.astrale.ai:core.fleet::publishDomain',
-        value: {
-          operationId: 'cli.domain.publish:test',
-          origin: 'crm.acme.dev',
-          name: 'crm',
-          discoveryUrl: 'https://crm.acme.dev',
-        },
-      },
-      {
-        method: { owner: 'Domain', name: 'configureDefault' },
-        receiver: '@crm-domain::configureDefault',
-        value: {
-          operationId: 'cli.domain.configure-default:test',
-          enabled: true,
-        },
-      },
-    ])
-  })
-
-  test('does not invoke a receiver when the catalog record is already current', async () => {
-    const crm = domainNode('crm-domain', 'crm.acme.dev')
-    const contract = fixture({ domains: [crm] })
-    const api = await contract.connect()
-
-    await expect(
-      api.publish({ origin: 'crm.acme.dev', name: 'crm', url: 'https://crm.acme.dev' }),
-    ).resolves.toMatchObject({ changed: false, isNew: false })
-    expect(contract.invoke).not.toHaveBeenCalled()
-  })
-})