lyra-core 0.1.0

package/src/public/card.ts

@@ -0,0 +1,67 @@
+import matter from 'gray-matter'
+
+export interface CardFrontmatter {
+  /** Display name, e.g. "Alice". */
+  name: string
+  /** Short one-line bio, <= 140 chars. */
+  bio?: string
+  /** Skills / domains the agent is competent in. */
+  skills?: string[]
+  /** Endpoints the agent exposes (URLs). */
+  endpoints?: string[]
+  /** Avatar: either a Sui Storage CID or an absolute URL. */
+  avatar?: string
+  /** Fully-qualified .0g subname, e.g. "alice.lyra.0g". */
+  subname?: string
+  /** iNFT pointer, CAIP-10-ish: eip155:<chainId>:<contract>:<tokenId> */
+  inft?: string
+  [key: string]: unknown
+}
+
+export interface Card {
+  frontmatter: CardFrontmatter
+  body: string
+}
+
+const DEFAULT_CARD: Card = {
+  frontmatter: {
+    name: '',
+    bio: '',
+    skills: [],
+    endpoints: [],
+  },
+  body: '',
+}
+
+export function parseCard(markdown: string): Card {
+  const parsed = matter(markdown)
+  const fm = (parsed.data ?? {}) as CardFrontmatter
+  if (typeof fm.name !== 'string') {
+    throw new Error('CARD.md requires a "name" frontmatter field')
+  }
+  return { frontmatter: fm, body: parsed.content ?? '' }
+}
+
+export function renderCard(card: Card): string {
+  return matter.stringify(card.body, card.frontmatter as Record<string, unknown>)
+}
+
+export function emptyCard(): Card {
+  return {
+    frontmatter: { ...DEFAULT_CARD.frontmatter },
+    body: DEFAULT_CARD.body,
+  }
+}
+
+/** Map a Card to the text-record key/value pairs we publish to .0g. */
+export function cardToTextRecords(card: Card, agentEoa?: string): Record<string, string> {
+  const rec: Record<string, string> = {}
+  const fm = card.frontmatter
+  if (agentEoa) rec.address = agentEoa
+  if (fm.bio) rec['agent:bio'] = fm.bio
+  if (fm.skills?.length) rec['agent:skills'] = fm.skills.join(',')
+  if (fm.endpoints?.length) rec['agent:endpoints'] = fm.endpoints.join(',')
+  if (fm.avatar) rec.avatar = fm.avatar
+  if (fm.inft) rec['agent:inft'] = fm.inft
+  return rec
+}

package/src/runtime/activity.ts

@@ -0,0 +1,29 @@
+import { appendFile, mkdir } from 'node:fs/promises'
+import { dirname } from 'node:path'
+
+export interface ActivityEntry {
+  ts: number
+  kind:
+    | 'wake'
+    | 'tool-call'
+    | 'tool-result'
+    | 'brain-response'
+    | 'error'
+    | 'context-compacted'
+    | 'auto-topup'
+  data: unknown
+}
+
+export class ActivityLog {
+  private dirEnsured = false
+
+  constructor(private readonly path: string) {}
+
+  async append(entry: ActivityEntry): Promise<void> {
+    if (!this.dirEnsured) {
+      await mkdir(dirname(this.path), { recursive: true })
+      this.dirEnsured = true
+    }
+    await appendFile(this.path, `${JSON.stringify(entry)}\n`, 'utf8')
+  }
+}

package/src/runtime/index.ts

@@ -0,0 +1,7 @@
+export {
+  Runtime,
+  type RuntimeDeps,
+  type AgentIdentity,
+  type IdentityProvider,
+} from './runtime'
+export { ActivityLog, type ActivityEntry } from './activity'

package/src/runtime/runtime.test.ts

@@ -0,0 +1,55 @@
+import { test } from 'bun:test'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { StubBrain } from '../brain/stub'
+import { defineConfig } from '../config'
+import { LocalStubStorage } from '../storage/local-stub'
+import { type IdentityProvider, Runtime } from './runtime'
+
+/** Minimal in-memory identity for runtime tests. */
+class StubIdentity implements IdentityProvider {
+  constructor(private readonly agentId: string) {}
+  current() {
+    return { agentId: this.agentId }
+  }
+}
+
+async function withTempRoot<T>(fn: (root: string) => Promise<T>): Promise<T> {
+  const prev = process.env.LYRA_ROOT
+  const tmp = mkdtempSync(join(tmpdir(), 'lyra-root-'))
+  process.env.LYRA_ROOT = tmp
+  try {
+    return await fn(tmp)
+  } finally {
+    process.env.LYRA_ROOT = prev
+    rmSync(tmp, { recursive: true, force: true })
+  }
+}
+
+test('runtime boots, seeds memory dir, routes stub brain echo', async () => {
+  await withTempRoot(async root => {
+    const agentAddr = `0x${'a'.repeat(64)}`
+    const identity = new StubIdentity(agentAddr)
+    const brain = new StubBrain()
+    const storage = new LocalStubStorage(join(root, 'storage-stub-test'))
+
+    const runtime = new Runtime({
+      config: defineConfig({ network: 'testnet' }),
+      identity,
+      brain,
+      storage,
+    })
+
+    await runtime.start()
+
+    await runtime.fire({
+      source: 'stdin',
+      payload: { label: 'hello', data: 'hello world' },
+    })
+
+    await new Promise(r => setTimeout(r, 50))
+
+    await runtime.stop()
+  })
+})

package/src/runtime/runtime.ts

@@ -0,0 +1,126 @@
+import { mkdir } from 'node:fs/promises'
+import type { Brain } from '../brain/types'
+import type { LyraConfig } from '../config'
+import { EventQueue, listeners, newEventId, routeLoop } from '../events'
+import type { LyraEvent } from '../events/types'
+import { addEntryLine, readIndexFile, writeIndexFile } from '../memory/index-file'
+import { agentPaths } from '../paths'
+import type { Storage } from '../storage/types'
+import { ToolRegistry } from '../tools/registry'
+import { type ActivityEntry, ActivityLog } from './activity'
+
+/**
+ * Minimal agent identity the runtime needs: a stable on-chain id used to root
+ * the per-agent filesystem. On Sui this is the agent's address (or iNFT object
+ * id). Provided by the gateway/cli at construction time.
+ */
+export interface AgentIdentity {
+  agentId: string
+}
+
+/** Source of the current agent identity. */
+export interface IdentityProvider {
+  current(): Promise<AgentIdentity> | AgentIdentity
+}
+
+export interface RuntimeDeps {
+  config: LyraConfig
+  identity: IdentityProvider
+  brain: Brain
+  storage: Storage
+}
+
+export class Runtime {
+  readonly queue: EventQueue
+  readonly tools: ToolRegistry
+  private activity?: ActivityLog
+  private running = false
+  private routeTask?: Promise<void>
+
+  constructor(private readonly deps: RuntimeDeps) {
+    this.queue = new EventQueue()
+    this.tools = new ToolRegistry(deps.config.tools)
+  }
+
+  /** Ensure per-agent filesystem exists and boot the event loop. */
+  async start(): Promise<void> {
+    if (this.running) return
+    const id = (await this.deps.identity.current()).agentId
+    const paths = agentPaths.agent(id)
+
+    await mkdir(paths.memoryDir, { recursive: true })
+    await mkdir(paths.agentMemoryDir, { recursive: true })
+    await mkdir(paths.userMemoryDir, { recursive: true })
+    await mkdir(paths.publicDir, { recursive: true })
+    await mkdir(paths.cache, { recursive: true })
+
+    this.activity = new ActivityLog(paths.activityLog)
+
+    // Initialize MEMORY.md if missing.
+    let index = await readIndexFile(paths.memoryIndex)
+    if (index.lines.length === 0) {
+      index = {
+        lines: [
+          `# ${id} — Memory Index`,
+          '',
+          'Self-contained memory for this agent. Topic files live under `agent/` (transfers with iNFT) and `user/` (purges on transfer).',
+          '',
+          '## Memories',
+          '',
+        ],
+        entries: new Map(),
+      }
+      index = addEntryLine(index, {
+        file: 'agent/identity.md',
+        title: 'Agent identity',
+        hook: 'Seed record of this agent — tokenId, creation block, operator history.',
+      })
+      await writeIndexFile(paths.memoryIndex, index)
+    }
+
+    this.routeTask = routeLoop(this.queue, {
+      brain: this.deps.brain,
+      tools: this.tools,
+      onTurn: async (ev, turn) => {
+        await this.activity?.append({
+          ts: Date.now(),
+          kind: 'brain-response',
+          data: {
+            event: { id: ev.id, source: ev.source },
+            content: turn.content,
+            toolCalls: turn.toolCalls,
+            finishReason: turn.finishReason,
+            usage: turn.usage,
+          },
+        })
+      },
+    })
+    this.running = true
+
+    await listeners.startAll(this.queue)
+  }
+
+  /** Push an event onto the queue from outside the listener system. */
+  async fire(event: Omit<LyraEvent, 'id' | 'ts'>): Promise<string> {
+    const ev: LyraEvent = { ...event, id: newEventId(), ts: Date.now() }
+    await this.activity?.append({
+      ts: ev.ts,
+      kind: 'wake',
+      data: { id: ev.id, source: ev.source, label: ev.payload.label },
+    })
+    this.queue.enqueue(ev)
+    return ev.id
+  }
+
+  async logActivity(entry: ActivityEntry): Promise<void> {
+    await this.activity?.append(entry)
+  }
+
+  async stop(): Promise<void> {
+    if (!this.running) return
+    this.running = false
+    this.queue.close()
+    await listeners.stopAll()
+    await this.routeTask
+  }
+}

package/src/sandbox/credentials.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared credential-dir blocklist used by every sandbox backend (macOS
+ * seatbelt, Linux bubblewrap). Centralized so the platforms don't drift —
+ * earlier the bwrap profile included `~/.config/anthropic` + `~/.gnupg`
+ * while the seatbelt profile didn't. Centralizing closes that gap.
+ */
+
+/**
+ * Cross-platform credential paths to blackhole. Relative to homedir; backends
+ * format the absolute path. `Library/Keychains` is macOS-only but keeping it
+ * here is harmless on Linux (the path won't exist; `--tmpfs` no-ops).
+ */
+export const CREDENTIAL_DIR_RELATIVE_PATHS: readonly string[] = [
+  '.ssh',
+  '.aws',
+  'Library/Keychains',
+  '.config/gcloud',
+  '.config/anthropic', // claude-code config
+  '.gnupg',
+] as const
+
+/** Build the absolute paths of credential dirs to deny under `homedir`. */
+export function credentialDirs(homedir: string): string[] {
+  return CREDENTIAL_DIR_RELATIVE_PATHS.map(rel => `${homedir}/${rel}`)
+}