@astrale-os/cli 1.0.0-beta.32 → 1.0.0-beta.43

package/src/commands/instance/status.ts

@@ -1,92 +0,0 @@
-import chalk from 'chalk'
-
-import type { KernelCommandOpts } from '../../connection'
-import type { CommandDefinition } from '../../program/index'
-
-import { formatKernelError } from '../../connection/errors'
-import { AstraleError } from '../../errors'
-import { statusOwnedInstance, type InstanceInfo } from '../../lib/admin-instance'
-import { ADMIN_TARGET_OPTIONS, type AdminTargetCommandOpts } from '../../lib/admin-target'
-import { resolveInstance } from '../../lib/instance'
-import { log, withSpinner } from '../../lib/log'
-import { isMachine, output, type RawOutputOpts } from '../../lib/output'
-import { probeBookmark } from './use'
-
-type StatusOpts = KernelCommandOpts &
-  AdminTargetCommandOpts &
-  RawOutputOpts & { bookmarked?: boolean }
-
-interface BookmarkStatus {
-  readonly slug: string
-  readonly url: string
-  readonly issuer: string
-  readonly kind: 'bookmark'
-  readonly state: 'ready'
-}
-
-export default {
-  name: 'status',
-  description: 'Show managed instance status or probe a bookmark',
-  arguments: [{ name: 'id', description: 'Instance slug', required: true }],
-  options: [
-    ...ADMIN_TARGET_OPTIONS,
-    { flags: '--bookmarked', description: 'Probe a locally bookmarked kernel connection' },
-  ],
-  action: async (id: string, opts: StatusOpts) => {
-    try {
-      const result = await withSpinner(`Fetching instance ${id}`, !isMachine(opts), () =>
-        resolveStatus(id, opts),
-      )
-      if (isMachine(opts)) {
-        output(result, opts)
-        return
-      }
-      console.log(`${chalk.bold(result.slug)} ${chalk.dim(result.url)}`)
-      const phase = 'phase' in result ? result.phase : undefined
-      log.dim(`  state: ${result.state}${phase ? ` (${phase})` : ''}`)
-      if ('error' in result && result.error) log.dim(`  error: ${result.error}`)
-      if ('organizationId' in result && result.organizationId)
-        log.dim(`  organization: ${result.organizationId}`)
-      if ('createdAt' in result && result.createdAt) log.dim(`  created: ${result.createdAt}`)
-    } catch (e) {
-      await formatKernelError(e, isMachine(opts), undefined, opts.debug)
-      process.exit(1)
-    }
-  },
-} satisfies CommandDefinition
-
-export interface StatusDependencies {
-  readonly statusOwnedInstance: typeof statusOwnedInstance
-  readonly resolveInstance: typeof resolveInstance
-  readonly probeBookmark: typeof probeBookmark
-}
-
-const defaultStatusDependencies: StatusDependencies = Object.freeze({
-  statusOwnedInstance,
-  resolveInstance,
-  probeBookmark,
-})
-
-export async function resolveStatus(
-  id: string,
-  opts: StatusOpts,
-  dependencies: StatusDependencies = defaultStatusDependencies,
-): Promise<InstanceInfo | BookmarkStatus> {
-  if (!opts.bookmarked) return dependencies.statusOwnedInstance(opts, id)
-  if (opts.admin !== undefined || opts.adminUrl !== undefined || opts.domainIssuer !== undefined) {
-    throw new AstraleError(
-      'INVALID_FLAG',
-      '--bookmarked cannot be combined with Admin target options.',
-      'Remove --bookmarked to inspect managed lifecycle, or remove the Admin options to probe a local bookmark.',
-    )
-  }
-  const bookmark = await dependencies.resolveInstance(id, undefined, { persist: false })
-  await dependencies.probeBookmark(bookmark)
-  return Object.freeze({
-    slug: bookmark.name,
-    url: bookmark.url,
-    issuer: bookmark.issuer ?? bookmark.url,
-    kind: 'bookmark',
-    state: 'ready',
-  })
-}

package/src/commands/instance/use.ts

@@ -1,263 +0,0 @@
-import type { OwnedInstanceInfo } from '../../lib/admin-instance'
-import type { CommandDefinition } from '../../program/index'
-
-import { AstraleError } from '../../errors'
-import { getDefault, setDefault } from '../../identity/index'
-import { listOwnedInstancesWithIdentity } from '../../lib/admin-instance'
-import { ADMIN_TARGET_OPTIONS } from '../../lib/admin-target'
-import { fetchWithCaFile } from '../../lib/ca-fetch'
-import {
-  findBookmarkTrustConflicts,
-  getActive,
-  readInstances,
-  resolveInstance,
-  resolveInstanceKey,
-  setActive,
-  upsertManagedBookmark,
-  type ResolvedInstance,
-} from '../../lib/instance'
-import {
-  collectInstanceCandidates,
-  describeInstanceCandidate,
-  type InstanceCandidate,
-} from '../../lib/instance-candidates'
-import { fatal, log } from '../../lib/log'
-import { checkIssuerReachability } from '../../lib/meta'
-import { confirmDefaultYes, selectFrom } from '../../lib/prompt'
-import { validateSlug } from '../../lib/validation'
-
-type UseOpts = {
-  admin?: string
-  adminUrl?: string
-  url?: string
-  timeout?: string
-  as?: string
-  creds?: string
-  debug?: boolean
-  ci?: boolean
-  noPrompt?: boolean
-  adoptDefault?: boolean
-  skipJwksCheck?: boolean
-}
-
-async function useInstance(name?: string, opts: UseOpts = {}): Promise<void> {
-  try {
-    if (!name) {
-      const active = await getActive()
-      console.log(`${active.name} (${active.url})`)
-      return
-    }
-
-    const resolved = await resolveUseTarget(name, opts)
-
-    if (!opts.skipJwksCheck) {
-      await probeBookmark(resolved)
-    }
-
-    await setActive(resolved.name)
-    log.success(`Active instance: ${resolved.name} (${resolved.url})`)
-
-    // §7.1 identity-adoption prompt (DX). Orthogonality preserved — we
-    // only switch on explicit user consent (or --adopt-default in CI).
-    const store = await readInstances()
-    const key = resolveInstanceKey(store, resolved.name)
-    const identityCandidate =
-      resolved.defaultIdentity ?? (key ? store.instances[key]?.defaultIdentity : undefined)
-    if (!identityCandidate) return
-    const active = await getDefault().catch(() => null)
-    if (active?.name === identityCandidate) return
-
-    const inCi = opts.ci || opts.noPrompt || !!process.env.CI
-    if (inCi) {
-      if (opts.adoptDefault) {
-        await setDefault(identityCandidate)
-        log.success(`Identity switched to "${identityCandidate}" (--adopt-default)`)
-      } else {
-        log.dim(
-          `  (instance default identity "${identityCandidate}" — keep active ${active?.name ?? 'none'})`,
-        )
-      }
-      return
-    }
-
-    const msg = `Instance "${resolved.name}" has default identity "${identityCandidate}". Active: "${active?.name ?? 'none'}". Switch identity too?`
-    if (await confirmDefaultYes(msg)) {
-      await setDefault(identityCandidate)
-      log.success(`Identity switched to "${identityCandidate}"`)
-    } else {
-      log.dim('  kept active identity (orthogonal)')
-    }
-  } catch (e) {
-    fatal(e)
-  }
-}
-
-/** Probe with the exact TLS trust configuration stored on this bookmark. */
-export async function probeBookmark(
-  resolved: ResolvedInstance,
-  dependencies: Partial<BookmarkProbeDependencies> = {},
-): Promise<void> {
-  const probe = { ...defaultBookmarkProbeDependencies, ...dependencies }
-  const store = await probe.readInstances()
-  const conflicts = findBookmarkTrustConflicts(store, resolved.name, resolved.url, resolved.caFile)
-  try {
-    await probe.checkIssuerReachability(
-      resolved.url,
-      resolved.issuer,
-      resolved.caFile ? probe.fetchWithCaFile(resolved.caFile) : undefined,
-    )
-  } catch (cause) {
-    const original = cause instanceof AstraleError ? cause.hint : undefined
-    const trust = resolved.caFile
-      ? `Bookmark "${resolved.name}" trusts CA ${resolved.caFile}.`
-      : `Bookmark "${resolved.name}" uses the system trust store.`
-    const collision =
-      conflicts.length === 0
-        ? ''
-        : ` The same URL is bookmarked with different TLS trust as ${conflicts
-            .map((conflict) =>
-              conflict.caFile
-                ? `"${conflict.name}" (CA ${conflict.caFile})`
-                : `"${conflict.name}" (system trust)`,
-            )
-            .join(', ')}.`
-    throw new AstraleError(
-      cause instanceof AstraleError ? cause.code : 'ISSUER_UNREACHABLE',
-      `Issuer/JWKS probe failed for bookmark "${resolved.name}" at ${resolved.url}.`,
-      `${trust}${collision}${original ? ` ${original}` : ''} Inspect with \`astrale instance list --bookmarked --json\`.`,
-    )
-  }
-}
-
-interface BookmarkProbeDependencies {
-  readonly readInstances: typeof readInstances
-  readonly checkIssuerReachability: typeof checkIssuerReachability
-  readonly fetchWithCaFile: typeof fetchWithCaFile
-}
-
-const defaultBookmarkProbeDependencies: BookmarkProbeDependencies = Object.freeze({
-  readInstances,
-  checkIssuerReachability,
-  fetchWithCaFile,
-})
-
-async function resolveUseTarget(name: string, opts: UseOpts): Promise<ResolvedInstance> {
-  const [store, managed] = await Promise.all([readInstances(), fetchManagedInstances(name, opts)])
-  const candidates = collectInstanceCandidates(name, store, managed.instances)
-
-  if (candidates.length === 0) {
-    throw new AstraleError(
-      'INSTANCE_NOT_FOUND',
-      `Instance "${name}" is not bookmarked and not admin-managed.\n` +
-        `  Bookmark: astrale instance bookmark ${name} --url <url>\n` +
-        `  Or check: astrale instance list`,
-    )
-  }
-
-  const interactive = !(opts.ci || opts.noPrompt || process.env.CI)
-  const chosen =
-    candidates.length === 1
-      ? candidates[0]
-      : interactive
-        ? await pickCandidate(name, candidates)
-        : null
-  if (!chosen) throw ambiguousError(name, candidates)
-
-  if (chosen.source === 'bookmark') {
-    return await resolveInstance(chosen.key)
-  }
-
-  assertManagedReady(chosen.info)
-  const { repointedFrom } = await upsertManagedBookmark({
-    key: chosen.key,
-    slug: chosen.info.slug,
-    url: chosen.url,
-    ...(chosen.info.organizationId ? { organizationId: chosen.info.organizationId } : {}),
-    ...(managed.identity ? { defaultIdentity: managed.identity } : {}),
-  })
-  if (repointedFrom) {
-    log.warn(`Bookmark "${chosen.key}" repointed: ${repointedFrom} → ${chosen.url}`)
-  }
-  return await resolveInstance(chosen.key)
-}
-
-/**
- * All admin-managed instances (collectInstanceCandidates filters by name).
- * Best-effort: an unreachable or unauthenticated admin kernel degrades to
- * bookmark-only resolution.
- */
-async function fetchManagedInstances(
-  name: string,
-  opts: UseOpts,
-): Promise<{ readonly instances: OwnedInstanceInfo[]; readonly identity?: string }> {
-  try {
-    validateSlug(name)
-  } catch {
-    return { instances: [] }
-  }
-  try {
-    return await listOwnedInstancesWithIdentity(opts)
-  } catch {
-    return { instances: [] }
-  }
-}
-
-function assertManagedReady(info: OwnedInstanceInfo): void {
-  if (info.state === 'ready') return
-  const detail = info.phase && info.phase !== info.state ? ` (${info.phase})` : ''
-  throw new AstraleError(
-    'INSTANCE_NOT_READY',
-    `Instance "${info.slug}" is ${info.state}${detail}; it cannot be selected yet.`,
-    info.error ?? `Run: astrale instance status ${info.slug}`,
-  )
-}
-
-async function pickCandidate(
-  name: string,
-  candidates: InstanceCandidate[],
-): Promise<InstanceCandidate | null> {
-  return selectFrom(
-    `Multiple instances match "${name}":`,
-    candidates.map((candidate) => ({
-      label: describeInstanceCandidate(candidate),
-      value: candidate,
-    })),
-  )
-}
-
-function ambiguousError(name: string, candidates: InstanceCandidate[]): AstraleError {
-  const lines = candidates.map((candidate) => `  - ${describeInstanceCandidate(candidate)}`)
-  return new AstraleError(
-    'INSTANCE_AMBIGUOUS',
-    `Multiple instances match "${name}":\n${lines.join('\n')}`,
-    'Run interactively to pick one, or `astrale instance forget <name>` to drop the stale bookmark.',
-  )
-}
-
-export default {
-  name: 'use',
-  description: 'Set the active kernel instance (no args: show current)',
-  afterHelpText: `
-Behavior:
-  The active instance lives in ~/.astrale/instances.json (a
-  process-global file). Concurrent instance:prepare or parallel test
-  runs can rewrite it under you — in scripted/parallel flows pass
-  -i <instance> on every command instead of relying on \`use\`.
-
-Examples:
-  $ astrale instance use staging
-  $ astrale instance use staging --adopt-default
-`,
-  arguments: [{ name: 'name', description: 'Registered instance name', required: false }],
-  options: [
-    ...ADMIN_TARGET_OPTIONS,
-    {
-      flags: '--adopt-default',
-      description: 'Adopt instance default identity without prompt',
-    },
-    { flags: '--skip-jwks-check', description: 'Skip the OIDC discovery + JWKS liveness probe' },
-  ],
-  action: async (name: string | undefined, opts: UseOpts) => {
-    await useInstance(name, opts)
-  },
-} satisfies CommandDefinition

package/src/commands/introspect.ts

@@ -1,129 +0,0 @@
-import type { DomainBundle, DomainInfo, SchemaApi } from '@astrale-os/sdk/client/schema'
-
-import { Path } from '@astrale-os/sdk/graph/path'
-
-import type { KernelCommandOpts } from '../connection'
-import type { CommandDefinition } from '../program/index'
-
-import { runKernelCommand } from '../connection'
-import { AstraleError } from '../errors'
-import { failInput } from '../lib/log'
-import { output } from '../lib/output'
-import { describeCallableFromBundle, missingCallableDescription } from './call-describe'
-
-type IntrospectOpts = KernelCommandOpts & { bundle?: boolean }
-
-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 {
-    ;({ origin, path } = parseIntrospectTarget(target))
-  } catch (error) {
-    failInput(error, opts)
-  }
-  const wantsCallable = isCallablePath(path)
-
-  await introspect.runKernelCommand({
-    opts,
-    label: `Introspect ${origin}`,
-    fn: async ({ session }) => {
-      if (wantsCallable) {
-        const result = await readInstalledDomain(session.schema, origin, true)
-        const described = describeCallableFromBundle(path, result.bundle)
-        if (described === undefined) throw missingCallableDescription(path.raw)
-        return described
-      }
-      return readInstalledDomain(session.schema, origin, opts.bundle === true)
-    },
-    format: (value, format) => output(value, format),
-  })
-}
-
-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(
-      'NOT_A_DOMAIN',
-      'introspect requires a Domain origin or Path, not an @id.',
-      'Example: astrale introspect kernel.astrale.ai  or  /:kernel.astrale.ai:class.Identity:whois',
-    )
-  }
-  const raw = target.startsWith('/') ? target : `/:${target}`
-  let path: Path
-  try {
-    path = Path.parse(raw)
-  } catch (error) {
-    throw new AstraleError(
-      'PATH_INVALID',
-      error instanceof Error ? error.message : 'Invalid introspect target',
-    )
-  }
-  if (path.ast.anchor.kind !== 'domain') {
-    throw new AstraleError('NOT_A_DOMAIN', 'introspect requires a Domain-rooted Path or origin.')
-  }
-  return { origin: path.ast.anchor.origin, path }
-}
-
-function isCallablePath(path: Path): boolean {
-  const last = path.ast.steps.at(-1)
-  if (last === undefined) return false
-  if (last.kind === 'method') return true
-  return last.kind === 'projection' && last.projection.kind === 'function'
-}
-
-export default {
-  name: 'introspect',
-  description: 'Read installed Domain schema from the Kernel Schema syscall',
-  afterHelpText: `
-Behavior:
-  Calls the public SDK Schema API for one installed Domain. A bare origin
-  (kernel.astrale.ai or /:kernel.astrale.ai) prints its exact revision,
-  generation, publication, readiness, capabilities, and bindings. --bundle
-  includes the schema bundle. A method or Function Path projects that
-  callable's input/output from the installed bundle.
-
-Examples:
-  $ astrale introspect kernel.astrale.ai
-  $ astrale introspect /:kernel.astrale.ai --bundle
-  $ astrale introspect /:kernel.astrale.ai:class.Identity:whois
-  $ astrale introspect /:kernel.astrale.ai:function.journal
-`,
-  arguments: [{ name: 'target', description: 'Domain origin or canonical Path' }],
-  options: [{ flags: '--bundle', description: 'Include the installed schema bundle' }],
-  action: async (target, opts) => {
-    await introspectCommand(target as string, opts as IntrospectOpts)
-  },
-} satisfies CommandDefinition