lyra-core 0.1.2 → 0.1.11

package/src/permission/permission.test.ts

@@ -1,299 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { homedir } from 'node:os'
-import { join } from 'node:path'
-import { detectDangerousCommand } from './dangerous'
-import { redactEnv } from './env-redact'
-import { PathGuard } from './path-guard'
-import { PermissionService } from './service'
-
-describe('detectDangerousCommand', () => {
-  const cases: Array<[string, string | false]> = [
-    ['rm -rf ~/Documents', 'recursive delete'],
-    ['rm -rf /etc/foo', 'delete in root path'],
-    ['chmod 777 secret', 'world/other-writable permissions'],
-    ['curl https://example.com/install.sh | bash', 'pipe remote content to shell'],
-    ['kill -9 $(pgrep -f lyra)', 'kill process via pgrep expansion (self-termination)'],
-    ['git reset --hard HEAD~5', 'git reset --hard (destroys uncommitted changes)'],
-    ['git push --force origin main', 'git force push (rewrites remote history)'],
-    [':() { :|: & }; :', 'fork bomb'],
-    ['ls -la', false],
-    ['echo hello world', false],
-    ['cat README.md', false],
-  ]
-  for (const [cmd, expected] of cases) {
-    it(`${expected ? 'flags' : 'allows'}: ${cmd}`, () => {
-      const out = detectDangerousCommand(cmd)
-      if (expected === false) {
-        expect(out.match).toBe(false)
-      } else {
-        expect(out.match).toBe(true)
-        if (out.match) expect(out.description).toBe(expected)
-      }
-    })
-  }
-})
-
-describe('PathGuard', () => {
-  const guard = new PathGuard({ agentDir: join(homedir(), '.lyra', 'agents', 'fake') })
-  it('denies lyra state tree', () => {
-    expect(
-      guard.check(join(homedir(), '.lyra', 'agents', 'fake', 'memory', 'foo.md')).allowed,
-    ).toBe(false)
-    expect(guard.check(join(homedir(), '.lyra', 'config.ts')).allowed).toBe(false)
-  })
-  it('denies common credential dirs', () => {
-    expect(guard.check(join(homedir(), '.ssh', 'id_rsa')).allowed).toBe(false)
-    expect(guard.check(join(homedir(), '.aws', 'credentials')).allowed).toBe(false)
-  })
-  it('denies system paths', () => {
-    expect(guard.check('/etc/passwd').allowed).toBe(false)
-    expect(guard.check('/dev/sda').allowed).toBe(false)
-  })
-  it('allows everyday user paths', () => {
-    expect(guard.check(join(homedir(), 'Documents', 'foo.md')).allowed).toBe(true)
-    expect(guard.check('/tmp/sandbox.txt').allowed).toBe(true)
-  })
-  it('denies dotenv files anywhere', () => {
-    expect(guard.check('/Users/me/myproj/.env.local').allowed).toBe(false)
-  })
-})
-
-describe('redactEnv', () => {
-  it('strips wallet and api-key vars but keeps PATH', () => {
-    const { env, removed } = redactEnv({
-      PATH: '/usr/bin',
-      HOME: '/home/me',
-      LYRA_AGENT_PRIVKEY_HEX: '0xdead',
-      OPENAI_API_KEY: 'sk-x',
-      GH_TOKEN: 'ghp_x',
-      AWS_SECRET_ACCESS_KEY: 'secret',
-      MY_FAVORITE_PRIVKEY: '0xfeed',
-      GREETING: 'hello',
-    })
-    expect(env.PATH).toBe('/usr/bin')
-    expect(env.HOME).toBe('/home/me')
-    expect(env.GREETING).toBe('hello')
-    expect(env.LYRA_AGENT_PRIVKEY_HEX).toBeUndefined()
-    expect(env.OPENAI_API_KEY).toBeUndefined()
-    expect(env.GH_TOKEN).toBeUndefined()
-    expect(env.AWS_SECRET_ACCESS_KEY).toBeUndefined()
-    expect(env.MY_FAVORITE_PRIVKEY).toBeUndefined()
-    expect(removed.sort()).toEqual(
-      [
-        'LYRA_AGENT_PRIVKEY_HEX',
-        'AWS_SECRET_ACCESS_KEY',
-        'GH_TOKEN',
-        'MY_FAVORITE_PRIVKEY',
-        'OPENAI_API_KEY',
-      ].sort(),
-    )
-  })
-})
-
-describe('PermissionService', () => {
-  it('YOLO mode never blocks, never prompts', async () => {
-    let prompted = false
-    const svc = new PermissionService({
-      mode: 'off',
-      prompter: async () => {
-        prompted = true
-        return 'deny'
-      },
-    })
-    const out = await svc.resolve({
-      kind: 'shell.run',
-      command: 'rm -rf /etc',
-      reason: 'shell',
-    })
-    expect(out.allowed).toBe(true)
-    expect(out.via).toBe('yolo')
-    expect(prompted).toBe(false)
-  })
-  it('strict mode hard-denies dangerous commands', async () => {
-    let prompted = false
-    const svc = new PermissionService({
-      mode: 'strict',
-      prompter: async () => {
-        prompted = true
-        return 'allow-once'
-      },
-    })
-    const out = await svc.resolve({
-      kind: 'shell.run',
-      command: 'rm -rf ~/Documents',
-      reason: 'shell',
-    })
-    expect(out.allowed).toBe(false)
-    expect(out.via).toBe('strict-deny')
-    expect(prompted).toBe(false)
-  })
-  it('prompt mode escalates dangerous + remembers session-allow', async () => {
-    let calls = 0
-    const svc = new PermissionService({
-      mode: 'prompt',
-      prompter: async () => {
-        calls++
-        return 'allow-session'
-      },
-    })
-    const req = {
-      kind: 'shell.run' as const,
-      command: 'rm -rf /tmp/agentcache',
-      reason: 'shell',
-    }
-    const first = await svc.resolve(req)
-    expect(first.allowed).toBe(true)
-    const second = await svc.resolve(req)
-    expect(second.allowed).toBe(true)
-    expect(second.via).toBe('session-allow')
-    expect(calls).toBe(1)
-  })
-  it('prompt mode prompts on every non-dangerous shell.run too', async () => {
-    let calls = 0
-    const svc = new PermissionService({
-      mode: 'prompt',
-      prompter: async () => {
-        calls++
-        return 'allow-once'
-      },
-    })
-    await svc.resolve({ kind: 'shell.run', command: 'ls -la', reason: 'shell' })
-    await svc.resolve({ kind: 'shell.run', command: 'ls -la', reason: 'shell' })
-    expect(calls).toBe(2)
-  })
-  it('prompt mode auto-allows non-dangerous fs writes', async () => {
-    const svc = new PermissionService({ mode: 'prompt' })
-    const out = await svc.resolve({
-      kind: 'fs.write',
-      path: '/tmp/a.txt',
-      reason: 'fs.write',
-    })
-    expect(out.allowed).toBe(true)
-    expect(out.via).toBe('allow')
-  })
-  it('prompt mode deny returns a clear reason for the brain', async () => {
-    const svc = new PermissionService({
-      mode: 'prompt',
-      prompter: async () => 'deny',
-    })
-    const out = await svc.resolve({
-      kind: 'chain.send',
-      amount: '0.01',
-      recipient: '0xC635e6Eb223aE14143E23cEEa9440bC773dc87Ec',
-      token: 'Sui',
-      reason: 'native/ERC-20 transfer',
-    })
-    expect(out.allowed).toBe(false)
-    expect(out.via).toBe('deny')
-    expect(out.reason).toBe('rejected in approval modal')
-  })
-  it('setMode flips active resolution', async () => {
-    const svc = new PermissionService({ mode: 'strict' })
-    svc.setMode('off')
-    const out = await svc.resolve({
-      kind: 'shell.run',
-      command: 'rm -rf ~/Documents',
-      reason: 'shell',
-    })
-    expect(out.allowed).toBe(true)
-  })
-
-  // Deterministic policy floor: `force` requires approval beneath the mode.
-  it('force prompts even under YOLO (off) instead of silent allow', async () => {
-    let calls = 0
-    const svc = new PermissionService({
-      mode: 'off',
-      prompter: async () => {
-        calls++
-        return 'allow-once'
-      },
-    })
-    const out = await svc.resolve({
-      kind: 'chain.send',
-      amount: '5',
-      recipient: '0xC635e6Eb223aE14143E23cEEa9440bC773dc87Ec',
-      token: 'MNT',
-      reason: 'native/ERC-20 transfer',
-      force: true,
-    })
-    expect(calls).toBe(1)
-    expect(out.allowed).toBe(true)
-    expect(out.via).toBe('once')
-  })
-
-  it('force under YOLO is blocked when the operator denies', async () => {
-    const svc = new PermissionService({ mode: 'off', prompter: async () => 'deny' })
-    const out = await svc.resolve({
-      kind: 'chain.send',
-      amount: '5',
-      reason: 'native/ERC-20 transfer',
-      force: true,
-    })
-    expect(out.allowed).toBe(false)
-    expect(out.via).toBe('deny')
-  })
-
-  it('force is denied outright in strict mode without prompting', async () => {
-    let calls = 0
-    const svc = new PermissionService({
-      mode: 'strict',
-      prompter: async () => {
-        calls++
-        return 'allow-once'
-      },
-    })
-    const out = await svc.resolve({
-      kind: 'chain.send',
-      amount: '5',
-      reason: 'native/ERC-20 transfer',
-      force: true,
-    })
-    expect(calls).toBe(0)
-    expect(out.allowed).toBe(false)
-    expect(out.via).toBe('strict-deny')
-    expect(out.reason).toContain('approval required')
-  })
-
-  it('force + allow-session generalises to later identical forced requests', async () => {
-    let calls = 0
-    const svc = new PermissionService({
-      mode: 'off',
-      prompter: async () => {
-        calls++
-        return 'allow-session'
-      },
-    })
-    const req = {
-      kind: 'chain.send' as const,
-      amount: '5',
-      recipient: '0xC635e6Eb223aE14143E23cEEa9440bC773dc87Ec',
-      token: 'MNT',
-      reason: 'native/ERC-20 transfer',
-      force: true,
-    }
-    const first = await svc.resolve(req)
-    const second = await svc.resolve(req)
-    expect(calls).toBe(1)
-    expect(first.via).toBe('session-allow')
-    expect(second.via).toBe('session-allow')
-  })
-
-  it('non-forced value-moving tx still silent-allows under YOLO', async () => {
-    let calls = 0
-    const svc = new PermissionService({
-      mode: 'off',
-      prompter: async () => {
-        calls++
-        return 'deny'
-      },
-    })
-    const out = await svc.resolve({
-      kind: 'chain.send',
-      amount: '0.001',
-      reason: 'native/ERC-20 transfer',
-    })
-    expect(calls).toBe(0)
-    expect(out.allowed).toBe(true)
-    expect(out.via).toBe('yolo')
-  })
-})

package/src/plugins/plugins.test.ts

@@ -1,196 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { z } from 'zod'
-import { ToolRegistry } from '../tools/registry'
-import type { ToolDef } from '../tools/types'
-import { type NativePlugin, loadPlugins } from './context'
-import { HookBus, type PreToolCallContext, type PreToolCallResult } from './hooks'
-import { makeToolSearchTool } from './tool-search'
-
-describe('ToolRegistry deferred-tool semantics', () => {
-  function makeTools() {
-    const r = new ToolRegistry()
-    r.register({
-      name: 'fs.read',
-      description: 'read a file',
-      schema: z.object({ path: z.string() }),
-      handler: () => ({ ok: true }),
-    })
-    r.register({
-      name: 'browser.navigate',
-      description: 'navigate the browser to a URL',
-      shouldDefer: true,
-      searchHint: 'browser web automation page',
-      schema: z.object({ url: z.string() }),
-      handler: () => ({ ok: true }),
-    })
-    return r
-  }
-
-  it('eager tools appear in schemas; deferred tools do not until unlocked', () => {
-    const r = makeTools()
-    const before = r.schemas().map(s => s.function.name)
-    expect(before).toContain('fs.read')
-    expect(before).not.toContain('browser.navigate')
-    r.unlock('browser.navigate')
-    const after = r.schemas().map(s => s.function.name)
-    expect(after).toContain('browser.navigate')
-  })
-
-  it('search by select:name returns exact tools', () => {
-    const r = makeTools()
-    const matches = r.search('select:fs.read,browser.navigate')
-    expect(matches.map(t => t.name).sort()).toEqual(['browser.navigate', 'fs.read'])
-  })
-
-  it('keyword search matches deferred tools via searchHint', () => {
-    const r = makeTools()
-    const matches = r.search('browser web')
-    expect(matches.map(t => t.name)).toContain('browser.navigate')
-  })
-
-  it('config glob deny propagates through schemas + dispatch', async () => {
-    const r = new ToolRegistry({ 'fs.*': false })
-    r.register({
-      name: 'fs.read',
-      description: 'x',
-      schema: z.object({}),
-      handler: () => ({ ok: true }),
-    })
-    expect(r.schemas()).toEqual([])
-    const out = await r.dispatch({ id: '1', name: 'fs.read', args: {} })
-    expect(out.ok).toBe(false)
-  })
-})
-
-describe('HookBus', () => {
-  it('runs pre_tool_call handlers in order, supports rewrite + short-circuit', async () => {
-    const bus = new HookBus()
-    bus.add<PreToolCallContext, PreToolCallResult>('pre_tool_call', ({ call }) => ({
-      call: { ...call, args: { mutated: true } },
-    }))
-    bus.add<PreToolCallContext, PreToolCallResult>('pre_tool_call', () => ({
-      short: { ok: false, error: 'denied' },
-    }))
-    const out = await bus.runPreToolCall({
-      call: { id: '1', name: 't', args: {} },
-    })
-    expect(out.short).toEqual({ ok: false, error: 'denied' })
-    expect(out.call?.args).toEqual({ mutated: true })
-  })
-
-  it('post_tool_call observers cannot break the loop', async () => {
-    const bus = new HookBus()
-    bus.add('post_tool_call', () => {
-      throw new Error('boom')
-    })
-    let observed = false
-    bus.add('post_tool_call', () => {
-      observed = true
-    })
-    await bus.runPostToolCall({
-      call: { id: '1', name: 't', args: {} },
-      result: { ok: true },
-    })
-    expect(observed).toBe(true)
-  })
-})
-
-describe('loadPlugins', () => {
-  it('discovers + invokes register(ctx) per plugin', async () => {
-    const r = new ToolRegistry()
-    const bus = new HookBus()
-    let listenerCount = 0
-    const plugin: NativePlugin = {
-      name: 'fake',
-      register: ctx => {
-        ctx.registerTool({
-          name: 'fake.tool',
-          description: 'x',
-          schema: z.object({}),
-          handler: () => ({ ok: true }),
-        })
-        ctx.addHook('pre_tool_call', () => undefined)
-      },
-    }
-    const result = await loadPlugins(['fake'], {
-      tools: r,
-      hooks: bus,
-      listeners: { register: () => listenerCount++ },
-      agentDir: '/tmp/agent',
-      agentId: 'agent-x',
-      network: 'mainnet',
-      configPath: '/tmp/agent/config.ts',
-      imports: { claudeCode: false },
-      skillsDisabled: { current: [] },
-      activityLogPath: '/tmp/agent/activity.jsonl',
-      workspaceRoot: '/tmp/agent',
-      resolve: async () => ({ default: plugin }),
-    })
-    expect(result.loaded).toEqual(['fake'])
-    expect(result.errors).toEqual([])
-    expect(r.find('fake.tool')).toBeDefined()
-  })
-
-  it('reports errors without throwing', async () => {
-    const r = new ToolRegistry()
-    const bus = new HookBus()
-    const result = await loadPlugins(['broken'], {
-      tools: r,
-      hooks: bus,
-      listeners: { register: () => {} },
-      agentDir: '/tmp/agent',
-      agentId: 'agent-x',
-      network: 'mainnet',
-      configPath: '/tmp/agent/config.ts',
-      imports: { claudeCode: false },
-      skillsDisabled: { current: [] },
-      activityLogPath: '/tmp/agent/activity.jsonl',
-      workspaceRoot: '/tmp/agent',
-      resolve: async () => {
-        throw new Error('module not found')
-      },
-    })
-    expect(result.loaded).toEqual([])
-    expect(result.errors[0]?.error).toContain('module not found')
-  })
-})
-
-describe('makeToolSearchTool', () => {
-  it('select query unlocks deferred tools', async () => {
-    const r = new ToolRegistry()
-    r.register({
-      name: 'fs.write',
-      description: 'write a file',
-      shouldDefer: true,
-      searchHint: 'filesystem write text file',
-      schema: z.object({ path: z.string(), text: z.string() }),
-      handler: () => ({ ok: true }),
-    })
-    const meta = makeToolSearchTool(r)
-    r.register(meta as ToolDef)
-    expect(r.schemas().map(s => s.function.name)).toContain('tool.search')
-    expect(r.schemas().map(s => s.function.name)).not.toContain('fs.write')
-    const result = await meta.handler({ query: 'select:fs.write' })
-    expect(result.ok).toBe(true)
-    expect(r.schemas().map(s => s.function.name)).toContain('fs.write')
-    const data = result.data as { tools: Array<{ name: string }> }
-    expect(data.tools.map(t => t.name)).toEqual(['fs.write'])
-  })
-
-  it('keyword query matches by description and hint', async () => {
-    const r = new ToolRegistry()
-    r.register({
-      name: 'browser.navigate',
-      description: 'navigate the browser',
-      shouldDefer: true,
-      searchHint: 'browser web automation',
-      schema: z.object({ url: z.string() }),
-      handler: () => ({ ok: true }),
-    })
-    const meta = makeToolSearchTool(r)
-    r.register(meta as ToolDef)
-    const result = await meta.handler({ query: 'browser web' })
-    const data = result.data as { matched: number }
-    expect(data.matched).toBe(1)
-  })
-})

package/src/public/card.test.ts

@@ -1,70 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { cardToTextRecords, emptyCard, parseCard, renderCard } from './card'
-
-describe('card', () => {
-  test('parses frontmatter + body', () => {
-    const md = `---
-name: Alice
-bio: research lyra
-skills:
-  - research
-  - writing
----
-
-Free-form body here.`
-    const c = parseCard(md)
-    expect(c.frontmatter.name).toBe('Alice')
-    expect(c.frontmatter.bio).toBe('research lyra')
-    expect(c.frontmatter.skills).toEqual(['research', 'writing'])
-    expect(c.body.trim()).toBe('Free-form body here.')
-  })
-
-  test('rejects missing name', () => {
-    expect(() => parseCard('---\nbio: no name\n---\nbody')).toThrow()
-  })
-
-  test('round-trips via render', () => {
-    const c = {
-      frontmatter: { name: 'Bob', bio: 'hi', skills: ['code'] },
-      body: 'Body.',
-    }
-    const rendered = renderCard(c)
-    const parsed = parseCard(rendered)
-    expect(parsed.frontmatter.name).toBe('Bob')
-    expect(parsed.frontmatter.skills).toEqual(['code'])
-  })
-
-  test('emptyCard is parseable after setting a name', () => {
-    const c = emptyCard()
-    c.frontmatter.name = 'Temp'
-    const rendered = renderCard(c)
-    const parsed = parseCard(rendered)
-    expect(parsed.frontmatter.name).toBe('Temp')
-  })
-
-  test('cardToTextRecords includes address + agent:inft when present', () => {
-    const c = {
-      frontmatter: {
-        name: 'Alice',
-        bio: 'hi',
-        skills: ['research', 'writing'],
-        inft: 'eip155:5003:0xabc:42',
-        avatar: '0xdeadbeef',
-      },
-      body: '',
-    }
-    const r = cardToTextRecords(c, '0xC635e6Eb223aE14143E23cEEa9440bC773dc87Ec')
-    expect(r.address).toBe('0xC635e6Eb223aE14143E23cEEa9440bC773dc87Ec')
-    expect(r['agent:bio']).toBe('hi')
-    expect(r['agent:skills']).toBe('research,writing')
-    expect(r['agent:inft']).toBe('eip155:5003:0xabc:42')
-    expect(r.avatar).toBe('0xdeadbeef')
-  })
-
-  test('cardToTextRecords omits empty fields', () => {
-    const c = emptyCard()
-    c.frontmatter.name = 'NoExtras'
-    const r = cardToTextRecords(c)
-    expect(Object.keys(r)).toHaveLength(0)
-  })
-})

package/src/runtime/runtime.test.ts

@@ -1,55 +0,0 @@
-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()
-  })
-})