@astrale-os/cli 0.5.0-alpha.0 → 0.6.0-alpha.0

package/src/connect-core.ts

@@ -0,0 +1,53 @@
+/**
+ * connect-core — the frozen, curated re-export surface the connect-host adapter
+ * borrows from the CLI. It is the ONE public seam between `@astrale-os/cli` and
+ * `@astrale-os/connect-host`; nothing else in cli/src is contract.
+ *
+ * Consumed by `@astrale-os/connect-host`; temps-2 seed of a future
+ * `@astrale-os/client-core`. Re-export ONLY — no logic lives here.
+ */
+
+// ── identity registry (~/.astrale/identities.json) ──────────────────────────
+export { readIdentities, getDefault, getIdentity } from './lib/identity'
+export type { Identity, IdentityStore } from './lib/identity'
+
+// ── keypairs on disk + self-grant mint ──────────────────────────────────────
+export { signAs, listIdentityKeys } from './lib/keys'
+
+// ── instance bookmarks (~/.astrale/instances.json) ──────────────────────────
+export {
+  readInstances,
+  resetInstancesMemo,
+  resolveInstance,
+  normalizeInstanceKernelUrl,
+  orgIdForAudience,
+} from './lib/instance'
+export type { InstanceEntry, InstanceStore, ResolvedInstance } from './lib/instance'
+
+// ── instance-target resolution (bookmark | managed | admin | free url) ──────
+export { resolveInstanceTarget } from './lib/instance-target'
+export type { ResolvedInstanceTarget } from './lib/instance-target'
+
+// ── global config (~/.astrale/config.json) ──────────────────────────────────
+export { readConfig } from './lib/config'
+export type { AstraleConfig } from './lib/config'
+
+// ── credential resolution (self-grant + IdP) ────────────────────────────────
+export { resolveCredential, IdpRefreshTransientError, IdpOrgMembershipError } from './kernel/auth'
+
+// ── IdP login (device flow) — driven by connect-host's `auth.login` op ───────
+export { loginViaIdp, resolveIdpName } from './lib/login-flow'
+export type { LoginFlowOpts, LoginResult, DeviceVerification } from './lib/login-flow'
+
+// ── IdP session state (so connect-host can flag "login required" rows) ───────
+export { readIdpSession, isSessionExpired } from './lib/idp'
+export type { IdpSession } from './lib/idp'
+
+// ── typed errors ────────────────────────────────────────────────────────────
+export { AuthError } from './errors'
+
+// ── custom-CA fetch (private-CA local stacks) ───────────────────────────────
+export { fetchWithCaFile } from './kernel/ca-fetch'
+
+// ── path resolution (~/.astrale layout) ─────────────────────────────────────
+export { paths, createPaths } from './lib/env'

package/src/kernel/__tests__/auth.test.ts

@@ -12,6 +12,7 @@ const config: AstraleConfig = {
     url: 'https://admin.eu.astrale.ai/api',
     issuer: 'https://admin.eu.astrale.ai/api',
   },
+  telemetry: { enabled: true },
 }
 
 describe('resolveKeyIdentityAuthOptions', () => {

package/src/kernel/client.ts

@@ -5,7 +5,7 @@ import type { AdminTargetCommandOpts } from '../lib/admin-target'
 import type { KernelCommandOpts } from './types'
 
 import { AstraleError } from '../errors'
-import { ADMIN_INSTANCE, type InstanceInfo } from '../lib/admin-instance'
+import { adminInstanceMethod, type InstanceInfo } from '../lib/admin-instance'
 import { readConfig } from '../lib/config'
 import { resolveInstanceTarget, type ResolvedInstanceTarget } from '../lib/instance-target'
 import { resolveCredential } from './auth'
@@ -21,7 +21,7 @@ export type ClientContext = {
   config: Awaited<ReturnType<typeof readConfig>>
 }
 
-type ResolvedKernelTarget = {
+export type ResolvedKernelTarget = {
   url: string
   audience: string
   slug?: string
@@ -29,44 +29,50 @@ type ResolvedKernelTarget = {
   caFile?: string
 }
 
-/**
- * Connect to a kernel instance, run `fn`, then disconnect.
- * The new client is lazy: construction does no I/O. We only need to
- * release sockets on the way out.
- */
-export async function withKernelClient<T>(
+/** Resolve the kernel a command targets (`--url` / `-i` / active instance). */
+export async function resolveKernelTarget(
   opts: KernelCommandOpts,
-  fn: (ctx: ClientContext) => Promise<T>,
-): Promise<T> {
-  const config = await readConfig()
+  config: Awaited<ReturnType<typeof readConfig>>,
+): Promise<ResolvedKernelTarget> {
   // Ad-hoc `--url` — unknown kernel. Stamp the URL itself as audience,
   // no slug for per-instance signing.
-  let target: ResolvedKernelTarget
   if (opts.url && !opts.instance) {
     const resolved = await resolveInstanceTarget(
       { source: 'url', url: opts.url },
       { config, admin: adminLookupOpts(opts) },
     )
-    target = resolvedToKernelTarget(resolved)
-  } else {
-    const resolved = await resolveInstanceTarget(
-      opts.instance ? { source: 'name', name: opts.instance } : { source: 'active' },
-      {
-        config,
-        admin: adminLookupOpts(opts),
-        managed: (slug) => lookupManagedInstance(slug, opts),
-      },
-    )
-    target = resolvedToKernelTarget(resolved, opts.url)
+    return resolvedToKernelTarget(resolved)
   }
+  const resolved = await resolveInstanceTarget(
+    opts.instance ? { source: 'name', name: opts.instance } : { source: 'active' },
+    {
+      config,
+      admin: adminLookupOpts(opts),
+      managed: (slug) => lookupManagedInstance(slug, opts),
+    },
+  )
+  return resolvedToKernelTarget(resolved, opts.url)
+}
 
+/**
+ * Connect to a kernel instance, run `fn`, then disconnect.
+ * The new client is lazy: construction does no I/O. We only need to
+ * release sockets on the way out.
+ */
+export async function withKernelClient<T>(
+  opts: KernelCommandOpts,
+  fn: (ctx: ClientContext) => Promise<T>,
+): Promise<T> {
+  const config = await readConfig()
+  const target = await resolveKernelTarget(opts, config)
   return withResolvedKernelClient(opts, config, target, fn)
 }
 
 async function lookupManagedInstance(slug: string, opts: KernelCommandOpts): Promise<InstanceInfo> {
   return await withAdminKernelClient(
     adminLookupOpts(opts),
-    async (ctx) => (await ctx.client.call(`${ADMIN_INSTANCE}/info`, { id: slug })) as InstanceInfo,
+    async (ctx) =>
+      (await ctx.client.call(adminInstanceMethod('info'), { id: slug })) as InstanceInfo,
   )
 }
 

package/src/kernel/expand.ts

@@ -1,7 +1,7 @@
 import type { InstanceInfo } from '../lib/admin-instance'
 import type { KernelCommandOpts } from './types'
 
-import { ADMIN_INSTANCE } from '../lib/admin-instance'
+import { adminInstanceMethod } from '../lib/admin-instance'
 /** CLI bridge for @self resolution and stale-registration error hints. */
 import { readConfig } from '../lib/config'
 import { getDefault, getIdentity, setRegistration } from '../lib/identity'
@@ -95,7 +95,8 @@ function adminLookupOpts(opts: KernelCommandOpts): KernelCommandOpts {
 async function lookupManagedInstance(slug: string, opts: KernelCommandOpts): Promise<InstanceInfo> {
   return await withAdminKernelClient(
     adminLookupOpts(opts),
-    async (ctx) => (await ctx.client.call(`${ADMIN_INSTANCE}/info`, { id: slug })) as InstanceInfo,
+    async (ctx) =>
+      (await ctx.client.call(adminInstanceMethod('info'), { id: slug })) as InstanceInfo,
   )
 }
 

package/src/kernel/index.ts

@@ -1,4 +1,10 @@
-export { withKernelClient, withAdminKernelClient, type ClientContext } from './client'
+export {
+  withKernelClient,
+  withAdminKernelClient,
+  resolveKernelTarget,
+  type ClientContext,
+  type ResolvedKernelTarget,
+} from './client'
 export { resolveCredential } from './auth'
 export { formatKernelError } from './errors'
 export {

package/src/kernel/options.ts

@@ -15,7 +15,7 @@ export const KERNEL_PASSTHROUGH_OPTIONS: CommandOption[] = [
     flags: '-i, --instance <name>',
     description: 'Target a specific instance (overrides active)',
   },
-  { flags: '--timeout <ms>', description: 'Request timeout in ms', default: '30000' },
+  { flags: '--timeout <ms>', description: 'Request timeout in ms (default: 30000)' },
   { flags: '--as <identity>', description: 'Call as a specific identity' },
   { flags: '--creds <token>', description: 'Use a pre-signed credential (e.g. delegation token)' },
   { flags: '--debug', description: 'Print full error diagnostics on failure' },

package/src/lib/__tests__/instance-target.test.ts

@@ -3,6 +3,7 @@ import { describe, expect, test } from 'bun:test'
 import type { AstraleConfig } from '../config'
 import type { InstanceStore } from '../instance'
 
+import { AstraleError } from '../../errors'
 import { DEFAULT_CONFIG } from '../config'
 import {
   couldBeConfiguredAdminInstance,
@@ -181,3 +182,36 @@ describe('instance target helpers', () => {
     expect(isManagedInstanceNotFound(auth)).toBe(false)
   })
 })
+
+describe('isManagedInstanceNotFound: kernel InternalKernelError wrap', () => {
+  test('NOT_FOUND-prefixed InternalKernelError is an instance miss', () => {
+    const e = new Error('NOT_FOUND: no instance node for "knowledge"')
+    e.name = 'InternalKernelError'
+    expect(isManagedInstanceNotFound(e)).toBe(true)
+  })
+  test('other InternalKernelError messages are not swallowed', () => {
+    const e = new Error('DISPATCH_FAILED: handler crashed')
+    e.name = 'InternalKernelError'
+    expect(isManagedInstanceNotFound(e)).toBe(false)
+  })
+  test('resolveNamedInstanceTarget maps the wrap to typed INSTANCE_NOT_FOUND', async () => {
+    const managed = async () => {
+      const e = new Error('NOT_FOUND: no instance node for "ghost"')
+      e.name = 'InternalKernelError'
+      throw e
+    }
+    const opts = {
+      config: DEFAULT_CONFIG,
+      instances: { instances: {} },
+      managed,
+    } as unknown as Parameters<typeof resolveInstanceTarget>[1]
+    let caught: unknown
+    try {
+      await resolveInstanceTarget({ source: 'name', name: 'ghost' }, opts)
+    } catch (e) {
+      caught = e
+    }
+    expect(caught).toBeInstanceOf(AstraleError)
+    expect((caught as AstraleError).code).toBe('INSTANCE_NOT_FOUND')
+  })
+})

package/src/lib/__tests__/view-open-intent.test.ts

@@ -0,0 +1,308 @@
+import type { IntentMessage, MountedWindow, ResolvedView, Shell } from '@astrale-os/shell'
+
+import { describe, expect, test } from 'bun:test'
+
+import {
+  handleOpenIntent,
+  installOpenIntentHandler,
+  mountWithHandshakeFallback,
+  type OpenIntentHost,
+} from '../view/open-intent'
+
+const profile: ResolvedView = {
+  id: 'profile-view',
+  path: '/shell/views/profile',
+  url: 'https://shell.test/profile',
+  origin: 'class',
+}
+const card: ResolvedView = {
+  id: 'card-view',
+  path: '/shell/views/card',
+  url: 'https://shell.test/card',
+  handshake: 'none',
+  origin: 'class',
+}
+
+function openMessage(viewId?: string, correlationId?: string): IntentMessage<'open'> {
+  return {
+    type: 'intent',
+    version: 1,
+    envelope: {
+      name: 'open',
+      payload: { nodeId: 'person-1', ...(viewId ? { viewId } : {}) },
+      sender: { windowId: 'old-window' },
+      ...(correlationId ? { correlationId } : {}),
+    },
+  }
+}
+
+function mounted(windowId: string, onClose?: () => void): MountedWindow {
+  return {
+    windowId,
+    window: {
+      windowId,
+      functionId: 'view',
+      isolation: 'shared',
+      state: 'active',
+      delegationToken: null,
+      capabilities: { intents: [] },
+    },
+    handle: { element: {} as HTMLElement },
+    close: async () => {
+      onClose?.()
+      return { kind: 'closed' }
+    },
+  }
+}
+
+function harness(views: readonly ResolvedView[] = [profile, card]) {
+  const events: string[] = []
+  const sent: { windowId: string; message: IntentMessage }[] = []
+  const old = mounted('old-window', () => events.push('close:old-window'))
+  let current: MountedWindow | null = old
+  const shell = {
+    views: {
+      resolve: async (node: string) => {
+        events.push(`resolve:${node}`)
+        return views
+      },
+    },
+  } as unknown as Pick<Shell, 'views'>
+  const host: OpenIntentHost = {
+    current: () => current,
+    setCurrent: (next) => {
+      events.push(`current:${next.windowId}`)
+      current = next
+    },
+    mount: async (view, nodeId) => {
+      events.push(`mount:${view.id}:${nodeId}`)
+      return mounted('new-window')
+    },
+    opened: (view, nodeId) => events.push(`opened:${view.path}:${nodeId}`),
+    failed: (error) => events.push(`failed:${error instanceof Error ? error.message : error}`),
+    reply: (message, windowId) => {
+      if (!message.envelope.correlationId) return
+      events.push(`reply:${message.envelope.sender.windowId}`)
+      sent.push({
+        windowId: message.envelope.sender.windowId,
+        message: {
+          type: 'intent',
+          version: 1,
+          envelope: {
+            name: 'intentReply',
+            payload: {
+              correlationId: message.envelope.correlationId,
+              result: { windowId },
+            },
+            sender: { windowId: 'root' },
+          },
+        },
+      })
+    },
+    reject: (message, error) => {
+      if (!message.envelope.correlationId) return
+      events.push(`reply:${message.envelope.sender.windowId}`)
+      sent.push({
+        windowId: message.envelope.sender.windowId,
+        message: {
+          type: 'intent',
+          version: 1,
+          envelope: {
+            name: 'intentReply',
+            payload: {
+              correlationId: message.envelope.correlationId,
+              error: { message: error instanceof Error ? error.message : String(error) },
+            },
+            sender: { windowId: 'root' },
+          },
+        },
+      })
+    },
+  }
+  return { events, sent, shell, host, current: () => current }
+}
+
+describe('open intent host', () => {
+  test('uses kernel preference and replies before retiring the requesting child', async () => {
+    const h = harness()
+    await handleOpenIntent(h.shell, h.host, openMessage(undefined, 'corr-1'))
+
+    expect(h.events).toEqual([
+      'resolve:person-1',
+      'mount:profile-view:person-1',
+      'current:new-window',
+      'opened:/shell/views/profile:person-1',
+      'reply:old-window',
+      'close:old-window',
+    ])
+    expect(h.current()?.windowId).toBe('new-window')
+    expect(h.sent).toEqual([
+      {
+        windowId: 'old-window',
+        message: {
+          type: 'intent',
+          version: 1,
+          envelope: {
+            name: 'intentReply',
+            payload: { correlationId: 'corr-1', result: { windowId: 'new-window' } },
+            sender: { windowId: 'root' },
+          },
+        },
+      },
+    ])
+  })
+
+  test('honors an explicit view and keeps fire-and-forget navigation reply-free', async () => {
+    const h = harness()
+    await handleOpenIntent(h.shell, h.host, openMessage('card-view'))
+
+    expect(h.events).toContain('mount:card-view:person-1')
+    expect(h.sent).toEqual([])
+  })
+
+  test('keeps the current view and rejects a correlated resolution failure', async () => {
+    const h = harness([])
+    await handleOpenIntent(h.shell, h.host, openMessage(undefined, 'corr-fail'))
+
+    expect(h.current()?.windowId).toBe('old-window')
+    expect(h.events).toEqual([
+      'resolve:person-1',
+      'reply:old-window',
+      'failed:No view resolves for this node',
+    ])
+    expect(h.sent[0]!.message.envelope).toEqual({
+      name: 'intentReply',
+      payload: {
+        correlationId: 'corr-fail',
+        error: { message: 'No view resolves for this node' },
+      },
+      sender: { windowId: 'root' },
+    })
+  })
+
+  test('keeps the current view when the replacement mount fails', async () => {
+    const h = harness([profile])
+    h.host.mount = async () => {
+      h.events.push('mount:failed')
+      throw new Error('replacement failed')
+    }
+
+    await handleOpenIntent(h.shell, h.host, openMessage(undefined, 'corr-mount'))
+
+    expect(h.current()?.windowId).toBe('old-window')
+    expect(h.events).toEqual([
+      'resolve:person-1',
+      'mount:failed',
+      'reply:old-window',
+      'failed:replacement failed',
+    ])
+    expect(h.sent[0]!.message.envelope.payload).toEqual({
+      correlationId: 'corr-mount',
+      error: { message: 'replacement failed' },
+    })
+  })
+
+  test('serializes overlapping opens', async () => {
+    let handler: ((message: IntentMessage<'open'>) => Promise<void>) | undefined
+    let releaseFirst!: () => void
+    const firstGate = new Promise<void>((resolve) => {
+      releaseFirst = resolve
+    })
+    let resolveCount = 0
+    const base = harness([profile])
+    const events = base.events
+    const shell = {
+      ...base.shell,
+      views: {
+        resolve: async () => {
+          resolveCount += 1
+          events.push(`resolve:${resolveCount}`)
+          if (resolveCount === 1) await firstGate
+          return [profile]
+        },
+      },
+      onIntent: (_name: 'open', next: typeof handler) => {
+        handler = next
+        return () => {}
+      },
+    } as unknown as Shell
+    const host = {
+      ...base.host,
+      mount: async () => {
+        const id = `new-${resolveCount}`
+        events.push(`mount:${id}`)
+        return mounted(id, () => events.push(`close:${id}`))
+      },
+    }
+    installOpenIntentHandler(shell, host)
+
+    const first = handler!(openMessage())
+    const second = handler!(openMessage())
+    await Promise.resolve()
+    expect(events).toEqual(['resolve:1'])
+    releaseFirst()
+    await Promise.all([first, second])
+    expect(events).toEqual([
+      'resolve:1',
+      'mount:new-1',
+      'current:new-1',
+      'opened:/shell/views/profile:person-1',
+      'close:old-window',
+      'resolve:2',
+      'mount:new-2',
+      'current:new-2',
+      'opened:/shell/views/profile:person-1',
+      'close:new-1',
+    ])
+    expect(base.current()?.windowId).toBe('new-2')
+  })
+})
+
+describe('mountWithHandshakeFallback', () => {
+  test('mounts a plain view once', async () => {
+    const attempts: string[] = []
+    const result = await mountWithHandshakeFallback({
+      handshake: 'none',
+      attempts: 2,
+      mount: async (handshake) => {
+        attempts.push(handshake)
+        return 'plain-window'
+      },
+      cleanupFailedAttempt: () => attempts.push('cleanup'),
+    })
+    expect(result).toEqual({ mounted: 'plain-window', handshake: 'none' })
+    expect(attempts).toEqual(['none'])
+  })
+
+  test('retries shell mounts, cleans each failure, then falls back to plain', async () => {
+    const attempts: string[] = []
+    const result = await mountWithHandshakeFallback({
+      handshake: 'shell',
+      attempts: 2,
+      mount: async (handshake) => {
+        attempts.push(handshake)
+        if (handshake === 'shell') throw new Error('handshake failed')
+        return 'plain-window'
+      },
+      cleanupFailedAttempt: () => attempts.push('cleanup'),
+    })
+    expect(result).toEqual({ mounted: 'plain-window', handshake: 'none' })
+    expect(attempts).toEqual(['shell', 'cleanup', 'shell', 'cleanup', 'none'])
+  })
+
+  test('cleans and surfaces the decisive plain fallback failure', async () => {
+    const attempts: string[] = []
+    const run = mountWithHandshakeFallback({
+      handshake: 'shell',
+      attempts: 2,
+      mount: async (handshake) => {
+        attempts.push(handshake)
+        throw new Error(handshake === 'shell' ? 'handshake failed' : 'plain failed')
+      },
+      cleanupFailedAttempt: () => attempts.push('cleanup'),
+    })
+
+    await expect(run).rejects.toThrow('plain failed')
+    expect(attempts).toEqual(['shell', 'cleanup', 'shell', 'cleanup', 'none', 'cleanup'])
+  })
+})

package/src/lib/__tests__/view-snapshot.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from 'bun:test'
+
+import type { AbResult } from '../browser'
+
+import { snapshotText, waitForSettledSnapshot } from '../view/snapshot'
+
+const pending = result('- paragraph\n  - StaticText "Opening integrations…"')
+const settled = result('- heading "Integrations" [level=1]\n- button "Connect Google" [ref=e4]')
+
+function result(snapshot: string): AbResult {
+  return { ok: true, data: { snapshot }, error: null }
+}
+
+function clock() {
+  let elapsed = 0
+  return {
+    now: () => elapsed,
+    sleep: async (ms: number) => {
+      elapsed += ms
+    },
+    elapsed: () => elapsed,
+  }
+}
+
+describe('view snapshot settling', () => {
+  test('waits through a late loading-to-content transition and a quiet window', async () => {
+    const fakeClock = clock()
+    let calls = 0
+    const takeSnapshot = async () => {
+      calls += 1
+      return fakeClock.elapsed() < 1_250 ? pending : settled
+    }
+
+    const snapshot = await waitForSettledSnapshot(takeSnapshot, fakeClock, {
+      timeoutMs: 4_000,
+      quietWindowMs: 750,
+      pollMs: 250,
+    })
+
+    expect(snapshotText(snapshot)).toContain('Connect Google')
+    expect(fakeClock.elapsed()).toBe(2_000)
+    expect(calls).toBe(10)
+  })
+
+  test('returns the latest permanently pending snapshot at the bound', async () => {
+    const fakeClock = clock()
+    let calls = 0
+    const takeSnapshot = async () => {
+      calls += 1
+      return pending
+    }
+
+    const snapshot = await waitForSettledSnapshot(takeSnapshot, fakeClock, {
+      timeoutMs: 1_000,
+      quietWindowMs: 500,
+      pollMs: 250,
+    })
+
+    expect(snapshot).toBe(pending)
+    expect(fakeClock.elapsed()).toBe(1_000)
+    expect(calls).toBe(6)
+  })
+
+  test('ignores changing agent-browser refs when measuring stability', async () => {
+    const fakeClock = clock()
+    let ref = 0
+
+    const snapshot = await waitForSettledSnapshot(
+      async () => result(`- button "Deploy" [ref=e${++ref}]`),
+      fakeClock,
+      { timeoutMs: 2_000, quietWindowMs: 500, pollMs: 250 },
+    )
+
+    expect(snapshotText(snapshot)).toContain('Deploy')
+    expect(fakeClock.elapsed()).toBe(500)
+  })
+})

package/src/lib/admin-domain.ts

@@ -7,16 +7,20 @@
  * mounting it on an instance is the separate `domain install` step (or the
  * admin's install-by-default policy).
  */
-export const ADMIN_DOMAIN = '/admin.astrale.ai/class.DomainEntry'
+export const ADMIN_DOMAIN = '/:admin.astrale.ai:class.DomainEntry'
+
+export function adminDomainMethod(method: 'info' | 'install' | 'list' | 'publish'): string {
+  return `${ADMIN_DOMAIN}:${method}`
+}
 
 /** Read shape returned by `DomainEntry.publish` / `info` / `list` (domain `DomainInfoSchema`). */
 export type DomainInfo = {
   id: string
-  /** workspace.astrale.ai — the authority origin (== JWT aud + kernel path prefix). */
+  /** shell.astrale.ai — the authority origin (== JWT aud + kernel path prefix). */
   origin: string
-  /** 'workspace' — the node slug + the id used in install plans / the CLI. */
+  /** 'shell' — the node slug + the id used in install plans / the CLI. */
   name: string
-  /** https://workspace.astrale.ai — the published worker URL the kernel installs from. */
+  /** https://shell.astrale.ai — the published worker URL the kernel installs from. */
   url?: string
   description?: string
   installByDefault?: boolean

package/src/lib/admin-instance.ts

@@ -3,7 +3,11 @@
  * list/status/create/delete`. The merged admin domain models instances as the
  * `Instance` class (provisioned via `Instance.init`); these commands target it.
  */
-export const ADMIN_INSTANCE = '/admin.astrale.ai/class.Instance'
+export const ADMIN_INSTANCE = '/:admin.astrale.ai:class.Instance'
+
+export function adminInstanceMethod(method: 'alphaCreate' | 'delete' | 'info' | 'list'): string {
+  return `${ADMIN_INSTANCE}:${method}`
+}
 
 /** Read shape returned by `Instance.list` / `info` / `delete` (domain `InstanceInfoSchema`). */
 export type InstanceInfo = {

package/src/lib/config.ts

@@ -9,6 +9,7 @@ import { CONFIG_PATH } from './paths'
 export const AstraleConfigSchema = z.object({
   issuer: z.string().url().default('https://unregistered.invalid'),
   admin: AdminTargetConfigSchema.default(DEFAULT_ADMIN_TARGET_CONFIG),
+  telemetry: z.object({ enabled: z.boolean().default(true) }).default({ enabled: true }),
 })
 
 export type AstraleConfig = z.infer<typeof AstraleConfigSchema>