lyra-ai-agent 0.1.0

package/src/commands/demo.ts

@@ -0,0 +1,177 @@
+/**
+ * `lyra demo` — walk the guarded pipeline end to end using the lyra-plugin-onchain
+ * tools and the deterministic policy engine.
+ *
+ * Steps:
+ *   1. policy.show           — print the active fund-control policy.
+ *   2. blocked over-cap send — evaluatePolicy on an amount above the per-tx cap;
+ *                              demonstrates a BLOCKED unsafe action (no network).
+ *   3. policy.create         — publish an on-chain lyra::policy AgentPolicy   (--yes)
+ *   4. sui.send              — a small in-cap transfer to self                (--yes)
+ *   5. walrus.store          — store the run receipt durably on Walrus        (--yes)
+ *
+ * Steps 3–5 move value / write on-chain, so they run ONLY with `--yes`. The
+ * default run is read-only + deterministic: it proves the policy blocks an
+ * over-cap action and explains what the write path would do.
+ */
+
+import { formatSui, getSuiBalanceMist } from 'lyra-core'
+import onchainPlugin, {
+  type OnchainRuntimeContext,
+  type SuiPolicy,
+  evaluatePolicy,
+  makeSuiClient,
+  policyFromEnv,
+  suiToMist,
+} from 'lyra-plugin-onchain'
+import { findAndLoadConfig } from '../config/load'
+import { buildOnchainContext, loadAgentFromEnv } from '../util/sui-runtime'
+
+const SUI_TYPE = '0x2::sui::SUI'
+
+export interface DemoOpts {
+  yes?: boolean
+}
+
+interface DemoTool {
+  name: string
+  handler: (args: unknown) => Promise<unknown>
+}
+
+/**
+ * Drive the plugin's own `register` against a minimal collector so we get the
+ * exact ToolDefs the chat agent uses — without reaching past the public API.
+ */
+function collectOnchainTools(onchain: OnchainRuntimeContext): Map<string, DemoTool> {
+  const tools = new Map<string, DemoTool>()
+  const ctx = {
+    onchain,
+    registerTool: (t: DemoTool) => tools.set(t.name, t),
+  }
+  onchainPlugin.register(ctx as unknown as Parameters<typeof onchainPlugin.register>[0])
+  return tools
+}
+
+export async function runDemo(opts: DemoOpts = {}): Promise<void> {
+  const found = await findAndLoadConfig()
+  if (!found) {
+    console.log('No lyra.config.ts found. Run `lyra init` first.')
+    process.exit(1)
+  }
+  const { config } = found
+
+  const agent = loadAgentFromEnv()
+  if (!agent) {
+    console.log('No LYRA_AGENT_KEY set. Run `lyra init` first.')
+    process.exit(1)
+  }
+
+  console.log(`lyra demo — agent ${agent.address} on ${config.network}\n`)
+
+  const onchain = buildOnchainContext({
+    agent,
+    network: config.network,
+    agentDir: found.path,
+    brainProvider: config.brain.provider,
+    brainModel: config.brain.model,
+  })
+  const tools = collectOnchainTools(onchain)
+
+  // ── Step 1: policy.show ────────────────────────────────────────────────
+  console.log('1) policy.show')
+  const policy = policyFromEnv()
+  if (!policy) {
+    console.log(
+      '   (no LYRA_POLICY_* configured — set LYRA_POLICY_MAX_PER_TX_SUI to bound the agent)\n',
+    )
+  } else {
+    console.log(`   ${describePolicy(policy)}\n`)
+  }
+
+  // ── Step 2: blocked over-cap send (deterministic, no network) ──────────
+  console.log('2) blocked over-cap send (policy enforcement)')
+  if (policy?.maxMistPerTx !== undefined) {
+    const overCap = policy.maxMistPerTx + (suiToMist('1') ?? 0n) // 1 SUI over the cap
+    const verdict = evaluatePolicy(
+      {
+        kind: 'transfer',
+        coinType: SUI_TYPE,
+        amountMist: overCap,
+        to: agent.address,
+        protocol: 'transfer',
+      },
+      policy,
+    )
+    if (!verdict.allowed) {
+      console.log(
+        `   send ${formatSui(overCap)} SUI → BLOCKED ✓  (${verdict.violations.join('; ')})\n`,
+      )
+    } else {
+      console.log(`   send ${formatSui(overCap)} SUI was allowed (cap not enforced?)\n`)
+    }
+  } else {
+    console.log('   skipped: no per-tx cap configured (set LYRA_POLICY_MAX_PER_TX_SUI)\n')
+  }
+
+  // ── Live balance (read-only) ────────────────────────────────────────────
+  try {
+    const client = makeSuiClient(config.network)
+    const mist = await getSuiBalanceMist(client, agent.address)
+    console.log(`   agent SUI balance: ${formatSui(mist)} SUI\n`)
+  } catch {
+    // RPC unavailable — fine, the rest is descriptive.
+  }
+
+  // ── Steps 3–5: write path ────────────────────────────────────────────────
+  if (!opts.yes) {
+    console.log('3-5) write path (policy.create → sui.send → walrus.store)')
+    console.log('   dry run. Re-run `lyra demo --yes` to execute the on-chain steps:')
+    console.log('     • policy.create — publish a shared lyra::policy AgentPolicy')
+    console.log(
+      '     • sui.send      — a small in-cap transfer to self (policy + simulate + execute)',
+    )
+    console.log('     • walrus.store  — store the run receipt durably on Walrus')
+    return
+  }
+
+  console.log('3) policy.create')
+  await runTool(tools, 'policy.create', { budgetSui: '1', maxPerTxSui: '0.1', maxSlippageBps: 100 })
+
+  console.log('4) sui.send (in-cap, to self)')
+  await runTool(tools, 'sui.send', { to: agent.address, amount: '0.001' })
+
+  console.log('5) walrus.store (run receipt)')
+  await runTool(tools, 'walrus.store', {
+    content: JSON.stringify({ demo: 'lyra', agent: agent.address, ts: Date.now() }),
+  })
+}
+
+async function runTool(
+  tools: Map<string, DemoTool>,
+  name: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const tool = tools.get(name)
+  if (!tool) {
+    console.log(`   tool ${name} not registered; skipped`)
+    console.log('')
+    return
+  }
+  try {
+    const res = (await tool.handler(args)) as { ok?: boolean; error?: string; data?: unknown }
+    if (res.ok === false) console.log(`   ${name} failed: ${res.error}`)
+    else console.log(`   ${name} ok: ${JSON.stringify(res.data)}`)
+  } catch (e) {
+    console.log(`   ${name} threw: ${(e as Error).message.slice(0, 200)}`)
+  }
+  console.log('')
+}
+
+function describePolicy(p: SuiPolicy): string {
+  const parts: string[] = []
+  if (p.maxMistPerTx !== undefined) parts.push(`maxPerTx=${formatSui(p.maxMistPerTx)} SUI`)
+  if (p.autoMaxMistPerTx !== undefined) parts.push(`autoMax=${formatSui(p.autoMaxMistPerTx)} SUI`)
+  if (p.autonomy) parts.push(`autonomy=${p.autonomy}`)
+  if (p.readOnly) parts.push('READ-ONLY')
+  return parts.length ? parts.join(', ') : '(no caps set)'
+}

package/src/commands/gateway-logs.ts

@@ -0,0 +1,49 @@
+/**
+ * `lyra gateway logs [--tail N] [-f]` — tail the gateway log.
+ *
+ * v0.19.x: gateway daemon logs to stdout/stderr only (inherited by `gateway run`
+ * or backgrounded by `gateway start`). v0.19.3 wires a log file at
+ * `~/.lyra/agents/<id>/gateway.log` for tailing. Until then, this command
+ * informs the user where to look.
+ */
+
+import { spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { agentPaths, placeholderAgentId } from 'lyra-core'
+import { findAndLoadConfig } from '../config/load'
+
+export interface GatewayLogsOpts {
+  agentId?: string
+  tail: number
+  follow: boolean
+}
+
+export async function runGatewayLogs(opts: GatewayLogsOpts): Promise<void> {
+  let agentId = opts.agentId
+  if (!agentId) {
+    const found = await findAndLoadConfig()
+    if (!found?.config) {
+      console.error('lyra gateway logs: no lyra.config.ts and no --agent provided')
+      process.exit(1)
+    }
+    const agentEoa = found.config.identity.agent
+    if (!agentEoa) {
+      console.error('lyra gateway logs: config has no agent EOA; run `lyra init` first')
+      process.exit(1)
+    }
+    agentId = placeholderAgentId(agentEoa)
+  }
+  const logFile = join(agentPaths.agent(agentId).dir, 'gateway.log')
+  if (!existsSync(logFile)) {
+    console.log(`gateway log not found at ${logFile}`)
+    console.log('v0.19.x: gateway daemon logs to stdout when run via `lyra gateway run`.')
+    console.log(
+      'Background it with: nohup bun packages/gateway/bin/lyra-gateway-local > ~/lyra-logs/gateway.log 2>&1 &',
+    )
+    return
+  }
+  const args = ['-n', String(opts.tail), ...(opts.follow ? ['-f'] : []), logFile]
+  const proc = spawn('tail', args, { stdio: 'inherit' })
+  proc.on('exit', code => process.exit(code ?? 0))
+}

package/src/commands/gateway-run.ts

@@ -0,0 +1,42 @@
+/**
+ * `lyra gateway run` — foreground daemon (blocks; Ctrl+C to stop).
+ *
+ * Spawns `lyra-gateway-local` (the bin in lyra-gateway) with
+ * inherit stdio so the user sees logs live. Reads operator-session for the
+ * cached AES keys; fails loud if no session exists ("run lyra gateway start
+ * first").
+ */
+
+import { spawn } from 'node:child_process'
+import { join } from 'node:path'
+import { resolveLocalBin } from '../util/gateway-spawn'
+
+export interface GatewayRunOpts {
+  agentId?: string
+}
+
+export async function runGatewayForeground(opts: GatewayRunOpts): Promise<void> {
+  const env = { ...process.env }
+  if (opts.agentId) env.LYRA_AGENT_ID = opts.agentId
+  // Default LYRA_CONFIG to ~/.lyra/config.ts if not already set.
+  if (!env.LYRA_CONFIG) {
+    env.LYRA_CONFIG = join(env.HOME ?? '', '.lyra', 'config.ts')
+  }
+
+  const localBin = resolveLocalBin()
+  const proc = spawn('bun', [localBin], {
+    env,
+    stdio: 'inherit',
+  })
+  proc.on('exit', code => process.exit(code ?? 0))
+  proc.on('error', err => {
+    console.error(`lyra gateway run: spawn failed — ${err.message}`)
+    process.exit(1)
+  })
+
+  const forwardSignal = (sig: NodeJS.Signals): void => {
+    if (!proc.killed) proc.kill(sig)
+  }
+  process.on('SIGINT', () => forwardSignal('SIGINT'))
+  process.on('SIGTERM', () => forwardSignal('SIGTERM'))
+}

package/src/commands/gateway-start.ts

@@ -0,0 +1,89 @@
+/**
+ * `lyra gateway start` — fork the gateway daemon detached.
+ *
+ * On Sui the agent key comes from the `LYRA_AGENT_KEY` env var, so there is no
+ * operator wallet, Touch ID, or operator-session to derive. The daemon reads
+ * the same env the CLI runs in.
+ *
+ * Flow:
+ *   1. Load config from ~/.lyra/config.ts
+ *   2. Resolve agentId (override via --agent or derived from LYRA_AGENT_KEY)
+ *   3. Check if gateway already running (socket present). If yes, error.
+ *   4. Spawn the gateway daemon detached + wait for socket to bind.
+ *   5. Print pid + socket path.
+ */
+
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { spinner } from '@clack/prompts'
+import { agentPaths, placeholderAgentId } from 'lyra-core'
+import { findAndLoadConfig } from '../config/load'
+import { spawnGatewayDaemon } from '../util/gateway-spawn'
+import { loadAgentFromEnv } from '../util/sui-runtime'
+
+export interface GatewayStartOpts {
+  agentId?: string
+}
+
+export async function runGatewayStart(opts: GatewayStartOpts): Promise<void> {
+  const found = await findAndLoadConfig()
+  if (!found?.config) {
+    console.error('lyra gateway start: no lyra.config.ts found in cwd or ~/.lyra/')
+    process.exit(1)
+  }
+  const config = found.config
+
+  const agent = loadAgentFromEnv()
+  const agentAddress = agent?.address ?? config.identity.agent
+  if (!agentAddress) {
+    console.error(
+      'lyra gateway start: no LYRA_AGENT_KEY set and no agent in config. Run `lyra init`.',
+    )
+    process.exit(1)
+  }
+  const agentId = opts.agentId ?? placeholderAgentId(agentAddress)
+  const paths = agentPaths.agent(agentId)
+  const socketPath = join(paths.dir, 'gateway.sock')
+
+  // If the socket exists, check for version drift; auto-restart on mismatch so
+  // operators don't have to `lyra gateway restart` after upgrading the binary.
+  if (existsSync(socketPath)) {
+    const { createHash } = await import('node:crypto')
+    const { homedir } = await import('node:os')
+    const identityHash = createHash('sha256').update(agentId).digest('hex').slice(0, 16)
+    const lockFile = join(homedir(), '.lyra', 'locks', `lyra-gateway-${identityHash}.lock`)
+    const { ensureGatewayVersionMatchesCli } = await import('../util/gateway-version')
+    const drift = await ensureGatewayVersionMatchesCli({ socketPath, lockFile })
+    if (drift.action === 'ok' || drift.action === 'no-cli-version') {
+      console.error(
+        `lyra gateway start: socket already exists at ${socketPath} — gateway may be running (version ${drift.daemonVersion ?? 'unknown'}). Try \`lyra gateway stop\` first.`,
+      )
+      process.exit(1)
+    }
+    console.log(`note: ${drift.note}`)
+  }
+
+  // Spawn gateway daemon detached. The daemon reads LYRA_AGENT_KEY + LYRA_*
+  // from the inherited environment; no key derivation happens here.
+  const sBoot = spinner()
+  sBoot.start(`Spawning gateway daemon (agent=${agentId.slice(0, 8)}…)`)
+
+  const result = await spawnGatewayDaemon({
+    agentId,
+    configPath: found.path ?? '',
+    socketPath,
+    timeoutMs: 10_000,
+  })
+  if (result.ready) {
+    sBoot.stop(`gateway running pid=${result.pid} socket=${socketPath}`)
+    console.log('stop with: lyra gateway stop')
+    console.log('logs:      lyra gateway logs -f')
+  } else {
+    const reason = result.reason ?? 'unknown'
+    const detail = result.error ? `: ${result.error}` : ''
+    sBoot.stop(
+      `gateway did not bind socket within 10s (reason=${reason} pid=${result.pid ?? '?'})${detail}; check above output`,
+    )
+    process.exit(1)
+  }
+}

package/src/commands/gateway-status.ts

@@ -0,0 +1,73 @@
+/**
+ * `lyra gateway status` — show PID, uptime, socket path, lock state,
+ * operator-session freshness.
+ */
+
+import { createHash } from 'node:crypto'
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { agentPaths, placeholderAgentId } from 'lyra-core'
+import { findAndLoadConfig } from '../config/load'
+
+export interface GatewayStatusOpts {
+  agentId?: string
+}
+
+function fmtAge(ms: number): string {
+  const s = Math.floor(ms / 1000)
+  if (s < 60) return `${s}s`
+  const m = Math.floor(s / 60)
+  if (m < 60) return `${m}m`
+  const h = Math.floor(m / 60)
+  return `${h}h${m % 60}m`
+}
+
+export async function runGatewayStatus(opts: GatewayStatusOpts): Promise<void> {
+  let agentId = opts.agentId
+  if (!agentId) {
+    const found = await findAndLoadConfig()
+    if (!found?.config) {
+      console.error('lyra gateway status: no lyra.config.ts and no --agent provided')
+      process.exit(1)
+    }
+    const agentEoa = found.config.identity.agent
+    if (!agentEoa) {
+      console.error('lyra gateway status: config has no agent EOA; run `lyra init` first')
+      process.exit(1)
+    }
+    agentId = placeholderAgentId(agentEoa)
+  }
+  const paths = agentPaths.agent(agentId)
+  const socketPath = join(paths.dir, 'gateway.sock')
+  const identityHash = createHash('sha256').update(agentId).digest('hex').slice(0, 16)
+  const lockFile = join(homedir(), '.lyra', 'locks', `lyra-gateway-${identityHash}.lock`)
+
+  console.log(`agent:        ${agentId}`)
+  console.log(`socket:       ${socketPath} ${existsSync(socketPath) ? '(present)' : '(absent)'}`)
+  console.log(`lock:         ${lockFile} ${existsSync(lockFile) ? '(present)' : '(absent)'}`)
+
+  // PID + uptime via lock file.
+  if (existsSync(lockFile)) {
+    try {
+      const parsed = JSON.parse(readFileSync(lockFile, 'utf8')) as { pid?: number }
+      if (typeof parsed.pid === 'number') {
+        let alive = false
+        try {
+          process.kill(parsed.pid, 0)
+          alive = true
+        } catch {
+          /* dead */
+        }
+        const stat = statSync(lockFile)
+        const ageMs = Date.now() - stat.mtimeMs
+        console.log(`pid:          ${parsed.pid} ${alive ? '(alive)' : '(dead — stale lock)'}`)
+        console.log(`lock-age:     ${fmtAge(ageMs)}`)
+      }
+    } catch {
+      console.log('pid:          (lock file unreadable)')
+    }
+  } else {
+    console.log('pid:          (not running)')
+  }
+}

package/src/commands/gateway-stop.ts

@@ -0,0 +1,133 @@
+/**
+ * `lyra gateway stop` — SIGTERM the running gateway daemon via the lock
+ * file's PID. Falls through to SIGKILL after a 5s grace period.
+ */
+
+import { existsSync, readFileSync, unlinkSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { agentPaths, placeholderAgentId } from 'lyra-core'
+import { findAndLoadConfig } from '../config/load'
+
+export interface GatewayStopOpts {
+  agentId?: string
+}
+
+function lockPath(_agentId: string): string {
+  // Mirror packages/core/src/locks.ts — `~/.lyra/locks/<scope>-<sha256(identity).slice(0,16)>.lock`
+  // For 'lyra-gateway' scope. We compute the same hash as the lock module.
+  // Easiest: read all lock files and find one matching the agent.
+  return join(homedir(), '.lyra', 'locks')
+}
+
+function findGatewayLock(agentId: string): string | null {
+  // The lock filename embeds sha256(agentId).slice(0, 16). Compute it.
+  const { createHash } = require('node:crypto')
+  const identityHash = createHash('sha256').update(agentId).digest('hex').slice(0, 16)
+  const lockFile = join(lockPath(agentId), `lyra-gateway-${identityHash}.lock`)
+  return existsSync(lockFile) ? lockFile : null
+}
+
+export async function runGatewayStop(opts: GatewayStopOpts): Promise<void> {
+  let agentId = opts.agentId
+  if (!agentId) {
+    const found = await findAndLoadConfig()
+    if (!found?.config) {
+      console.error('lyra gateway stop: no lyra.config.ts and no --agent provided')
+      process.exit(1)
+    }
+    const agentEoa = found.config.identity?.agent ?? null
+    if (!agentEoa) {
+      console.error('lyra gateway stop: config has no agent EOA; run `lyra init` first')
+      process.exit(1)
+    }
+    agentId = placeholderAgentId(agentEoa)
+    const label = `agent ${agentId.slice(0, 8)}…`
+    const eoaLabel = ` (EOA ${agentEoa.slice(0, 6)}…${agentEoa.slice(-4)})`
+    const configPath = found.path ?? '<unknown>'
+    console.log(`lyra gateway stop → ${label}${eoaLabel}`)
+    console.log(`  config: ${configPath}`)
+    console.log(
+      '  if this is not the agent you meant, set LYRA_ROOT or pass --agent <id> before re-running.',
+    )
+  }
+  const lockFile = findGatewayLock(agentId)
+  if (!lockFile) {
+    console.log(`gateway not running (no lock at ${lockPath(agentId)})`)
+    return
+  }
+  let pid: number
+  try {
+    const raw = readFileSync(lockFile, 'utf8').trim()
+    // Lock files are JSON with shape `{pid, scope, identityHash, expiresAt}`.
+    const parsed = JSON.parse(raw) as { pid?: number }
+    if (typeof parsed.pid !== 'number') {
+      console.error('lyra gateway stop: lock file has no pid field')
+      process.exit(1)
+    }
+    pid = parsed.pid
+  } catch (e) {
+    console.error(`lyra gateway stop: lock file unreadable — ${(e as Error).message}`)
+    process.exit(1)
+  }
+
+  // Verify the PID is alive.
+  try {
+    process.kill(pid, 0)
+  } catch {
+    console.log(`gateway not running (stale lock pid=${pid}); cleaning up`)
+    try {
+      unlinkSync(lockFile)
+    } catch {
+      /* ignore */
+    }
+    return
+  }
+
+  // Send SIGTERM, wait up to 5s, then SIGKILL.
+  console.log(`stopping gateway pid=${pid} ...`)
+  try {
+    process.kill(pid, 'SIGTERM')
+  } catch (e) {
+    console.error(`lyra gateway stop: SIGTERM failed — ${(e as Error).message}`)
+    process.exit(1)
+  }
+
+  const start = Date.now()
+  while (Date.now() - start < 5_000) {
+    try {
+      process.kill(pid, 0)
+    } catch {
+      console.log(`gateway stopped pid=${pid}`)
+      // Lock file is auto-removed by daemon's shutdown handler. Belt + suspenders:
+      try {
+        if (existsSync(lockFile)) unlinkSync(lockFile)
+      } catch {
+        /* ignore */
+      }
+      // Also clean up the socket file in case the daemon didn't.
+      const socketPath = join(agentPaths.agent(agentId).dir, 'gateway.sock')
+      try {
+        if (existsSync(socketPath)) unlinkSync(socketPath)
+      } catch {
+        /* ignore */
+      }
+      return
+    }
+    await new Promise(r => setTimeout(r, 200))
+  }
+
+  console.log('gateway did not exit in 5s; sending SIGKILL')
+  try {
+    process.kill(pid, 'SIGKILL')
+  } catch (e) {
+    console.error(`lyra gateway stop: SIGKILL failed — ${(e as Error).message}`)
+    process.exit(1)
+  }
+  try {
+    if (existsSync(lockFile)) unlinkSync(lockFile)
+  } catch {
+    /* ignore */
+  }
+  console.log(`gateway force-killed pid=${pid}`)
+}

package/src/commands/gateway.ts

@@ -0,0 +1,101 @@
+/**
+ * `lyra gateway <sub>` argv dispatcher.
+ *
+ * Subs:
+ *   run       — foreground daemon (blocks; Ctrl+C to stop). Uses operator-session.
+ *   start     — interactive: prompt Touch ID, write operator-session, fork daemon.
+ *   stop      — SIGTERM the running daemon via the lock file's PID.
+ *   restart   — stop + start.
+ *   status    — show PID, uptime, socket path, lock state.
+ *   logs      — tail the gateway log (--tail N, --follow).
+ *
+ * v0.19.x scope: run + start + stop + status. restart/logs/install/setup ship
+ * in v0.19.3 alongside launchd plist generator.
+ */
+
+export type GatewaySub = 'run' | 'start' | 'stop' | 'restart' | 'status' | 'logs'
+
+export interface ParsedGatewayArgs {
+  sub: GatewaySub
+  /** Optional --agent <id> override; defaults to config-derived. */
+  agentId?: string
+  /** --tail N for logs; default 100. */
+  tail?: number
+  /** --follow / -f for logs. */
+  follow?: boolean
+}
+
+export type ParseResult = ParsedGatewayArgs | { error: string }
+
+export function parseGatewayArgs(argv: string[]): ParseResult {
+  const sub = argv[0]
+  if (!sub) {
+    return { error: 'usage: lyra gateway <run | start | stop | restart | status | logs>' }
+  }
+  if (!['run', 'start', 'stop', 'restart', 'status', 'logs'].includes(sub)) {
+    return { error: `unknown gateway sub: ${sub}` }
+  }
+  let agentId: string | undefined
+  let tail: number | undefined
+  let follow = false
+  for (let i = 1; i < argv.length; i++) {
+    const a = argv[i]
+    if (a === '--agent') {
+      const v = argv[++i]
+      if (!v) return { error: '--agent requires a value' }
+      agentId = v
+    } else if (a === '--tail') {
+      const v = argv[++i]
+      if (!v) return { error: '--tail requires a value' }
+      const n = Number.parseInt(v, 10)
+      if (!Number.isFinite(n) || n < 0) return { error: '--tail must be a positive integer' }
+      tail = n
+    } else if (a === '--follow' || a === '-f') {
+      follow = true
+    } else {
+      return { error: `unknown flag: ${a}` }
+    }
+  }
+  return { sub: sub as GatewaySub, agentId, tail, follow }
+}
+
+export async function runGateway(parsed: ParsedGatewayArgs): Promise<void> {
+  switch (parsed.sub) {
+    case 'run': {
+      const { runGatewayForeground } = await import('./gateway-run')
+      await runGatewayForeground({ agentId: parsed.agentId })
+      return
+    }
+    case 'start': {
+      const { runGatewayStart } = await import('./gateway-start')
+      await runGatewayStart({ agentId: parsed.agentId })
+      return
+    }
+    case 'stop': {
+      const { runGatewayStop } = await import('./gateway-stop')
+      await runGatewayStop({ agentId: parsed.agentId })
+      return
+    }
+    case 'restart': {
+      const { runGatewayStop } = await import('./gateway-stop')
+      const { runGatewayStart } = await import('./gateway-start')
+      await runGatewayStop({ agentId: parsed.agentId })
+      await runGatewayStart({ agentId: parsed.agentId })
+      return
+    }
+    case 'status': {
+      const { runGatewayStatus } = await import('./gateway-status')
+      await runGatewayStatus({ agentId: parsed.agentId })
+      return
+    }
+    case 'logs': {
+      const { runGatewayLogs } = await import('./gateway-logs')
+      await runGatewayLogs({
+        agentId: parsed.agentId,
+        tail: parsed.tail ?? 100,
+        follow: parsed.follow ?? false,
+      })
+      return
+    }
+  }
+}

package/src/commands/init/model-picker.ts

@@ -0,0 +1,17 @@
+export interface ModelPick {
+  provider: string
+  model: string | null
+}
+
+/**
+ * Lyra uses a fixed OpenAI-compatible model configured via env
+ * (`LYRA_LLM_MODEL` / `LYRA_LLM_BASE_URL` / `OPENAI_API_KEY`), so there's
+ * no live provider catalog to pick from. Return the configured default so
+ * `init` / `model` proceed without prompting.
+ */
+export async function pickBrainModel(): Promise<ModelPick | null> {
+  return {
+    provider: 'openai-compatible',
+    model: process.env.LYRA_LLM_MODEL ?? 'gpt-4o-mini',
+  }
+}