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

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,110 +0,0 @@
-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 }
-
-export async function introspectCommand(target: string, opts: IntrospectOpts): Promise<void> {
-  let origin: string
-  let path: Path
-  try {
-    ;({ origin, path } = parseIntrospectTarget(target))
-  } catch (error) {
-    failInput(error, opts)
-  }
-  const wantsCallable = isCallablePath(path)
-
-  await runKernelCommand({
-    opts,
-    label: `Introspect ${origin}`,
-    fn: async ({ session }) => {
-      const includeBundle = wantsCallable || opts.bundle === true
-      const result = await session.schema.introspect({
-        from: { kind: 'installation', origin },
-        select: {
-          state: true,
-          target: true,
-          source: true,
-          readiness: true,
-          capabilities: true,
-          ...(includeBundle ? { bundle: true as const } : {}),
-        },
-      })
-      if (result === null) {
-        throw new AstraleError(
-          'DOMAIN_NOT_INSTALLED',
-          `Domain ${origin} is not installed on this Kernel.`,
-        )
-      }
-      if (wantsCallable) {
-        const described = describeCallableFromBundle(path, result.bundle)
-        if (described === undefined) throw missingCallableDescription(path.raw)
-        return described
-      }
-      return result
-    },
-    format: (value, format) => output(value, format),
-  })
-}
-
-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 Kernel introspect syscall for one installed Domain.
-  A bare origin (kernel.astrale.ai or /:kernel.astrale.ai) prints installation
-  state, target, source, readiness, and capabilities. --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

package/src/commands/logs.ts

@@ -1,283 +0,0 @@
-import { Path } from '@astrale-os/sdk/graph/path'
-import { K } from '@astrale-os/sdk/schema'
-import chalk from 'chalk'
-
-import type { ConnectionContext, KernelCommandOpts } from '../connection'
-import type { Column, ListProjection } from '../lib/output'
-import type { CommandDefinition } from '../program/index'
-
-import { createPathCall, expandSelfInPath, runKernelCommand } from '../connection'
-import { failInput } from '../lib/log'
-import { isMachine, output, presentList } from '../lib/output'
-
-const JOURNAL_PATH = Path.project(K.functions.journal.ref).raw
-const DEFAULT_LIMIT = 200
-const FOLLOW_INTERVAL_MS = 2_000
-
-type LogsOpts = KernelCommandOpts & {
-  since?: string
-  until?: string
-  topic?: string
-  topicPrefix?: string
-  principal?: string
-  limit?: string
-  cursor?: string
-  follow?: boolean
-}
-
-export interface JournalRecord {
-  readonly sequence: number
-  readonly timestamp: string
-  readonly topic: string
-  readonly payload: unknown
-  readonly occurredAt?: string
-  readonly committedAt?: string
-  readonly principal?: string
-  readonly correlationId?: string
-  readonly causationId?: string
-}
-
-export interface JournalPage {
-  readonly records: readonly JournalRecord[]
-  readonly cursor?: string
-}
-
-export interface JournalInput {
-  readonly topics?: { readonly exact?: readonly string[]; readonly prefixes?: readonly string[] }
-  readonly principal?: string
-  readonly since?: string
-  readonly until?: string
-  readonly cursor?: string
-  readonly limit: number
-}
-
-const ISO_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/
-const CURSOR_TOKEN = /^[A-Za-z0-9._:+=/-]{8,}$/
-
-/** Map flags to the exact public journal syscall input without legacy glob/sequence lowering. */
-export function buildJournalInput(opts: LogsOpts): JournalInput {
-  const exact = nonEmpty(opts.topic)
-  const prefix = nonEmpty(opts.topicPrefix)
-  const since = timestampFlag('--since', opts.since)
-  const until = timestampFlag('--until', opts.until)
-  if (since !== undefined && until !== undefined && Date.parse(since) > Date.parse(until)) {
-    throw new TypeError('--since must be earlier than or equal to --until')
-  }
-  return {
-    ...(exact === undefined && prefix === undefined
-      ? {}
-      : {
-          topics: {
-            ...(exact === undefined ? {} : { exact: [exact] }),
-            ...(prefix === undefined ? {} : { prefixes: [prefix] }),
-          },
-        }),
-    ...(nonEmpty(opts.principal) === undefined ? {} : { principal: opts.principal }),
-    ...(since === undefined ? {} : { since }),
-    ...(until === undefined ? {} : { until }),
-    ...(opts.cursor === undefined ? {} : { cursor: cursorFlag(opts.cursor) }),
-    limit: opts.limit === undefined ? DEFAULT_LIMIT : positiveInteger('--limit', opts.limit),
-  }
-}
-
-function timestampFlag(name: string, raw: string | undefined): string | undefined {
-  const value = nonEmpty(raw)
-  if (value === undefined) return undefined
-  if (!ISO_TIMESTAMP.test(value) || Number.isNaN(Date.parse(value))) {
-    throw new TypeError(`${name} must be an ISO-8601 timestamp (e.g. 2026-08-19T16:51:10.049Z)`)
-  }
-  return value
-}
-
-function cursorFlag(raw: string): string {
-  const value = raw.trim()
-  if (!CURSOR_TOKEN.test(value)) {
-    throw new TypeError('--cursor must be an opaque journal resume token (at least 8 characters)')
-  }
-  return value
-}
-
-/** Validate the record fields the CLI presentation consumes and retain the opaque cursor. */
-export function acceptJournalPage(input: unknown): JournalPage {
-  if (!isRecord(input) || !Array.isArray(input.records)) {
-    throw new TypeError('Kernel journal response must contain a records array')
-  }
-  const records = input.records.map((record, index) => acceptRecord(record, index))
-  if (input.cursor !== undefined && typeof input.cursor !== 'string') {
-    throw new TypeError('Kernel journal cursor must be text')
-  }
-  return Object.freeze({
-    records: Object.freeze(records),
-    ...(input.cursor === undefined ? {} : { cursor: input.cursor }),
-  })
-}
-
-async function fetchPage(context: ConnectionContext, opts: LogsOpts): Promise<JournalPage> {
-  return acceptJournalPage(
-    await context.session.call(createPathCall(JOURNAL_PATH, buildJournalInput(opts))),
-  )
-}
-
-async function runOnce(opts: LogsOpts): Promise<void> {
-  await runKernelCommand({
-    opts,
-    label: 'Kernel journal',
-    fn: async (context) => fetchPage(context, await resolveLogsOpts(opts, context)),
-    format: (page, format) => {
-      if (isMachine(format) || format.format !== undefined) output(page, format)
-      else {
-        presentList([...page.records], format, journalProjection)
-        if (page.cursor) process.stderr.write(`  cursor: ${page.cursor}\n`)
-      }
-    },
-  })
-}
-
-async function follow(opts: LogsOpts): Promise<void> {
-  await runKernelCommand({
-    opts,
-    label: 'Kernel journal',
-    fn: async (context): Promise<never> => {
-      const resolved = await resolveLogsOpts(opts, context)
-      let cursor = resolved.cursor
-      for (;;) {
-        const page = await fetchPage(context, { ...resolved, cursor })
-        for (const record of page.records) printRecord(record)
-        cursor = page.cursor ?? cursor
-        await new Promise((resolve) => setTimeout(resolve, FOLLOW_INTERVAL_MS))
-      }
-    },
-  })
-}
-
-function journalProjection(records: JournalRecord[]): ListProjection {
-  const columns: Column[] = [
-    { key: 'sequence', header: 'SEQ', color: chalk.dim },
-    { key: 'timestamp', header: 'TIME', color: chalk.dim },
-    { key: 'topic', header: 'TOPIC', color: chalk.cyan },
-    { key: 'principal', header: 'PRINCIPAL', color: chalk.dim },
-  ]
-  return {
-    columns,
-    rows: records.map((record) => ({
-      sequence: String(record.sequence),
-      timestamp: record.timestamp,
-      topic: record.topic,
-      principal: record.principal ?? '',
-    })),
-    paths: records.map((record) => String(record.sequence)),
-  }
-}
-
-function printRecord(record: JournalRecord): void {
-  process.stdout.write(
-    `${chalk.dim(String(record.sequence).padStart(6))} ${chalk.dim(record.timestamp)} ${chalk.cyan(record.topic)} ${chalk.dim(record.principal ?? '')}\n`,
-  )
-}
-
-function acceptRecord(input: unknown, index: number): JournalRecord {
-  if (
-    !isRecord(input) ||
-    !Number.isSafeInteger(input.sequence) ||
-    typeof input.topic !== 'string'
-  ) {
-    throw new TypeError(`Kernel journal record ${index} is invalid`)
-  }
-  const occurredAt = optionalText(input.occurredAt, index, 'occurredAt')
-  const timestamp = optionalText(input.timestamp, index, 'timestamp') ?? occurredAt
-  if (timestamp === undefined) {
-    throw new TypeError(`Kernel journal record ${index} is missing occurredAt/timestamp`)
-  }
-  const correlation = isRecord(input.correlation) ? input.correlation : undefined
-  const correlationId =
-    optionalText(input.correlationId, index, 'correlationId') ??
-    optionalText(correlation?.invocationId, index, 'correlation.invocationId')
-  const principal = optionalText(input.principal, index, 'principal')
-  return Object.freeze({
-    sequence: input.sequence as number,
-    timestamp,
-    topic: input.topic,
-    payload: input.payload,
-    ...(occurredAt === undefined ? {} : { occurredAt }),
-    ...(optionalText(input.committedAt, index, 'committedAt') === undefined
-      ? {}
-      : { committedAt: input.committedAt as string }),
-    ...(principal === undefined ? {} : { principal }),
-    ...(correlationId === undefined ? {} : { correlationId }),
-    ...(optionalText(input.causationId, index, 'causationId') === undefined
-      ? {}
-      : { causationId: input.causationId as string }),
-  })
-}
-
-function optionalText(input: unknown, index: number, field: string): string | undefined {
-  if (input === undefined) return undefined
-  if (typeof input !== 'string') {
-    throw new TypeError(`Kernel journal record ${index}.${field} must be text`)
-  }
-  return input
-}
-
-function positiveInteger(flag: string, raw: string): number {
-  if (!/^\d+$/.test(raw)) throw new TypeError(`${flag} must be a positive integer`)
-  const value = Number.parseInt(raw, 10)
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new TypeError(`${flag} must be a positive integer`)
-  }
-  return value
-}
-
-async function resolveLogsOpts(opts: LogsOpts, context: ConnectionContext): Promise<LogsOpts> {
-  const principal = nonEmpty(opts.principal)
-  if (principal !== '@self') return opts
-  const { path } = await expandSelfInPath('@self', context)
-  return { ...opts, principal: path.startsWith('@') ? path.slice(1) : path }
-}
-
-function nonEmpty(input: string | undefined): string | undefined {
-  const value = input?.trim()
-  return value ? value : undefined
-}
-
-function isRecord(input: unknown): input is Record<string, unknown> {
-  return input !== null && typeof input === 'object' && !Array.isArray(input)
-}
-
-export default {
-  name: 'logs',
-  description: 'Read or follow the authorized Kernel journal',
-  afterHelpText: `
-Behavior:
-  Calls the public Kernel journal syscall and emits its { records, cursor }
-  page. Topic selection is exact or prefix-based; cursors and timestamps are
-  opaque strings owned by the journal backend. --follow reuses one Client Session
-  and advances only with the returned cursor.
-
-  Historical event-glob lowering and the application-specific services-domain
-  log buffer are not part of the Kernel V2 journal contract.
-
-Examples:
-  $ astrale logs -i staging --limit 50
-  $ astrale logs --topic op:function.failed
-  $ astrale logs --topic-prefix op:function. --follow
-`,
-  options: [
-    { flags: '--since <timestamp>', description: 'Inclusive journal timestamp lower bound' },
-    { flags: '--until <timestamp>', description: 'Inclusive journal timestamp upper bound' },
-    { flags: '--topic <topic>', description: 'Match one exact topic' },
-    { flags: '--topic-prefix <prefix>', description: 'Match one topic prefix' },
-    { flags: '--principal <id>', description: 'Filter by triggering identity ID' },
-    { flags: '--limit <n>', description: `Maximum records (default: ${DEFAULT_LIMIT})` },
-    { flags: '--cursor <token>', description: 'Resume from an opaque journal cursor' },
-    { flags: '--follow', description: 'Poll using returned cursors until interrupted' },
-  ],
-  action: async (opts: LogsOpts) => {
-    try {
-      buildJournalInput(opts)
-    } catch (error) {
-      failInput(error, opts)
-    }
-    if (opts.follow) await follow(opts)
-    else await runOnce(opts)
-  },
-} satisfies CommandDefinition