lyra-ai-agent 0.1.0

package/src/commands/init.ts

@@ -0,0 +1,153 @@
+import { existsSync } from 'node:fs'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { cancel, intro, isCancel, outro, select } from '@clack/prompts'
+import {
+  type LyraNetwork,
+  agentPaths,
+  defineConfig,
+  placeholderAgentId,
+  suiRpcUrl,
+} from 'lyra-core'
+import { writeConfigTs } from '../config/render'
+import { AGENT_KEY_ENV, loadAgentFromEnv } from '../util/sui-runtime'
+import { pickBrainModel } from './init/model-picker'
+
+/**
+ * `lyra init` — bootstrap the agent config for Sui.
+ *
+ * On Sui there is no operator wallet, keystore, or funding step. The agent IS
+ * the signer: one Ed25519 keypair, supplied via the `LYRA_AGENT_KEY` env var
+ * (`suiprivkey1…`). init resolves that key, derives the agent's Sui address,
+ * writes `~/.lyra/config.ts`, and seeds the starter memory files.
+ */
+export async function runInit(opts?: { resume?: boolean }): Promise<void> {
+  const configPath = agentPaths.config
+
+  intro('lyra init')
+
+  if (existsSync(configPath) && !opts?.resume) {
+    const choice = (await select({
+      message: `${configPath} exists`,
+      options: [
+        { value: 'overwrite', label: 'Start fresh (overwrite)' },
+        { value: 'cancel', label: 'Cancel' },
+      ],
+      initialValue: 'cancel',
+    })) as 'overwrite' | 'cancel' | symbol
+    if (isCancel(choice) || choice === 'cancel') {
+      cancel('Aborted.')
+      return
+    }
+  }
+
+  // The agent key is sourced from the environment (never prompted/stored on
+  // disk). If it is missing we cannot derive the Sui address, so bail with a
+  // clear instruction.
+  const agent = loadAgentFromEnv()
+  if (!agent) {
+    cancel(
+      `No ${AGENT_KEY_ENV} set. Export your agent's Sui secret key first, e.g.\n  export ${AGENT_KEY_ENV}=suiprivkey1...\nThen re-run \`lyra init\`.`,
+    )
+    return
+  }
+
+  const network = (await select({
+    message: 'Which Sui network?',
+    options: [
+      { value: 'mainnet' as LyraNetwork, label: 'Sui mainnet' },
+      { value: 'testnet' as LyraNetwork, label: 'Sui testnet' },
+    ],
+    initialValue: 'mainnet' as LyraNetwork,
+  })) as LyraNetwork
+  if (isCancel(network)) {
+    cancel('Aborted.')
+    return
+  }
+
+  const modelPick = await pickBrainModel()
+
+  const agentId = placeholderAgentId(agent.address)
+  const paths = agentPaths.agent(agentId)
+  await mkdir(paths.dir, { recursive: true })
+
+  // Telegram is env-driven on Sui (TELEGRAM_BOT_TOKEN). Auto-enable the plugin
+  // when the token is present so `lyra` brings the DM gateway online.
+  const telegramEnabled = !!process.env.TELEGRAM_BOT_TOKEN
+
+  await seedStarterMemoryFiles({
+    paths,
+    network,
+    agentAddress: agent.address,
+    brainProvider: modelPick?.provider ?? null,
+    brainModel: modelPick?.model ?? null,
+  })
+
+  const cfg = defineConfig({
+    identity: {
+      operator: null,
+      agent: agent.address,
+    },
+    network,
+    storage: { network },
+    brain: {
+      provider: modelPick?.provider ?? null,
+      model: modelPick?.model ?? null,
+    },
+    plugins: telegramEnabled ? ['onchain', 'system', 'telegram'] : ['onchain', 'system'],
+    tools: {},
+    imports: { claudeCode: true },
+  })
+  await writeConfigTs(configPath, cfg, {
+    header: '// Regenerated by `lyra init`. Edit freely; type-safe.',
+  })
+
+  const packageId = process.env.LYRA_PACKAGE_ID
+  const lines = [
+    '',
+    `  agent id    ${agentId}`,
+    `  agent addr  ${agent.address}`,
+    `  network     ${network} (${suiRpcUrl(network)})`,
+    `  config      ${configPath}`,
+    `  policy pkg  ${packageId ?? '(set LYRA_PACKAGE_ID for on-chain receipts)'}`,
+  ]
+  if (modelPick) lines.push(`  brain       ${modelPick.model ?? '?'} (${modelPick.provider})`)
+  if (telegramEnabled) lines.push('  telegram    enabled (TELEGRAM_BOT_TOKEN set)')
+  lines.push(
+    '',
+    'Next: `lyra` to chat · `lyra status` for health · `lyra demo` for the guarded pipeline',
+  )
+  outro(lines.join('\n'))
+}
+
+interface SeedStarterOpts {
+  paths: ReturnType<typeof agentPaths.agent>
+  network: LyraNetwork
+  agentAddress: string
+  brainProvider: string | null
+  brainModel: string | null
+}
+
+/**
+ * Seed `MEMORY.md`, `/agent/identity.md`, and `/agent/persona.md` so the
+ * brain's first turn sees a parseable memory index and introduces itself.
+ */
+async function seedStarterMemoryFiles(opts: SeedStarterOpts): Promise<void> {
+  const memDir = opts.paths.memoryDir
+  const agentMem = `${memDir}/agent`
+  const userMem = `${memDir}/user`
+  await mkdir(agentMem, { recursive: true })
+  await mkdir(userMem, { recursive: true })
+
+  const now = new Date().toISOString().slice(0, 10)
+  const identity = `---\nname: identity\ndescription: Auto-written agent identity facts.\ntype: agent-identity\n---\n# Lyra identity\n\n- Name: Lyra\n- Agent address: ${opts.agentAddress} (${opts.network})\n- Created: ${now}\n${opts.brainProvider ? `- Brain provider: ${opts.brainProvider}\n` : ''}${opts.brainModel ? `- Brain model: ${opts.brainModel}\n` : ''}`
+  const persona =
+    '---\nname: persona\ndescription: Voice + behavior style.\ntype: agent-persona\n---\n# Persona\n\nI am Lyra, a Sui-native autonomous finance agent. I convert goals into policy-checked PTBs, execute only within my approved protocol scope, and store auditable memory and receipts with Walrus. Every value-moving action is checked by a deterministic policy (mirrored on-chain by lyra::policy) before it runs. I am direct, concise, and factual.\n'
+  const profile =
+    '---\nname: profile\ndescription: User profile (local only).\ntype: user\n---\n# User profile\n\n(empty, fills as we chat)\n'
+
+  await writeFile(join(agentMem, 'identity.md'), identity, 'utf8')
+  await writeFile(join(agentMem, 'persona.md'), persona, 'utf8')
+  await writeFile(join(userMem, 'profile.md'), profile, 'utf8')
+  await writeFile(opts.paths.memoryIndex, '# Lyra Memory Index\n\n', 'utf8')
+}

package/src/commands/logs.ts

@@ -0,0 +1,37 @@
+import { readFile } from 'node:fs/promises'
+import { agentPaths } from 'lyra-core'
+import { pickDefaultAgent } from './_agents'
+
+export async function runLogs(opts: { agent?: string; tail?: number } = {}): Promise<void> {
+  // Local mode: read from agentPaths
+  const id = opts.agent ?? (await pickDefaultAgent())
+  if (!id) {
+    console.log('No agents found in ~/.lyra/agents. Run `lyra init` first.')
+    process.exit(1)
+  }
+  const path = agentPaths.agent(id).activityLog
+
+  let raw: string
+  try {
+    raw = await readFile(path, 'utf8')
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === 'ENOENT') {
+      console.log(`No activity log at ${path}`)
+      return
+    }
+    throw e
+  }
+
+  const lines = raw.trimEnd().split('\n').filter(Boolean)
+  const slice = opts.tail ? lines.slice(-opts.tail) : lines
+  for (const line of slice) {
+    try {
+      const entry = JSON.parse(line) as { ts: number; kind: string; data: unknown }
+      const d = new Date(entry.ts).toISOString()
+      const body = JSON.stringify(entry.data)
+      console.log(`${d}  ${entry.kind.padEnd(16)} ${body.slice(0, 200)}`)
+    } catch {
+      console.log(line)
+    }
+  }
+}

package/src/commands/model.ts

@@ -0,0 +1,48 @@
+import { cancel, intro, outro } from '@clack/prompts'
+import { defineConfig } from 'lyra-core'
+import { findAndLoadConfig } from '../config/load'
+import { writeConfigTs } from '../config/render'
+import { pickBrainModel } from './init/model-picker'
+
+/**
+ * `lyra model` — re-pick the brain provider/model. Updates the persisted
+ * config so subsequent `lyra` (chat) sessions use the new choice.
+ *
+ * The TUI also exposes `/model` as a slash command for in-session switching;
+ * see `chat.tsx`.
+ */
+export async function runModel(): Promise<void> {
+  intro('lyra model')
+
+  const loaded = await findAndLoadConfig()
+  if (!loaded) {
+    cancel('No lyra.config.ts found. Run `lyra init` first.')
+    return
+  }
+  const { config } = loaded
+
+  const pick = await pickBrainModel()
+  if (!pick) {
+    cancel('No model picked.')
+    return
+  }
+
+  const updated = defineConfig({
+    ...config,
+    brain: { provider: pick.provider, model: pick.model },
+  })
+  await writeConfigTs(loaded.path, updated, {
+    header: '// Updated by `lyra model`. Edit freely; type-safe.',
+  })
+
+  outro(
+    [
+      '',
+      `  brain    ${pick.model ?? '?'}`,
+      `  provider ${pick.provider}`,
+      `  config   ${loaded.path}`,
+      '',
+      'Next chat session will use the new brain.',
+    ].join('\n'),
+  )
+}

package/src/commands/pairing-approve.ts

@@ -0,0 +1,65 @@
+import {
+  PAIRING_ALPHABET,
+  PAIRING_CODE_LENGTH,
+  PairingStore,
+  agentPaths,
+  placeholderAgentId,
+} from 'lyra-core'
+import { findAndLoadConfig } from '../config/load'
+
+export interface RunPairingApproveOpts {
+  platform: string
+  code: string
+}
+
+export async function runPairingApprove(opts: RunPairingApproveOpts): Promise<void> {
+  const normalized = opts.code.toUpperCase().trim()
+  if (normalized.length !== PAIRING_CODE_LENGTH) {
+    console.error(
+      `Invalid pairing code: expected ${PAIRING_CODE_LENGTH} characters, got ${normalized.length}`,
+    )
+    process.exit(1)
+  }
+  for (const ch of normalized) {
+    if (!PAIRING_ALPHABET.includes(ch)) {
+      console.error(`Invalid pairing code: contains '${ch}' which is not in the pairing alphabet`)
+      process.exit(1)
+    }
+  }
+
+  const loaded = await findAndLoadConfig()
+  if (!loaded) {
+    console.error('No lyra.config.ts found. Run `lyra init` first.')
+    process.exit(1)
+  }
+  const { config } = loaded
+  if (!config.identity.agent) {
+    console.error('Config has no agent. Run `lyra init` first.')
+    process.exit(1)
+  }
+
+  // Operate directly on the host's PairingStore (same path as the daemon
+  // process when LYRA_FORCE_EMBEDDED or local-mode chat.tsx).
+  const agentId = placeholderAgentId(config.identity.agent)
+  const dir = agentPaths.agent(agentId).pairingDir
+  const store = new PairingStore({ dir })
+
+  const result = store.approveCode(opts.platform, normalized)
+  if (!result) {
+    if (store.isLockedOut(opts.platform)) {
+      console.error(
+        `Platform '${opts.platform}' is locked out due to repeated bad codes. Wait 1 hour and try again.`,
+      )
+      process.exit(1)
+    }
+    console.error(`Code ${normalized} not found in pending list. Maybe it expired (1h TTL).`)
+    process.exit(1)
+  }
+
+  console.log(
+    `✓ Approved on ${opts.platform}: id=${result.userId}${
+      result.userName ? ` (@${result.userName})` : ''
+    }`,
+  )
+  console.log('The user can now DM the bot. Their next message will be processed.')
+}

package/src/commands/pairing-clear.ts

@@ -0,0 +1,39 @@
+import { confirm, isCancel } from '@clack/prompts'
+import { PairingStore, agentPaths, placeholderAgentId } from 'lyra-core'
+import { findAndLoadConfig } from '../config/load'
+
+export interface RunPairingClearOpts {
+  platform?: string
+  yes?: boolean
+}
+
+export async function runPairingClear(opts: RunPairingClearOpts): Promise<void> {
+  const loaded = await findAndLoadConfig()
+  if (!loaded) {
+    console.error('No lyra.config.ts found. Run `lyra init` first.')
+    process.exit(1)
+  }
+  const { config } = loaded
+  if (!config.identity.agent) {
+    console.error('Config has no agent. Run `lyra init` first.')
+    process.exit(1)
+  }
+  const agentId = placeholderAgentId(config.identity.agent)
+  const dir = agentPaths.agent(agentId).pairingDir
+  const store = new PairingStore({ dir })
+
+  if (!opts.yes) {
+    const target = opts.platform ? `${opts.platform} pending` : 'ALL pending pairing codes'
+    const ok = await confirm({
+      message: `Clear ${target}?`,
+      initialValue: false,
+    })
+    if (isCancel(ok) || !ok) {
+      console.log('Aborted.')
+      return
+    }
+  }
+
+  const count = store.clearPending(opts.platform)
+  console.log(`✓ Cleared ${count} pending pairing code${count === 1 ? '' : 's'}`)
+}

package/src/commands/pairing-list.ts

@@ -0,0 +1,55 @@
+import { PairingStore, agentPaths, placeholderAgentId } from 'lyra-core'
+import { findAndLoadConfig } from '../config/load'
+
+export interface RunPairingListOpts {
+  platform?: string
+}
+
+export async function runPairingList(opts: RunPairingListOpts): Promise<void> {
+  const store = await openPairingStore()
+  if (!store) return
+
+  const pending = store.listPending(opts.platform)
+  const approved = store.listApproved(opts.platform)
+
+  const pendingTitle = opts.platform ? `Pending (${opts.platform})` : 'Pending'
+  console.log(`\n${pendingTitle} (1h TTL):`)
+  if (pending.length === 0) {
+    console.log('  (none)')
+  } else {
+    for (const p of pending) {
+      const userLabel = p.userName ? `@${p.userName}` : '(unknown)'
+      const idLabel = `id=${p.userId}`
+      console.log(`  [${p.platform}] ${p.code}  ${userLabel} ${idLabel}  age=${p.ageMinutes}m`)
+    }
+  }
+
+  const approvedTitle = opts.platform ? `Approved (${opts.platform})` : 'Approved'
+  console.log(`\n${approvedTitle}:`)
+  if (approved.length === 0) {
+    console.log('  (none)')
+  } else {
+    for (const a of approved) {
+      const userLabel = a.userName ? `@${a.userName}` : '(unknown)'
+      const idLabel = `id=${a.userId}`
+      console.log(`  [${a.platform}] ${userLabel} ${idLabel}`)
+    }
+  }
+  console.log()
+}
+
+async function openPairingStore(): Promise<PairingStore | null> {
+  const loaded = await findAndLoadConfig()
+  if (!loaded) {
+    console.error('No lyra.config.ts found. Run `lyra init` first.')
+    return null
+  }
+  const { config } = loaded
+  if (!config.identity.agent) {
+    console.error('Config has no agent. Run `lyra init` first.')
+    return null
+  }
+  const agentId = placeholderAgentId(config.identity.agent)
+  const dir = agentPaths.agent(agentId).pairingDir
+  return new PairingStore({ dir })
+}

package/src/commands/pairing-revoke.ts

@@ -0,0 +1,49 @@
+import { confirm, isCancel } from '@clack/prompts'
+import { PairingStore, agentPaths, placeholderAgentId } from 'lyra-core'
+import { findAndLoadConfig } from '../config/load'
+
+export interface RunPairingRevokeOpts {
+  platform: string
+  userId: string
+  yes?: boolean
+}
+
+export async function runPairingRevoke(opts: RunPairingRevokeOpts): Promise<void> {
+  const loaded = await findAndLoadConfig()
+  if (!loaded) {
+    console.error('No lyra.config.ts found. Run `lyra init` first.')
+    process.exit(1)
+  }
+  const { config } = loaded
+  if (!config.identity.agent) {
+    console.error('Config has no agent. Run `lyra init` first.')
+    process.exit(1)
+  }
+  const agentId = placeholderAgentId(config.identity.agent)
+  const dir = agentPaths.agent(agentId).pairingDir
+  const store = new PairingStore({ dir })
+
+  if (!store.isApproved(opts.platform, opts.userId)) {
+    console.error(`User ${opts.userId} is not on the ${opts.platform} approved list.`)
+    process.exit(1)
+  }
+
+  if (!opts.yes) {
+    const ok = await confirm({
+      message: `Revoke ${opts.platform} access for user id ${opts.userId}?`,
+      initialValue: false,
+    })
+    if (isCancel(ok) || !ok) {
+      console.log('Aborted.')
+      return
+    }
+  }
+
+  const removed = store.revoke(opts.platform, opts.userId)
+  if (removed) {
+    console.log(`✓ Revoked: ${opts.platform} id=${opts.userId}`)
+  } else {
+    console.error('Revoke failed (concurrent removal?)')
+    process.exit(1)
+  }
+}

package/src/commands/pairing.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'bun:test'
+import { parsePairingArgs } from './pairing'
+
+describe('parsePairingArgs', () => {
+  it('errors on no args', () => {
+    const r = parsePairingArgs([])
+    expect('error' in r).toBe(true)
+  })
+
+  it('errors on unknown subcommand', () => {
+    const r = parsePairingArgs(['quack'])
+    expect('error' in r).toBe(true)
+  })
+
+  it('parses `list`', () => {
+    const r = parsePairingArgs(['list']) as Exclude<
+      ReturnType<typeof parsePairingArgs>,
+      { error: string }
+    >
+    expect(r.sub).toBe('list')
+  })
+
+  it('parses `list telegram` with platform filter', () => {
+    const r = parsePairingArgs(['list', 'telegram']) as Exclude<
+      ReturnType<typeof parsePairingArgs>,
+      { error: string }
+    >
+    expect(r.sub).toBe('list')
+    expect(r.platform).toBe('telegram')
+  })
+
+  it('parses `approve telegram ABCDEFGH`', () => {
+    const r = parsePairingArgs(['approve', 'telegram', 'ABCDEFGH']) as Exclude<
+      ReturnType<typeof parsePairingArgs>,
+      { error: string }
+    >
+    expect(r.sub).toBe('approve')
+    expect(r.platform).toBe('telegram')
+    expect(r.code).toBe('ABCDEFGH')
+  })
+
+  it('errors on `approve` without arguments', () => {
+    const r = parsePairingArgs(['approve'])
+    expect('error' in r).toBe(true)
+  })
+
+  it('errors on `approve telegram` without code', () => {
+    const r = parsePairingArgs(['approve', 'telegram'])
+    expect('error' in r).toBe(true)
+  })
+
+  it('parses `revoke telegram 12345`', () => {
+    const r = parsePairingArgs(['revoke', 'telegram', '12345']) as Exclude<
+      ReturnType<typeof parsePairingArgs>,
+      { error: string }
+    >
+    expect(r.sub).toBe('revoke')
+    expect(r.platform).toBe('telegram')
+    expect(r.userId).toBe('12345')
+  })
+
+  it('parses `clear-pending` and `clear-pending telegram`', () => {
+    const a = parsePairingArgs(['clear-pending']) as Exclude<
+      ReturnType<typeof parsePairingArgs>,
+      { error: string }
+    >
+    expect(a.sub).toBe('clear-pending')
+    expect(a.platform).toBeUndefined()
+    const b = parsePairingArgs(['clear-pending', 'telegram']) as Exclude<
+      ReturnType<typeof parsePairingArgs>,
+      { error: string }
+    >
+    expect(b.platform).toBe('telegram')
+  })
+
+  it('extracts --yes / -y flag', () => {
+    const r = parsePairingArgs(['revoke', 'telegram', '12345', '--yes']) as Exclude<
+      ReturnType<typeof parsePairingArgs>,
+      { error: string }
+    >
+    expect(r.yes).toBe(true)
+    const s = parsePairingArgs(['clear-pending', '-y']) as Exclude<
+      ReturnType<typeof parsePairingArgs>,
+      { error: string }
+    >
+    expect(s.yes).toBe(true)
+  })
+})

package/src/commands/pairing.ts

@@ -0,0 +1,81 @@
+/**
+ * `lyra pairing <subcommand>` — argv dispatcher for the DM pairing flow.
+ *
+ * Subcommands:
+ *   list                          show pending codes + approved users
+ *   approve <platform> <code>     approve a pairing code (case-insensitive)
+ *   revoke <platform> <userId>    revoke an approved user
+ *   clear-pending [platform]      drop all pending codes
+ *
+ * Platform is `telegram` for Phase 12. Future platforms (discord, slack) will
+ * reuse the same command surface.
+ */
+
+export interface PairingArgs {
+  sub: 'list' | 'approve' | 'revoke' | 'clear-pending'
+  platform?: string
+  code?: string
+  userId?: string
+  yes?: boolean
+}
+
+const VALID_SUBS = ['list', 'approve', 'revoke', 'clear-pending'] as const
+
+export type PairingParseResult = PairingArgs | { error: string }
+
+export function parsePairingArgs(argv: string[]): PairingParseResult {
+  const sub = argv[0]
+  if (!sub) {
+    return {
+      error:
+        'usage: lyra pairing <list | approve <platform> <code> | revoke <platform> <userId> | clear-pending [platform]>',
+    }
+  }
+  if (!(VALID_SUBS as readonly string[]).includes(sub)) {
+    return { error: `unknown subcommand '${sub}' (expected: ${VALID_SUBS.join(' | ')})` }
+  }
+  const positional = argv.slice(1).filter(a => !a.startsWith('-'))
+  const yes = argv.includes('--yes') || argv.includes('-y')
+
+  if (sub === 'approve') {
+    if (positional.length < 2) {
+      return { error: 'usage: lyra pairing approve <platform> <code>' }
+    }
+    return { sub: 'approve', platform: positional[0], code: positional[1], yes }
+  }
+  if (sub === 'revoke') {
+    if (positional.length < 2) {
+      return { error: 'usage: lyra pairing revoke <platform> <userId>' }
+    }
+    return { sub: 'revoke', platform: positional[0], userId: positional[1], yes }
+  }
+  if (sub === 'clear-pending') {
+    return { sub: 'clear-pending', platform: positional[0], yes }
+  }
+  return { sub: 'list', platform: positional[0], yes }
+}
+
+export async function runPairing(args: PairingArgs): Promise<void> {
+  switch (args.sub) {
+    case 'list': {
+      const { runPairingList } = await import('./pairing-list')
+      await runPairingList({ platform: args.platform })
+      return
+    }
+    case 'approve': {
+      const { runPairingApprove } = await import('./pairing-approve')
+      await runPairingApprove({ platform: args.platform!, code: args.code! })
+      return
+    }
+    case 'revoke': {
+      const { runPairingRevoke } = await import('./pairing-revoke')
+      await runPairingRevoke({ platform: args.platform!, userId: args.userId!, yes: args.yes })
+      return
+    }
+    case 'clear-pending': {
+      const { runPairingClear } = await import('./pairing-clear')
+      await runPairingClear({ platform: args.platform, yes: args.yes })
+      return
+    }
+  }
+}