Tianyi Cui
81d434896d
Adds the snapshot-test harness and the keyless replay pipeline end-to-end. - snapshot-harness.ts: boots the real acp-agent subprocess via the cordis Loader (preserving TSX_TSCONFIG_PATH so unbuilt dsh-* imports resolve from a temp cwd), tees raw stdout into an SDK ClientSideConnection, interprets a per-scenario input.json DSL (initialize / newSession capturing the random sessionId / prompt / cancel), closes stdin to trigger graceful shutdown, and harvests the persisted session.jsonl. Failure-safe: a finally block SIGKILLs a live child, awaits its exit, and removes both temp dirs even on a thrown step or harvest. Raw bytes are buffered and decoded once (no multibyte split). - snapshot-normalize.ts (+ spec): two pure normalizers (stdout frames + session JSONL) scrub cwd, session ids / UUIDs, and JSON-RPC ids, and zero time / createdAt — but keep `seq` (deterministic by contract). normalizeStdout throws on a non-JSON line (the stdout-purity check). - start.ts: selects cordis.snapshot.yml (replay, providerless) or cordis.snapshot-record.yml (record, real adapter) from DSH_SNAPSHOT, skips .env in replay, and disposes the ctx on stdin end so persistence flushes before exit (harvest-after-flush, not on the prompt response). - acp.snapshot.ts: asserts the normalized stdout golden (and, for model scenarios, the re-persisted JSONL golden) via toMatchFileSnapshot; record mode writes the harvested log back to the scenario fixture; an orphan-fixture guard fails on an unregistered scenario dir. - handshake scenario: initialize + session/new (no model call; a header-only session.jsonl, since session/new persists no events). - vitest.snapshot.config.ts, test:snapshot / test:snapshot:record scripts, a pre-push snapshot job, and the knip entry. Incorporates Codex review: record-fixture writeback, failure-safe teardown, seq-not-scrubbed, harvest-after-flush. Per docs/rfc/implemented/2026-06-19.
59 lines
2.6 KiB
TypeScript
59 lines
2.6 KiB
TypeScript
import { pathToFileURL } from 'node:url'
|
|
import { Context } from 'cordis'
|
|
import Loader from '@cordisjs/plugin-loader'
|
|
|
|
// Snapshot-test modes (set by the snapshot harness via env):
|
|
// DSH_SNAPSHOT=replay — load cordis.snapshot.yml (providerless; llm-replay
|
|
// serves a recorded session log). Skip .env so a stray
|
|
// key can never trigger a live model call.
|
|
// DSH_SNAPSHOT=record — load cordis.snapshot-record.yml (the real adapter +
|
|
// persistence) so a real run can be harvested.
|
|
// Absent — the normal demo (cordis.yml), driven by a real editor.
|
|
const snapshotMode = process.env.DSH_SNAPSHOT
|
|
const configPath = snapshotMode === 'replay' ? './cordis.snapshot.yml'
|
|
: snapshotMode === 'record' ? './cordis.snapshot-record.yml'
|
|
: './cordis.yml'
|
|
|
|
// Load DEEPSEEK_API_KEY / DEEPSEEK_BASE_URL from a gitignored repo-root .env
|
|
// (Node native). Absent file is fine — the environment may already carry them.
|
|
// In REPLAY mode we deliberately skip this: replay must never reach the network,
|
|
// so we don't want a present .env to enable a live call.
|
|
//
|
|
// IMPORTANT: this server speaks ACP JSON-RPC on stdout. Do NOT add any
|
|
// stdout logging here or in cordis.yml — it would corrupt the protocol frames.
|
|
// A present-but-unreadable/malformed .env is a real misconfiguration: surface
|
|
// it on STDERR (never stdout) rather than silently running with the wrong env.
|
|
if (snapshotMode !== 'replay') {
|
|
try {
|
|
process.loadEnvFile(new URL('../../.env', import.meta.url).pathname)
|
|
} catch (error) {
|
|
if ((error as NodeJS.ErrnoException | null)?.code !== 'ENOENT') {
|
|
process.stderr.write(`acp-agent: failed to load .env: ${String(error)}\n`)
|
|
}
|
|
// ENOENT (no .env) is fine — rely on the ambient environment.
|
|
}
|
|
}
|
|
|
|
const ctx = new Context()
|
|
ctx.baseUrl = pathToFileURL(import.meta.dirname).href + '/'
|
|
|
|
await ctx.plugin(Loader)
|
|
await ctx.loader.create({
|
|
name: '@cordisjs/plugin-include',
|
|
config: {
|
|
path: configPath,
|
|
},
|
|
})
|
|
|
|
// Graceful shutdown for snapshot RECORD runs: when the client closes our stdin
|
|
// (it is done driving the session), dispose the whole context. Disposal awaits
|
|
// the agent-loop teardown and the persistence backend's final `session/flush`,
|
|
// so the recorded `.jsonl` is fully written before the process exits and the
|
|
// harness harvests it. (In a normal editor session stdin stays open for the
|
|
// connection's lifetime; the editor kills the process, so this never fires.)
|
|
if (snapshotMode !== undefined) {
|
|
process.stdin.on('end', () => {
|
|
void ctx.fiber.dispose().then(() => { process.exit(0) })
|
|
})
|
|
}
|