Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

5.1 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it } from 'vitest'
import { execFileSync } from 'child_process'
import { mkdtempSync, rmSync } from 'fs'
import { tmpdir } from 'os'
import { join } from 'path'
import { HermesReader, readHermesMessages } from './reader.js'
import type { LiveEvent } from '../../lib/normalize.js'

const hasSqlite = (() => {
  try { execFileSync('sqlite3', ['-version'], { stdio: 'ignore' }); return true } catch { return false }
})()
const d = hasSqlite ? describe : describe.skip

const SID = '20260727_162325_e25264' // the real Hermes id shape: YYYYMMDD_HHMMSS_<hex>
const CALL = 'call_ba1647ad979d0290'

function run(db: string, sql: string): void {
  execFileSync('sqlite3', [db, sql], { stdio: ['ignore', 'ignore', 'inherit'] })
}
function q(v: string | null): string {
  return v === null ? 'NULL' : `'${v.replace(/'/g, "''")}'`
}
function insert(
  db: string,
  row: { id: number; role: string; content?: string; toolCallId?: string; toolCalls?: string; toolName?: string; finishReason?: string; reasoning?: string },
): void {
  run(db,
    `INSERT INTO messages (id, session_id, role, content, tool_call_id, tool_calls, tool_name, finish_reason, reasoning, timestamp) VALUES (` +
    `${row.id}, '${SID}', '${row.role}', ${q(row.content ?? '')}, ${q(row.toolCallId ?? null)}, ${q(row.toolCalls ?? null)}, ` +
    `${q(row.toolName ?? null)}, ${q(row.finishReason ?? null)}, ${q(row.reasoning ?? null)}, ${row.id});`)
}
const wait = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms))

d('HermesReader (sqlite3 CLI)', () => {
  let dir = ''
  let db = ''
  beforeEach(() => {
    dir = mkdtempSync(join(tmpdir(), 'hermes-reader-'))
    db = join(dir, 'state.db')
    run(db,
      'CREATE TABLE messages (id INTEGER PRIMARY KEY, session_id TEXT, role TEXT, content TEXT, tool_call_id TEXT,' +
      ' tool_calls TEXT, tool_name TEXT, finish_reason TEXT, reasoning TEXT, timestamp REAL);')
  })
  afterEach(() => { rmSync(dir, { recursive: true, force: true }) })

  it('reads rows in id order with the columns the normalizer needs', async () => {
    insert(db, { id: 1, role: 'user', content: 'hi' })
    insert(db, { id: 2, role: 'assistant', content: 'hello', finishReason: 'stop' })
    const rows = await readHermesMessages(db, SID)
    expect(rows.map((r) => r.role)).toEqual(['user', 'assistant'])
    expect(rows[1]).toMatchObject({ id: 2, content: 'hello', finishReason: 'stop' })
  })

  it('rejects a session id that is not the Hermes shape (no injection surface)', async () => {
    expect(await readHermesMessages(db, "x'; DROP TABLE messages;--")).toEqual([])
  })

  it("reads an editor's (ACP) session, whose id is a uuid", async () => {
    const acp = '3f2a9c1e-8b4d-4e6f-9a1b-2c3d4e5f6a7b'
    run(db, `INSERT INTO messages (id, session_id, role, content, timestamp) VALUES (1, '${acp}', 'user', 'hi', 1)`)
    run(db, `INSERT INTO messages (id, session_id, role, content, finish_reason, timestamp) VALUES (2, '${acp}', 'assistant', 'hello', 'stop', 2)`)
    expect((await readHermesMessages(db, acp)).map((r) => r.role)).toEqual(['user', 'assistant'])
    // Uuid-shaped with a tail is not an id: refused, rows or not.
    run(db, `INSERT INTO messages (id, session_id, role, content, timestamp) VALUES (3, '${acp}-0', 'user', 'x', 3)`)
    expect(await readHermesMessages(db, `${acp}-0`)).toEqual([])
  })

  it('hydrates silently, then streams a new turn incrementally', async () => {
    insert(db, { id: 1, role: 'user', content: 'old' })
    insert(db, { id: 2, role: 'assistant', content: 'done', finishReason: 'stop' })

    const events: LiveEvent[] = []
    const reader = new HermesReader({ dbPath: db, sessionId: SID, onEvents: (e) => events.push(...e), pollMs: 30 })
    await reader.start()
    expect(events).toHaveLength(0)      // hydrate = no replay
    expect(reader.turnOpen).toBe(false) // last row was a terminal assistant

    insert(db, { id: 3, role: 'user', content: 'who won?' })
    insert(db, { id: 4, role: 'assistant', finishReason: 'tool_calls', toolCalls: `[{"id":"${CALL}","type":"function","function":{"name":"terminal","arguments":"{\\"command\\":\\"ls\\"}"}}]` })
    await wait(120)
    expect(reader.turnOpen).toBe(true)  // still calling a tool

    insert(db, { id: 5, role: 'tool', toolName: 'terminal', toolCallId: CALL, content: '{"output": "a.txt", "exit_code": 0, "error": null}' })
    insert(db, { id: 6, role: 'assistant', content: 'Spain', finishReason: 'stop' })
    await wait(150)
    reader.stop()

    const types = events.map((e) => e.type)
    expect(types).toEqual(['turn_started', 'tool_start', 'tool_end', 'text_delta', 'turn_ended'])
    expect(events[0]).toMatchObject({ payload: { userMessage: 'who won?' } })
    expect(events[2]).toMatchObject({ payload: { tool: 'Bash', output: 'a.txt', isError: false } })
    expect(reader.turnOpen).toBe(false)
  })

  it('reports a mid-turn attach as an open turn', async () => {
    insert(db, { id: 1, role: 'user', content: 'working on it' })
    const reader = new HermesReader({ dbPath: db, sessionId: SID, onEvents: () => {}, pollMs: 1_000 })
    await reader.start()
    expect(reader.turnOpen).toBe(true)
    reader.stop()
  })
})