@astrale-os/cli 0.4.0-alpha.13 → 0.6.0-alpha.0

package/src/commands/identity/register.ts

@@ -1,11 +1,10 @@
-import { K } from '@astrale-os/kernel-core'
 import { importJWK, SignJWT, type JWK } from 'jose'
 import { readFile } from 'node:fs/promises'
 
 import type { CommandDefinition } from '../../command'
-import type { KernelCommandOpts } from '../../kernel'
+import type { ClientContext, KernelCommandOpts } from '../../kernel'
 
-import { runKernelCommand } from '../../kernel'
+import { bindGraph, runKernelCommand } from '../../kernel'
 import { KERNEL_PASSTHROUGH_OPTIONS } from '../../kernel/options'
 import { getIdentity, setRegistration } from '../../lib/identity'
 import { getActive } from '../../lib/instance'
@@ -13,7 +12,6 @@ import { fileExists, keypairPaths } from '../../lib/keys'
 import { fatal, log } from '../../lib/log'
 import { output } from '../../lib/output'
 
-type CreateNodeResult = { id: string; path: string }
 type RegisterIdentityResult = { iss: string; sub: string }
 
 type RegisterOpts = KernelCommandOpts & {
@@ -27,37 +25,32 @@ async function readJwk(path: string): Promise<JWK> {
   return JSON.parse(raw) as JWK
 }
 
-type ChildNode = { class?: string; path?: string }
-
 /**
  * Discover the identity-bearer class on the target instance: find the
- * installed distribution domain (whatever its origin — `dist.astrale.ai` in
- * prod, `dist.localhost` locally) and address its `User` class semantically.
+ * installed domain that owns a `User` class (workspace on managed instances)
+ * and address it semantically.
  * The bearer class must exist before a non-root identity can be registered;
  * failing here names the real problem instead of surfacing as a confusing
- * permission error on a hardcoded prod origin.
+ * permission error on a hardcoded origin.
  */
-async function resolveUserClassPath(ctx: {
-  client: { call(path: string, params: unknown): Promise<unknown> }
-}): Promise<string> {
-  const children = (await ctx.client.call('/::listChildren', {})) as ChildNode[]
-  const domains = children
-    .filter((c) => typeof c.class === 'string' && c.class.endsWith(':class.Domain'))
-    .map((c) => (c.path ?? '').replace(/^\//, ''))
+async function resolveUserClassPath(ctx: ClientContext): Promise<string> {
+  const graph = bindGraph(ctx)
+  // Root's direct children are the installed Domain nodes.
+  const result = await graph.children('/')
+  const domains = result.nodes
+    .filter((n) => n.class.className === 'Domain')
+    .map((n) => n.path.raw.replace(/^\//, ''))
     .filter(Boolean)
   for (const origin of domains) {
-    try {
-      // The class materializes as a `class.User` Folder under the domain mount;
-      // a resolvable read means the domain declares it.
-      await ctx.client.call(`/${origin}/class.User::get`, {})
+    // The class materializes as a `class.User` Folder under the domain mount;
+    // a resolving node means the domain declares it (null when absent).
+    if (await graph.get(`/${origin}/class.User`)) {
       return `/:${origin}:class.User`
-    } catch {
-      // This domain has no User class — try the next one.
     }
   }
   throw new Error(
     'No installed domain declares a `User` class on this instance — registering a ' +
-      'non-root identity needs an identity-bearer class (install the distribution ' +
+      'non-root identity needs an identity-bearer class (install workspace or another ' +
       'domain, or pass --class <classPath> explicitly).',
   )
 }
@@ -85,7 +78,7 @@ export default {
     {
       flags: '--class <classPath>',
       description:
-        'Class path of the identity node to create (default: /:dist.<origin>:class.User when distribution is installed)',
+        'Class path of the identity node to create (default: the installed domain that declares class.User)',
     },
     {
       flags: '--path <nodePath>',
@@ -127,23 +120,24 @@ export default {
 
           const classPath = opts.class ?? (await resolveUserClassPath(ctx))
 
-          // A bare `astrale identity create <name>` carries no profile, but the
-          // bearer class may require one (distribution's User wants
-          // firstName/lastName) — default both to the identity name so a dev
+          // A bare `astrale identity create <name>` carries no profile, but a
+          // User bearer class may require one. Default both names so a dev
           // registration works out of the box; `--props` overrides.
           const extraProps = opts.props ? (JSON.parse(opts.props) as Record<string, unknown>) : {}
           const userDefaults = classPath.endsWith(':class.User')
             ? { firstName: name, lastName: name }
             : {}
 
-          const node = (await ctx.client.call(K.Node.createNode.path.method.raw, {
-            class: classPath,
-            path: nodePath,
-            props: { 'Statused.status': 'creating', ...userDefaults, ...extraProps },
-          })) as CreateNodeResult
+          // One-arm create through function.mutate; the minted node id comes
+          // back in createdNodes (keyed by the `at` path).
+          const nodeId = await bindGraph(ctx).createNode(classPath, nodePath, {
+            'Statused.status': 'creating',
+            ...userDefaults,
+            ...extraProps,
+          })
 
           const bootstrap = await mintBootstrapJwt(privateJwk)
-          const result = (await ctx.client.call(`@${node.id}::registerIdentity`, {
+          const result = (await ctx.client.call(`@${nodeId}::registerIdentity`, {
             signingKey: {
               publicKey: { jwk: publicJwk },
               credential: bootstrap,

package/src/commands/instance/active.ts

@@ -3,7 +3,7 @@ import chalk from 'chalk'
 import type { CommandDefinition } from '../../command'
 
 import { withAdminKernelClient } from '../../kernel/client'
-import { ADMIN_INSTANCE, type InstanceInfo } from '../../lib/admin-instance'
+import { adminInstanceMethod, type InstanceInfo } from '../../lib/admin-instance'
 import { getActive, normalizeInstanceKernelUrl } from '../../lib/instance'
 import { log } from '../../lib/log'
 import { RAW_OUTPUT_OPTIONS, isMachine, output, type RawOutputOpts } from '../../lib/output'
@@ -51,7 +51,7 @@ async function resolveActiveForDisplay(): Promise<{
     const managed = await withAdminKernelClient(
       {},
       async (ctx) =>
-        (await ctx.client.call(`${ADMIN_INSTANCE}/info`, { id: active.name })) as InstanceInfo,
+        (await ctx.client.call(adminInstanceMethod('info'), { id: active.name })) as InstanceInfo,
     )
     return {
       name: managed.slug,

package/src/commands/instance/create.ts

@@ -63,7 +63,7 @@ Examples:
         return
       }
     } catch (e) {
-      fatal(e)
+      fatal(e, opts)
     }
   },
 } satisfies CommandDefinition

package/src/commands/instance/delete.ts

@@ -2,7 +2,7 @@ import type { CommandDefinition } from '../../command'
 import type { KernelCommandOpts } from '../../kernel'
 
 import { withAdminKernelClient } from '../../kernel/client'
-import { ADMIN_INSTANCE, type InstanceInfo } from '../../lib/admin-instance'
+import { adminInstanceMethod, type InstanceInfo } from '../../lib/admin-instance'
 import { ADMIN_TARGET_OPTIONS, type AdminTargetCommandOpts } from '../../lib/admin-target'
 import { clearActive, readInstances, removeInstance, resolveInstanceKey } from '../../lib/instance'
 import { fatal, log, withSpinner } from '../../lib/log'
@@ -40,7 +40,7 @@ Behavior:
           withAdminKernelClient(
             opts,
             async (ctx) =>
-              (await ctx.client.call(`${ADMIN_INSTANCE}/delete`, { id })) as InstanceInfo,
+              (await ctx.client.call(adminInstanceMethod('delete'), { id })) as InstanceInfo,
           ),
         { success: (deleted) => `Deleted instance: ${deleted.slug}` },
       )
@@ -66,7 +66,7 @@ Behavior:
         log.dim(`  hint: it's a local bookmark — drop it with: astrale instance forget ${id}`)
         process.exit(1)
       }
-      fatal(e)
+      fatal(e, opts)
     }
   },
 } satisfies CommandDefinition

package/src/commands/instance/list.ts

@@ -5,7 +5,11 @@ import type { KernelCommandOpts } from '../../kernel'
 import type { Column } from '../../lib/output'
 
 import { withAdminKernelClient } from '../../kernel/client'
-import { ADMIN_INSTANCE, formatInstanceLocation, type InstanceInfo } from '../../lib/admin-instance'
+import {
+  adminInstanceMethod,
+  formatInstanceLocation,
+  type InstanceInfo,
+} from '../../lib/admin-instance'
 import { ADMIN_TARGET_OPTIONS, type AdminTargetCommandOpts } from '../../lib/admin-target'
 import { normalizeInstanceKernelUrl, readInstances } from '../../lib/instance'
 import { fatal, log, withSpinner } from '../../lib/log'
@@ -60,7 +64,8 @@ export default {
         managed = await withSpinner('Fetching instances', !isMachine(opts), () =>
           withAdminKernelClient(
             opts,
-            async (ctx) => (await ctx.client.call(`${ADMIN_INSTANCE}/list`, {})) as InstanceInfo[],
+            async (ctx) =>
+              (await ctx.client.call(adminInstanceMethod('list'), {})) as InstanceInfo[],
           ),
         )
       }
@@ -87,7 +92,7 @@ export default {
       }
       process.stdout.write(renderTable(rows, { columns: COLUMNS }) + '\n')
     } catch (e) {
-      fatal(e)
+      fatal(e, opts)
     }
   },
 } satisfies CommandDefinition

package/src/commands/instance/status.ts

@@ -4,7 +4,7 @@ import type { CommandDefinition } from '../../command'
 import type { KernelCommandOpts } from '../../kernel'
 
 import { withAdminKernelClient } from '../../kernel/client'
-import { ADMIN_INSTANCE, type InstanceInfo } from '../../lib/admin-instance'
+import { adminInstanceMethod, type InstanceInfo } from '../../lib/admin-instance'
 import { ADMIN_TARGET_OPTIONS, type AdminTargetCommandOpts } from '../../lib/admin-target'
 import { fatal, log, withSpinner } from '../../lib/log'
 import { isMachine, output, type RawOutputOpts } from '../../lib/output'
@@ -21,7 +21,8 @@ export default {
       const result = await withSpinner(`Fetching instance ${id}`, !isMachine(opts), () =>
         withAdminKernelClient(
           opts,
-          async (ctx) => (await ctx.client.call(`${ADMIN_INSTANCE}/info`, { id })) as InstanceInfo,
+          async (ctx) =>
+            (await ctx.client.call(adminInstanceMethod('info'), { id })) as InstanceInfo,
         ),
       )
       if (isMachine(opts)) {
@@ -36,7 +37,7 @@ export default {
       if (result.hostId) log.dim(`  host: ${result.hostId}`)
       if (result.createdAt) log.dim(`  created: ${result.createdAt}`)
     } catch (e) {
-      fatal(e)
+      fatal(e, opts)
     }
   },
 } satisfies CommandDefinition

package/src/commands/instance/use.ts

@@ -2,7 +2,7 @@ import type { CommandDefinition } from '../../command'
 
 import { AstraleError } from '../../errors'
 import { withAdminKernelClient } from '../../kernel/client'
-import { ADMIN_INSTANCE, type InstanceInfo } from '../../lib/admin-instance'
+import { adminInstanceMethod, type InstanceInfo } from '../../lib/admin-instance'
 import { ADMIN_TARGET_OPTIONS } from '../../lib/admin-target'
 import { getDefault, setDefault } from '../../lib/identity'
 import {
@@ -142,7 +142,7 @@ async function fetchManagedInstances(name: string, opts: UseOpts): Promise<Insta
   try {
     return await withAdminKernelClient(
       opts,
-      async (ctx) => (await ctx.client.call(`${ADMIN_INSTANCE}/list`, {})) as InstanceInfo[],
+      async (ctx) => (await ctx.client.call(adminInstanceMethod('list'), {})) as InstanceInfo[],
     )
   } catch {
     return []

package/src/commands/logs.ts

@@ -1,9 +1,9 @@
 import type { JournalEntry, JournalFilter } from '@astrale-os/kernel-core'
 
 /**
- * `astrale logs` — tail the kernel event journal (Root.journal) for the target
+ * `astrale logs` — tail the kernel event journal (function.journal) for the target
  * instance. Defaults to the kernel journal syscall
- * `/kernel.astrale.ai/class.Root/journal`; `--service <name>` switches to the
+ * `/kernel.astrale.ai/functions/journal`; `--service <name>` switches to the
  * per-instance `services` domain log buffer (the historical behavior).
  *
  * Target the instance with `-i <instance>` (inherited from withKernelOptions).
@@ -18,13 +18,13 @@ import { runKernelCommand, withKernelClient } from '../kernel'
 import { fatal, withSpinner } from '../lib/log'
 import { isMachine, output, presentList } from '../lib/output'
 
-const ROOT_JOURNAL_PATH = '/kernel.astrale.ai/class.Root/journal'
+const JOURNAL_FN_PATH = '/kernel.astrale.ai/functions/journal'
 const DEFAULT_SERVICES_ORIGIN = 'services.astrale.ai'
 const DEFAULT_LIMIT = 200
 const FOLLOW_INTERVAL_MS = 2000
 // The journal-read syscall journals its own ops; hide them by default so polling
 // doesn't self-pollute the view. `--all` shows them.
-const SELF_READ_PREFIX = 'op:class.Root.method.journal:'
+const SELF_READ_PREFIX = 'op:function.journal:'
 
 // The published @astrale-os/kernel-core@0.5.0 JournalFilter has no `cursor` yet
 // (added on the kernel branch). Type against the augmented shape so the
@@ -48,7 +48,7 @@ type LogsOpts = KernelCommandOpts & {
 }
 
 /**
- * Kernel journal page. The Root.journal syscall returns a BARE `JournalEntry[]`;
+ * Kernel journal page. The function.journal syscall returns a BARE `JournalEntry[]`;
  * the client derives the next cursor from the max `seq`. We still model a
  * `nextCursor` field so the TTY footer / incremental tail share one shape, and
  * so a future paged kernel response degrades gracefully.
@@ -58,7 +58,7 @@ type EventsPage = {
   nextCursor?: number | null
 }
 
-// ── Root.journal (default) ───────────────────────────────────
+// ── function.journal (default) ───────────────────────────────────
 
 /** The highest `seq` across entries, or null when empty. */
 function maxSeq(entries: JournalEntry[]): number | null {
@@ -177,7 +177,7 @@ function eventsProjection(entries: JournalEntry[], showTiming = false): ListProj
 }
 
 async function fetchEventsPage(ctx: ClientContext, opts: LogsOpts): Promise<EventsPage> {
-  const raw = await ctx.client.call(ROOT_JOURNAL_PATH, buildEventsParams(opts))
+  const raw = await ctx.client.call(JOURNAL_FN_PATH, buildEventsParams(opts))
   const page = normalizePage(raw)
   // Strip the journal's own read ops by default (but keep nextCursor past them).
   const entries = opts.all
@@ -313,7 +313,7 @@ export default {
     },
   ],
   afterHelpText: `
-Default: tails the kernel event journal via ${ROOT_JOURNAL_PATH} on the target
+Default: tails the kernel event journal via ${JOURNAL_FN_PATH} on the target
 instance (-i <instance>). Topics use ':'-segmented globs ('*' one segment,
 '**' zero-or-more). Machine output (--json / pipe) emits the JournalEntry[]
 array; a TTY shows a SEQ/TIME/TOPIC/LATENCY/PRINCIPAL table (LATENCY is the

package/src/commands/ls.ts

@@ -1,14 +1,17 @@
+import { rawOf } from '@astrale-os/kernel-client/graph'
 import chalk from 'chalk'
 
 import type { CommandDefinition } from '../command'
-import type { KernelCommandOpts, ClientContext, SelfExpansionMeta } from '../kernel'
+import type { GraphNode, KernelCommandOpts, SelfExpansionMeta } from '../kernel'
 import type { ListProjection } from '../lib/output'
 
 import {
+  bindGraph,
+  childrenCursor,
   expandSelfInPath,
-  extractItems,
   formatKernelError,
   runKernelCommand,
+  splitRoot,
   withKernelClient,
   withSelfHint,
 } from '../kernel'
@@ -23,25 +26,19 @@ type LsOpts = KernelCommandOpts & {
   filter?: string
 }
 
-/** A child node as returned by `::listChildren`. */
-type Item = {
-  id?: string
-  class?: string
-  path?: string
-  props?: Record<string, unknown>
-  __labels?: string[]
-}
+/** A child node row — the shared `function.get` node shape. */
+type Item = GraphNode
 
 // ── Display projection ──────────────────────────────────────
 
-/** `/dist.astrale.ai` → `dist.astrale.ai`; `/` stays `/`. */
+/** `/example.astrale.ai` → `example.astrale.ai`; `/` stays `/`. */
 export function basename(path?: string): string {
   if (!path || path === '/') return path ?? ''
   return path.slice(path.lastIndexOf('/') + 1)
 }
 
 /** `/:kernel.astrale.ai:class.Domain` → `Domain`; falls back to the most specific label. */
-export function classNameOf(item: Item): string {
+export function classNameOf(item: { class?: string; __labels?: string[] }): string {
   const tail = item.class?.split(/[/:.]/).pop()
   return tail || item.__labels?.[item.__labels.length - 1] || '?'
 }
@@ -92,14 +89,36 @@ export async function lsCommand(path: string, opts: LsOpts): Promise<void> {
   await runKernelCommand({
     opts,
     label: `Children of ${expandedPath}`,
-    fn: (ctx) => withSelfHint(() => ctx.client.call(`${expandedPath}::listChildren`, {}), meta),
-    format: (result, fmtOpts) => {
-      const items = applyFilter(extractItems<Item>(result), opts.filter)
+    // Flat listing = ONE function.get depth:1; the root is dropped, the rest are
+    // the direct children (replaces the removed `::listChildren` syscall).
+    fn: async (ctx) => {
+      const result = await withSelfHint(
+        () => bindGraph(ctx).query((q) => q.from(expandedPath).children()),
+        meta,
+      )
+      return {
+        children: splitRoot(result.wire.nodes, expandedPath).children,
+        next: childrenCursor(result.wire),
+      }
+    },
+    format: ({ children, next }, fmtOpts) => {
+      const items = applyFilter(children, opts.filter)
       presentList(
         items,
         { ...fmtOpts, quiet: opts.quiet, count: opts.count, long: opts.long },
         lsProjection,
       )
+      if (next && !isMachine(fmtOpts) && !opts.quiet && !opts.count) {
+        process.stdout.write(
+          chalk.dim(
+            '  more children truncated - page with `query ' +
+              expandedPath +
+              ' --depth 1 --children \'{"cursor":"' +
+              next +
+              '"}\'`\n',
+          ),
+        )
+      }
     },
   })
 }
@@ -107,9 +126,8 @@ export async function lsCommand(path: string, opts: LsOpts): Promise<void> {
 // ── Recursive tree ──────────────────────────────────────────
 
 const MAX_DEPTH = 5
-const MAX_NODES = 200
 
-type TreeNode = Item & { children?: TreeNode[] }
+type TreeNode = Item & { children: TreeNode[] }
 
 async function recursiveLs(
   path: string,
@@ -121,8 +139,13 @@ async function recursiveLs(
 
   try {
     await withKernelClient(opts, async (ctx) => {
-      const counter = { count: 0 }
-      const tree = await withSelfHint(() => buildTree(ctx, path, 0, counter), meta)
+      // The recursive walk is now ONE function.get to the depth cap; the tree is
+      // reassembled client-side from the flat node page (was an N+1 buildTree).
+      const result = await withSelfHint(
+        () => bindGraph(ctx).query((q) => q.from(path).descend(MAX_DEPTH)),
+        meta,
+      )
+      const tree = buildTree(result.wire.nodes, path)
       spin?.succeed(`Tree of ${path}`)
       if (!machine) console.log('')
 
@@ -141,32 +164,30 @@ async function recursiveLs(
   }
 }
 
-async function buildTree(
-  ctx: ClientContext,
-  path: string,
-  depth: number,
-  counter: { count: number },
-): Promise<TreeNode[]> {
-  if (depth >= MAX_DEPTH || counter.count >= MAX_NODES) return []
-  try {
-    const result = await ctx.client.call(`${path}::listChildren`, {})
-    const items = extractItems<Item>(result)
-
-    const nodes: TreeNode[] = []
-    for (const item of items) {
-      if (counter.count >= MAX_NODES) break
-      counter.count++
-      const node: TreeNode = { ...item }
-      // Descend by the child's absolute path (the kernel returns `path`, not `slug`).
-      if (item.path && item.path !== '/') {
-        node.children = await buildTree(ctx, item.path, depth + 1, counter)
-      }
-      nodes.push(node)
-    }
-    return nodes
-  } catch {
-    return []
+/** Parent absolute path of an absolute node path (`/a/b` → `/a`; `/a` → `/`). */
+function parentPathOf(path: string): string {
+  const i = path.lastIndexOf('/')
+  return i <= 0 ? '/' : path.slice(0, i)
+}
+
+/** Reassemble the flat `function.get` node page into a tree rooted at `rootPath`. */
+function buildTree(nodes: readonly GraphNode[], rootPath: string): TreeNode[] {
+  const rootRaw = rawOf(rootPath)
+  const byPath = new Map<string, TreeNode>()
+  for (const n of nodes) {
+    const raw = rawOf(n.path)
+    if (raw === rootRaw) continue
+    byPath.set(raw, { ...n, children: [] })
+  }
+
+  const roots: TreeNode[] = []
+  for (const [raw, node] of byPath) {
+    const parent = parentPathOf(raw)
+    const parentNode = parent === rootRaw ? undefined : byPath.get(parent)
+    if (parentNode) parentNode.children.push(node)
+    else roots.push(node)
   }
+  return roots
 }
 
 function printTree(nodes: TreeNode[], prefix: string): void {
@@ -179,7 +200,7 @@ function printTree(nodes: TreeNode[], prefix: string): void {
     const name = basename(node.path) || node.id || '?'
     console.log(`${prefix}${connector}${chalk.cyan(name)}  ${chalk.dim(classNameOf(node))}`)
 
-    if (node.children && node.children.length > 0) {
+    if (node.children.length > 0) {
       printTree(node.children, prefix + childPrefix)
     }
   }
@@ -188,7 +209,7 @@ function printTree(nodes: TreeNode[], prefix: string): void {
 function printTreeQuiet(nodes: TreeNode[]): void {
   for (const node of nodes) {
     process.stdout.write(itemPath(node) + '\n')
-    if (node.children) printTreeQuiet(node.children)
+    if (node.children.length > 0) printTreeQuiet(node.children)
   }
 }
 
@@ -197,13 +218,14 @@ export default {
   description: 'List children of a node',
   afterHelpText: `
 Behavior:
-  Default output is a NAME/KIND/ID table on a TTY, JSON when piped. --filter
-  matches a node KIND or label: Folder, Method, Domain. At a domain's tree
-  position the children are Folder nodes (class.X), not Class — so --filter
-  Class returns nothing; use --filter Folder, or descend into class.<X> and
-  --filter Method. -R tree view is TTY-only (raw/JSON emits the nested tree).
-  -q prints one absolute path per line (pipeable). Note: ls /<domain> may
-  report NOT_FOUND even when it exists — use describe, or ls one of its children.
+  Default output is a NAME/KIND/ID table on a TTY, JSON when piped. One
+  function.get depth:1 fetches the direct children; -R fetches the whole
+  subtree (to depth ${MAX_DEPTH}) in a SINGLE call and renders it as a tree.
+  --filter matches a child KIND or label (post-filter): Folder, Function,
+  Domain. At a domain's tree position the children are Folder nodes
+  (class.X), not Class — so --filter Class returns nothing; use --filter
+  Folder, or descend into class.<X>. -q prints one absolute path per line
+  (pipeable).
 
 Examples:
   $ astrale ls /
@@ -220,10 +242,10 @@ Examples:
     { flags: '--count', description: 'Print only the number of children' },
     {
       flags: '--filter <kind>',
-      description: 'Filter children by kind or label (e.g., Folder, Method, Domain)',
+      description: 'Filter children by kind or label (e.g., Folder, Function, Domain)',
     },
   ],
   action: async (path, opts) => {
-    await lsCommand((path as string | undefined) ?? '/', opts as Parameters<typeof lsCommand>[1])
+    await lsCommand((path as string | undefined) ?? '/', opts as LsOpts)
   },
 } satisfies CommandDefinition