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.5 KB
Raw Blame
import { afterEach, describe, expect, it } from 'vitest'
import { execFileSync } from 'child_process'
import { appendFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs'
import { join } from 'path'
import { tmpdir } from 'os'
import { DevinReader, readDevinMessages } from './reader.js'

/**
 * Integration test for the turn-close path, driven through a real `sqlite3` DB and a real log file —
 * because the failure mode being guarded is precisely the one where NO new row and NO Stop hook arrive.
 */
const AGENT_ERROR = "2026-07-28T06:38:22.096212Z  WARN chisel_core::translator: ACP: agent error (Internal):"
  + " Permission denied: Permission denied: We're currently facing high demand for this model."
  + " Please try again later. (trace ID: acb60788b786ddfb16a00ddb3d83b053)"

const dirs: string[] = []
afterEach(() => { for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true }) })

function sql(db: string, statement: string): void {
  execFileSync('sqlite3', [db, statement])
}

interface Fixture { db: string; home: string; log: string; sessionId: string }

function fixture(sessionId = 'tested-crabapple'): Fixture {
  const dir = mkdtempSync(join(tmpdir(), 'adapter-devin-reader-'))
  dirs.push(dir)
  const db = join(dir, 'sessions.db')
  sql(db, `CREATE TABLE message_nodes (
    row_id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL, node_id INTEGER NOT NULL,
    parent_node_id INTEGER, chat_message TEXT NOT NULL, created_at INTEGER NOT NULL, metadata TEXT);`)

  const home = join(dir, 'devin')
  mkdirSync(join(home, 'session_locks'), { recursive: true })
  mkdirSync(join(home, 'logs'), { recursive: true })
  writeFileSync(join(home, 'session_locks', `${sessionId}.lock`), '39022')
  const log = join(home, 'logs', 'devin_20260728-133808_39022.log')
  writeFileSync(log, '')
  return { db, home, log, sessionId }
}

let node = 0
function insert(f: Fixture, message: Record<string, unknown>): void {
  const json = JSON.stringify(message).replace(/'/g, "''")
  sql(f.db, `INSERT INTO message_nodes (session_id, node_id, chat_message, created_at)
    VALUES ('${f.sessionId}', ${node++}, '${json}', 0);`)
}

const userRow = (id: string, text: string, at = '2026-07-28T06:38:21.000000Z') =>
  ({ message_id: id, role: 'user', content: text, metadata: { created_at: at } })

const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))

// macOS ships the sqlite3 CLI in the base system; Ubuntu (and most slim images) do not. These cases
// drive a REAL database on purpose, so skip rather than fail where the binary is genuinely absent —
// the same guard opencode/reader.spec.ts and hermes/reader.spec.ts already use.
const hasSqlite = (() => {
  try { execFileSync('sqlite3', ['-version'], { stdio: 'ignore' }); return true } catch { return false }
})()
const d = hasSqlite ? describe : describe.skip

d('DevinReader turn close', () => {
  it('deduplicates the repeated rows Devin writes per inference', async () => {
    const f = fixture()
    const user = userRow('m-user', 'hi')
    insert(f, user)
    insert(f, user) // Devin re-persists the whole chain on the next inference
    insert(f, { message_id: 'm-asst', role: 'assistant', content: 'hello', metadata: { finish_reason: 'stop' } })
    insert(f, { message_id: 'm-sys', role: 'system', content: 'You are Devin' })

    const messages = await readDevinMessages(f.db, f.sessionId)
    expect(messages.map((m) => m.messageId)).toEqual(['m-user', 'm-asst'])
  })

  it('closes a turn that dies mid-flight, with no new row and no Stop hook', async () => {
    const f = fixture()
    const aborted: string[] = []
    const reader = new DevinReader({
      dbPath: f.db, devinHome: f.home, sessionId: f.sessionId, pollMs: 30,
      onEvents: () => {},
      onTurnAborted: (message) => aborted.push(message),
    })
    await reader.start()

    insert(f, userRow('m-1', 'gia btc moi nhat di'))
    await wait(150)
    expect(reader.turnOpen).toBe(true) // the user row opened the turn

    appendFileSync(f.log, AGENT_ERROR + '\n') // provider failure — Devin writes nothing else, ever
    await wait(150)
    reader.stop()

    expect(aborted).toEqual([
      "Permission denied: We're currently facing high demand for this model. Please try again later.",
    ])
    expect(reader.turnOpen).toBe(false)
  })

  it('heals a turn that was already stuck when it attached', async () => {
    const f = fixture()
    insert(f, userRow('m-1', 'gia btc moi nhat di'))
    appendFileSync(f.log, AGENT_ERROR + '\n') // failed before the daemon (re)started

    const aborted: string[] = []
    const reader = new DevinReader({
      dbPath: f.db, devinHome: f.home, sessionId: f.sessionId, pollMs: 30,
      onEvents: () => {},
      onTurnAborted: (message) => aborted.push(message),
    })
    await reader.start()
    reader.stop()

    expect(aborted).toHaveLength(1)
    expect(reader.turnOpen).toBe(false)
  })

  it('leaves a healthy in-flight turn alone when the log only holds an older failure', async () => {
    const f = fixture()
    appendFileSync(f.log, AGENT_ERROR + '\n') // 06:38:22 — BEFORE this turn's prompt
    insert(f, userRow('m-1', 'a fresh prompt', '2026-07-28T07:00:00.000000Z'))

    const aborted: string[] = []
    const reader = new DevinReader({
      dbPath: f.db, devinHome: f.home, sessionId: f.sessionId, pollMs: 30,
      onEvents: () => {},
      onTurnAborted: (message) => aborted.push(message),
    })
    await reader.start()
    await wait(120)
    reader.stop()

    expect(aborted).toEqual([])
    expect(reader.turnOpen).toBe(true) // still running — must not be force-closed
  })
})