@astrale-os/cli 1.0.0-beta.4 → 1.0.0-beta.6

package/src/commands/call.ts

@@ -5,7 +5,7 @@ import type { CommandDefinition } from '../program/index'
 
 import { createPathCall, expandSelfInCall, runKernelCommand, withSelfHint } from '../connection'
 import { presentBinary } from '../lib/binary'
-import { failClosed, log } from '../lib/log'
+import { failInput, log } from '../lib/log'
 import { output, present } from '../lib/output'
 
 type CallOpts = KernelCommandOpts & {
@@ -24,60 +24,47 @@ export async function callCommand(
   rawParams: string[],
   opts: CallOpts,
 ): Promise<void> {
-  // Expand @self before describe/execute through authenticated Identity.whoami.
-  let expanded: Awaited<ReturnType<typeof expandSelfInCall>>
-  try {
-    expanded = await expandSelfInCall(path, rawParams, opts)
-  } catch (error) {
-    failClosed(error, opts)
-  }
-  const expandedPath = expanded.path
-  try {
-    Path.parse(expandedPath)
-  } catch (error) {
-    failClosed(error, opts)
-  }
-
-  // ── Parse params ────────────────────────────────────────
   let params: Record<string, unknown>
   try {
-    params = await parseParams([...expanded.parameters], opts.data)
-  } catch (e) {
-    failClosed(e, opts)
-  }
-
-  // ── Dry-run: show what would be sent ─────────────────────
-  if (opts.dryRun) {
-    output({ method: expandedPath, params }, opts)
-    return
+    Path.parse(path)
+    params = await parseParams(rawParams, opts.data)
+  } catch (error) {
+    failInput(error, opts)
   }
 
-  // ── Execute ────────────────────────────────────────────
-  await runKernelCommand<MaterializedCallResult>({
-    opts,
-    label: expandedPath,
-    fn: (ctx) =>
-      withSelfHint(
-        async () =>
-          materializeCallResult(await ctx.session.dispatch(createPathCall(expandedPath, params))),
-        expanded.meta,
-      ),
-    format: async (result, fmtOpts) => {
-      switch (result.kind) {
-        case 'value':
-          present(result.value, fmtOpts)
-          return
-        case 'binary':
-          await presentBinary(result.value, fmtOpts, { outFile: opts.output })
-          return
-        case 'stream':
-          output(result.values, fmtOpts)
-          return
-        case 'redirect':
-          throw new Error('Client Session returned an unresolved redirect.')
-      }
+  await runKernelCommand<MaterializedCallResult | { readonly kind: 'dry'; readonly call: unknown }>(
+    {
+      opts,
+      label: path,
+      fn: async (ctx) => {
+        const expanded = await expandSelfInCall(path, params, ctx)
+        const request = createPathCall(expanded.path, expanded.parameters)
+        if (opts.dryRun) return { kind: 'dry', call: request }
+        return withSelfHint(
+          async () => materializeCallResult(await ctx.session.dispatch(request)),
+          expanded.meta,
+        )
+      },
+      format: async (result, fmtOpts) => {
+        switch (result.kind) {
+          case 'dry':
+            output(result.call, fmtOpts)
+            return
+          case 'value':
+            present(result.value, fmtOpts)
+            return
+          case 'binary':
+            await presentBinary(result.value, fmtOpts, { outFile: opts.output })
+            return
+          case 'stream':
+            output(result.values, fmtOpts)
+            return
+          case 'redirect':
+            throw new Error('Client Session returned an unresolved redirect.')
+        }
+      },
     },
-  })
+  )
 }
 
 /** Drain a session-backed stream before the command-scoped Client Session closes. */
@@ -101,7 +88,7 @@ export async function parseParams(
     try {
       return JSON.parse(dataFlag)
     } catch {
-      throw new Error(`Invalid JSON in --data: ${dataFlag}`)
+      throw new TypeError(`Invalid JSON in --data: ${dataFlag}`)
     }
   }
 
@@ -114,7 +101,7 @@ export async function parseParams(
     try {
       return JSON.parse(stdin)
     } catch {
-      throw new Error('Invalid JSON from stdin')
+      throw new TypeError('Invalid JSON from stdin')
     }
   }
 
@@ -142,7 +129,7 @@ export function parseKeyValue(pairs: string[]): Record<string, unknown> {
   for (const pair of pairs) {
     const eqIdx = pair.indexOf('=')
     if (eqIdx === -1) {
-      throw new Error(`Invalid param "${pair}" — expected key=value format`)
+      throw new TypeError(`Invalid param "${pair}" — expected key=value format`)
     }
     const key = pair.slice(0, eqIdx)
     const raw = pair.slice(eqIdx + 1)
@@ -150,7 +137,7 @@ export function parseKeyValue(pairs: string[]): Record<string, unknown> {
       const hint = key.endsWith(':')
         ? ` (looks like httpie's "key:=value" syntax — Astrale CLI doesn't support it; use --data '{"${key.slice(0, -1)}":<value>}' for nested values)`
         : ` (keys must be identifier-shaped: letters, digits, underscore, hyphen)`
-      throw new Error(`Invalid param key "${key}" in "${pair}"${hint}`)
+      throw new TypeError(`Invalid param key "${key}" in "${pair}"${hint}`)
     }
     result[key] = coerceValue(raw)
   }

package/src/commands/domain/install.ts

@@ -1,5 +1,5 @@
 import { Path } from '@astrale-os/sdk/graph/path'
-import { syscalls } from '@astrale-os/sdk/schema/kernel'
+import { K } from '@astrale-os/sdk/schema'
 import chalk from 'chalk'
 
 import type { KernelCommandOpts } from '../../connection'
@@ -414,7 +414,7 @@ export async function installDirect(
     fn: async ({ session }) =>
       (await session.call(
         createPathCall(
-          Path.project(syscalls.install.ref).raw,
+          Path.project(K.functions.install.ref).raw,
           directInstallCallInput(url, operation, opts.token),
         ),
       )) as DirectInstallResult,

package/src/commands/domain/uninstall.ts

@@ -1,5 +1,5 @@
 import { Path } from '@astrale-os/sdk/graph/path'
-import { syscalls } from '@astrale-os/sdk/schema/kernel'
+import { K } from '@astrale-os/sdk/schema'
 import chalk from 'chalk'
 
 import type { KernelCommandOpts } from '../../connection'
@@ -77,7 +77,7 @@ Examples:
       label: `Uninstalling domain ${origin}`,
       fn: async ({ session }) =>
         (await session.call(
-          createPathCall(Path.project(syscalls.uninstall.ref).raw, uninstallCallInput(origin)),
+          createPathCall(Path.project(K.functions.uninstall.ref).raw, uninstallCallInput(origin)),
         )) as UninstallResult,
       format: (result, formatOpts, machine) => {
         if (machine) {

package/src/commands/get.ts

@@ -4,40 +4,39 @@ import type { KernelCommandOpts } from '../connection'
 import type { CommandDefinition } from '../program/index'
 
 import { expandSelfInPath, runKernelCommand, withSelfHint } from '../connection'
-import { formatKernelError } from '../connection/errors'
 import { AstraleError } from '../errors'
-import { denoise, isMachine, output } from '../lib/output'
+import { failInput, fatal } from '../lib/log'
+import { denoise, output } from '../lib/output'
 
 type GetOpts = KernelCommandOpts & { schema?: boolean }
 
 /** Read one exact canonical Node. The caller's Path is not fabricated into the Node value. */
 export async function getCommand(target: string, opts: GetOpts): Promise<void> {
-  let path: string
-  let meta
   let parsed
   try {
-    ;({ path, meta } = await expandSelfInPath(target, opts))
-    parsed = Path.parse(path)
+    parsed = Path.parse(target)
   } catch (error) {
-    await formatKernelError(error, isMachine(opts), undefined, opts.debug)
-    process.exit(1)
+    failInput(error, opts)
   }
 
   const last = parsed.ast.steps.at(-1)
   if (last?.kind === 'method') {
     const error = new AstraleError(
       'NOT_A_NODE',
-      `${path} is a callable Path, not a Node.`,
-      `Use \`astrale call ${path}\` or \`astrale introspect ${path}\`.`,
+      `${target} is a callable Path, not a Node.`,
+      `Use \`astrale call ${target}\` or \`astrale introspect ${target}\`.`,
     )
-    await formatKernelError(error, isMachine(opts), undefined, opts.debug)
-    process.exit(1)
+    fatal(error, opts)
   }
 
   await runKernelCommand({
     opts,
-    label: `Node ${path}`,
-    fn: ({ graph }) => withSelfHint(() => graph.getOrThrow(parsed), meta),
+    label: `Node ${target}`,
+    fn: async (context) => {
+      const { path, meta } = await expandSelfInPath(target, context)
+      const resolved = meta === undefined ? parsed : Path.parse(path)
+      return withSelfHint(() => context.graph.getOrThrow(resolved), meta)
+    },
     format: (node, format) => output(opts.schema === true ? node : denoise(node), format),
   })
 }

package/src/commands/identity/__tests__/register.test.ts

@@ -1,9 +1,9 @@
 import { issuer, jwk, provision } from '@astrale-os/sdk/auth'
-import { ClassPath } from '@astrale-os/sdk/graph/class'
 import { normalizeProperties } from '@astrale-os/sdk/graph/properties'
 import { expect, mock, test } from 'bun:test'
 import { exportJWK, generateKeyPair, jwtVerify } from 'jose'
 
+import { classKey } from '../../../graph'
 import { formatIdentityRegistration, prepareIdentityProvision } from '../register'
 
 /** @evidence TEST-CLI-IDENTITY-REGISTER-JSON-EXACT */
@@ -46,7 +46,7 @@ test('builds one exact Mutation V3 identity birth bound to a self proof', async
     kid: 'alice-key',
   })
   const kernelIssuer = issuer.accept('https://kernel.example')
-  const classPath = ClassPath.parse('/:accounts.example:class.User')
+  const classPath = classKey('/:accounts.example:class.User', '--class')
   const properties = normalizeProperties({
     'accounts.example:class.User.property.name': 'Alice',
   })
@@ -70,7 +70,7 @@ test('builds one exact Mutation V3 identity birth bound to a self proof', async
       {
         op: 'node.create',
         as: 'identity',
-        class: '/:accounts.example:class.User',
+        class: 'accounts.example:class.User',
         props: { 'accounts.example:class.User.property.name': 'Alice' },
       },
     ],

package/src/commands/identity/register.ts

@@ -1,9 +1,9 @@
 import type { IssuerId, JsonWebKey, ProvisionRequest } from '@astrale-os/sdk/auth'
+import type { ClassKey as ClassKeyValue } from '@astrale-os/sdk/graph/class'
 import type { JWK } from 'jose'
 
 import { provision, jwk } from '@astrale-os/sdk/auth'
-import { ClassPath } from '@astrale-os/sdk/graph/class'
-import { LocalBinding } from '@astrale-os/sdk/graph/model'
+import { LocalBinding } from '@astrale-os/sdk/graph'
 import { normalizeProperties } from '@astrale-os/sdk/graph/properties'
 import { MutationAST } from '@astrale-os/sdk/mutation'
 import { importJWK, SignJWT } from 'jose'
@@ -14,6 +14,7 @@ import type { IdentityRegistrationResult } from '../../identity/index'
 import type { CommandDefinition } from '../../program/index'
 
 import { registrationKeyForTarget, runKernelCommand } from '../../connection'
+import { classKey } from '../../graph'
 import { getIdentity, setRegistration, submitIdentityProvision } from '../../identity/index'
 import { fileExists, keypairPaths } from '../../keys/index'
 import { fatal, log } from '../../lib/log'
@@ -83,7 +84,7 @@ Example:
 
       const privateKey = await readJwk(privatePath)
       const publicKey = jwk.acceptPublic(await readJwk(publicPath))
-      const classPath = ClassPath.parse(opts.class)
+      const classPath = classKey(opts.class, '--class')
       const properties = normalizeProperties(opts.props ? JSON.parse(opts.props) : {})
 
       await runKernelCommand<IdentityRegistrationResult>({
@@ -142,7 +143,7 @@ export function formatIdentityRegistration(
 /** Build and self-prove one exact canonical provision request for the target Kernel. */
 export async function prepareIdentityProvision(input: {
   readonly name: string
-  readonly classPath: ReturnType<typeof ClassPath.parse>
+  readonly classPath: ClassKeyValue
   readonly properties: ReturnType<typeof normalizeProperties>
   readonly privateKey: JWK
   readonly publicKey: JsonWebKey

package/src/commands/instance/delete.ts

@@ -1,6 +1,7 @@
 import type { KernelCommandOpts } from '../../connection'
 import type { CommandDefinition } from '../../program/index'
 
+import { AdminInstanceNotFoundError } from '../../admin/instance'
 import { deleteOwnedInstance } from '../../lib/admin-instance'
 import { ADMIN_TARGET_OPTIONS, type AdminTargetCommandOpts } from '../../lib/admin-target'
 import { clearActive, readInstances, removeInstance, resolveInstanceKey } from '../../lib/instance'
@@ -53,9 +54,10 @@ Behavior:
     } catch (e) {
       // Bookmark-only id → no admin Instance → kernel NOT_FOUND. Point to
       // `forget` (local drop) instead of surfacing the raw path error.
-      const notManaged =
-        e instanceof Error && (e.name === 'NotFoundError' || e.message.startsWith('Path not found'))
-      if (notManaged && resolveInstanceKey(await readInstances(), id)) {
+      if (
+        e instanceof AdminInstanceNotFoundError &&
+        resolveInstanceKey(await readInstances(), id)
+      ) {
         log.error(`No admin-managed instance "${id}".`)
         log.dim(`  hint: it's a local bookmark — drop it with: astrale instance forget ${id}`)
         process.exit(1)

package/src/commands/instance/status.ts

@@ -3,7 +3,6 @@ import chalk from 'chalk'
 import type { KernelCommandOpts } from '../../connection'
 import type { CommandDefinition } from '../../program/index'
 
-import { AstraleError } from '../../errors'
 import { statusOwnedInstance } from '../../lib/admin-instance'
 import { ADMIN_TARGET_OPTIONS, type AdminTargetCommandOpts } from '../../lib/admin-target'
 import { fatal, log, withSpinner } from '../../lib/log'
@@ -19,14 +18,7 @@ export default {
   action: async (id: string, opts: StatusOpts) => {
     try {
       const result = await withSpinner(`Fetching instance ${id}`, !isMachine(opts), () =>
-        statusOwnedInstance(opts, id).catch((error) => {
-          if (!(error instanceof Error) || error.name !== 'NotFoundError') throw error
-          throw new AstraleError(
-            'INSTANCE_NOT_FOUND',
-            `No owned instance matches "${id}".`,
-            'Run `astrale instance list` to see your instances.',
-          )
-        }),
+        statusOwnedInstance(opts, id),
       )
       if (isMachine(opts)) {
         output(result, opts)

package/src/commands/introspect.ts

@@ -5,9 +5,9 @@ import type { CommandDefinition } from '../program/index'
 
 import { runKernelCommand } from '../connection'
 import { AstraleError } from '../errors'
-import { failClosed } from '../lib/log'
+import { failInput } from '../lib/log'
 import { output } from '../lib/output'
-import { describeCallableFromSchema, missingCallableDescription } from './call-describe'
+import { describeCallableFromBundle, missingCallableDescription } from './call-describe'
 
 type IntrospectOpts = KernelCommandOpts & { bundle?: boolean }
 
@@ -17,7 +17,7 @@ export async function introspectCommand(target: string, opts: IntrospectOpts): P
   try {
     ;({ origin, path } = parseIntrospectTarget(target))
   } catch (error) {
-    failClosed(error, opts)
+    failInput(error, opts)
   }
   const wantsCallable = isCallablePath(path)
 
@@ -44,7 +44,7 @@ export async function introspectCommand(target: string, opts: IntrospectOpts): P
         )
       }
       if (wantsCallable) {
-        const described = describeCallableFromSchema(path, bundleRoot(result.bundle))
+        const described = describeCallableFromBundle(path, result.bundle)
         if (described === undefined) throw missingCallableDescription(path.raw)
         return described
       }
@@ -85,13 +85,6 @@ function isCallablePath(path: Path): boolean {
   return last.kind === 'projection' && last.projection.kind === 'function'
 }
 
-function bundleRoot(bundle: unknown): unknown {
-  if (bundle !== null && typeof bundle === 'object' && 'root' in bundle) {
-    return (bundle as { root: unknown }).root
-  }
-  return bundle
-}
-
 export default {
   name: 'introspect',
   description: 'Read installed Domain schema from the Kernel Schema syscall',

package/src/commands/logs.ts

@@ -1,21 +1,16 @@
 import { Path } from '@astrale-os/sdk/graph/path'
-import { syscalls } from '@astrale-os/sdk/schema/kernel'
+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,
-  withClientSession,
-} from '../connection'
-import { failClosed } from '../lib/log'
+import { createPathCall, expandSelfInPath, runKernelCommand } from '../connection'
+import { failInput } from '../lib/log'
 import { isMachine, output, presentList } from '../lib/output'
 
-const JOURNAL_PATH = Path.project(syscalls.journal.ref).raw
+const JOURNAL_PATH = Path.project(K.functions.journal.ref).raw
 const DEFAULT_LIMIT = 200
 const FOLLOW_INTERVAL_MS = 2_000
 
@@ -127,7 +122,7 @@ async function runOnce(opts: LogsOpts): Promise<void> {
   await runKernelCommand({
     opts,
     label: 'Kernel journal',
-    fn: (context) => fetchPage(context, opts),
+    fn: async (context) => fetchPage(context, await resolveLogsOpts(opts, context)),
     format: (page, format) => {
       if (isMachine(format) || format.format !== undefined) output(page, format)
       else {
@@ -139,14 +134,19 @@ async function runOnce(opts: LogsOpts): Promise<void> {
 }
 
 async function follow(opts: LogsOpts): Promise<void> {
-  await withClientSession(opts, async (context) => {
-    let cursor = opts.cursor
-    for (;;) {
-      const page = await fetchPage(context, { ...opts, cursor })
-      for (const record of page.records) printRecord(record)
-      cursor = page.cursor ?? cursor
-      await new Promise((resolve) => setTimeout(resolve, FOLLOW_INTERVAL_MS))
-    }
+  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))
+      }
+    },
   })
 }
 
@@ -227,11 +227,10 @@ function positiveInteger(flag: string, raw: string): number {
   return value
 }
 
-async function prepareLogsOpts(opts: LogsOpts): Promise<LogsOpts> {
-  buildJournalInput(opts)
+async function resolveLogsOpts(opts: LogsOpts, context: ConnectionContext): Promise<LogsOpts> {
   const principal = nonEmpty(opts.principal)
   if (principal !== '@self') return opts
-  const { path } = await expandSelfInPath('@self', opts)
+  const { path } = await expandSelfInPath('@self', context)
   return { ...opts, principal: path.startsWith('@') ? path.slice(1) : path }
 }
 
@@ -274,11 +273,11 @@ Examples:
   ],
   action: async (opts: LogsOpts) => {
     try {
-      const prepared = await prepareLogsOpts(opts)
-      if (prepared.follow) await follow(prepared)
-      else await runOnce(prepared)
+      buildJournalInput(opts)
     } catch (error) {
-      failClosed(error, opts)
+      failInput(error, opts)
     }
+    if (opts.follow) await follow(opts)
+    else await runOnce(opts)
   },
 } satisfies CommandDefinition

package/src/commands/mutate.ts

@@ -7,8 +7,9 @@ import type { KernelCommandOpts } from '../connection'
 import type { CommandDefinition } from '../program/index'
 
 import { runKernelCommand } from '../connection'
+import { AstraleError } from '../errors'
 import { prepareMutation } from '../graph/index'
-import { failClosed } from '../lib/log'
+import { failInput } from '../lib/log'
 import { output } from '../lib/output'
 import { renderTable } from '../lib/table'
 
@@ -23,7 +24,7 @@ export async function mutateCommand(opts: MutateOpts): Promise<void> {
   try {
     mutation = prepareMutation(await readDocument(opts))
   } catch (error) {
-    failClosed(error, opts)
+    failInput(error, opts)
   }
 
   if (opts.dry) {
@@ -51,9 +52,9 @@ async function readDocument(opts: MutateOpts): Promise<unknown> {
     try {
       raw = await readFile(opts.file, 'utf8')
     } catch (error) {
-      throw new Error(
-        `Cannot read --file ${opts.file}: ${error instanceof Error ? error.message : error}`,
-      )
+      throw new AstraleError('FILE_READ_FAILED', `Cannot read --file ${opts.file}.`, undefined, {
+        cause: error,
+      })
     }
     return parseJson(raw, opts.file)
   }

package/src/commands/query.ts

@@ -6,8 +6,9 @@ import type { KernelCommandOpts, SelfExpansionMeta } from '../connection'
 import type { CommandDefinition } from '../program/index'
 
 import { expandSelfInPath, runKernelCommand, withSelfHint } from '../connection'
+import { AstraleError } from '../errors'
 import { prepareQuery, type QueryCommandInput } from '../graph/index'
-import { failClosed } from '../lib/log'
+import { failInput } from '../lib/log'
 import { isMachine, output } from '../lib/output'
 
 type QueryOpts = KernelCommandOpts & {
@@ -22,46 +23,42 @@ type QueryOpts = KernelCommandOpts & {
 
 export async function queryCommand(sources: string[], opts: QueryOpts): Promise<void> {
   let input: QueryCommandInput
-  let meta: SelfExpansionMeta | undefined
   try {
     const ast = await readAst(opts)
-    if (ast === undefined) {
-      const expanded = await Promise.all(sources.map((source) => expandSelfInPath(source, opts)))
-      input = {
-        sources: expanded.map(({ path }) => path),
-        definition: opts.definition,
-        edge: opts.edge,
-        direction: opts.direction,
-        limit: opts.limit,
-        cursor: opts.cursor,
-      }
-      meta = expanded.find((entry) => entry.meta !== undefined)?.meta
-    } else {
-      input = {
-        sources,
-        ast,
-        definition: opts.definition,
-        edge: opts.edge,
-        direction: opts.direction,
-        limit: opts.limit,
-        cursor: opts.cursor,
-      }
+    input = {
+      sources,
+      ...(ast === undefined ? {} : { ast }),
+      definition: opts.definition,
+      edge: opts.edge,
+      direction: opts.direction,
+      limit: opts.limit,
+      cursor: opts.cursor,
     }
   } catch (error) {
-    failClosed(error, opts)
+    failInput(error, opts)
   }
 
   let prepared
   try {
     prepared = prepareQuery(input)
   } catch (error) {
-    failClosed(error, opts)
+    failInput(error, opts)
   }
 
   await runKernelCommand({
     opts,
     label: 'Query',
-    fn: ({ graph }) => withSelfHint(() => graph.query(prepared.ast, { page: prepared.page }), meta),
+    fn: async (context) => {
+      const expanded = await Promise.all(sources.map((source) => expandSelfInPath(source, context)))
+      const meta: SelfExpansionMeta | undefined = expanded.find(
+        (entry) => entry.meta !== undefined,
+      )?.meta
+      const resolved =
+        meta === undefined
+          ? prepared
+          : prepareQuery({ ...input, sources: expanded.map(({ path }) => path) })
+      return withSelfHint(() => context.graph.query(resolved.ast, { page: resolved.page }), meta)
+    },
     format: (response, format) => {
       output(response.result, format)
       if (response.page.next && !isMachine(format)) {
@@ -81,9 +78,9 @@ async function readAst(opts: QueryOpts): Promise<unknown | undefined> {
   try {
     raw = await readFile(opts.file, 'utf8')
   } catch (error) {
-    throw new Error(
-      `Cannot read --file ${opts.file}: ${error instanceof Error ? error.message : error}`,
-    )
+    throw new AstraleError('FILE_READ_FAILED', `Cannot read --file ${opts.file}.`, undefined, {
+      cause: error,
+    })
   }
   return parseJson(raw, opts.file)
 }
@@ -122,7 +119,7 @@ Examples:
     { flags: '-f, --file <path>', description: 'Read a canonical Query V6 document from a file' },
     {
       flags: '--definition <path>',
-      description: 'Select Nodes implementing one exact Class or Interface',
+      description: 'Select Nodes satisfying one exact Class',
     },
     { flags: '--edge <class>', description: 'Expand one exact Edge Class' },
     {

package/src/commands/token.ts

@@ -6,7 +6,7 @@ import type { CommandDefinition } from '../program/index'
 import { runKernelCommand } from '../connection'
 import { AstraleError } from '../errors'
 import { decodeJwtExpiration } from '../lib/local-status'
-import { failClosed, log } from '../lib/log'
+import { failInput, log } from '../lib/log'
 import { output } from '../lib/output'
 
 /**
@@ -23,7 +23,12 @@ export type TokenOpts = KernelCommandOpts & {
 
 export async function tokenCommand(opts: TokenOpts): Promise<void> {
   const commandOpts: TokenOpts = opts.for && !opts.as ? { ...opts, as: opts.for } : opts
-  const ttl = parseTtl(commandOpts.ttl)
+  let ttl: number
+  try {
+    ttl = parseTtl(commandOpts.ttl)
+  } catch (error) {
+    failInput(error, opts)
+  }
   await runKernelCommand<string>({
     opts: commandOpts,
     label: 'Minting delegation token',
@@ -97,10 +102,6 @@ Examples:
     { flags: '--for <identity>', description: 'Mint the token for this identity (alias of --as)' },
   ],
   action: async (opts) => {
-    try {
-      await tokenCommand(opts as Parameters<typeof tokenCommand>[0])
-    } catch (error) {
-      failClosed(error, opts as TokenOpts)
-    }
+    await tokenCommand(opts as Parameters<typeof tokenCommand>[0])
   },
 } satisfies CommandDefinition