Files
Agent-Workbench/src/core/storage/state-database.mjs
T

139 lines
9.0 KiB
JavaScript

import fs from 'node:fs';
import path from 'node:path';
import { DatabaseSync } from 'node:sqlite';
import { randomUUID, createHash } from 'node:crypto';
const DATABASE_SCHEMA = 2;
export class StateDatabase {
constructor(directory, { faultInjector } = {}) {
this.filename = path.join(directory, 'workbench.sqlite');
this.faultInjector = faultInjector;
this.database = new DatabaseSync(this.filename);
try {
const version = this.database.prepare('PRAGMA user_version').get().user_version;
if (version > DATABASE_SCHEMA) throw new Error('任务数据库由更新版本创建,请使用对应版本打开。');
this.database.exec('PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000;');
this.database.exec(`
CREATE TABLE IF NOT EXISTS metadata (key TEXT PRIMARY KEY, value TEXT NOT NULL CHECK(json_valid(value)));
CREATE TABLE IF NOT EXISTS projects (id TEXT PRIMARY KEY, position INTEGER NOT NULL, payload TEXT NOT NULL CHECK(json_valid(payload)));
CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, project_id TEXT NOT NULL REFERENCES projects(id), revision INTEGER NOT NULL, payload TEXT NOT NULL CHECK(json_valid(payload)));
CREATE TABLE IF NOT EXISTS records (
kind TEXT NOT NULL, id TEXT NOT NULL, session_id TEXT NOT NULL REFERENCES sessions(id), project_id TEXT NOT NULL REFERENCES projects(id),
task_id TEXT, run_id TEXT, status TEXT, payload TEXT NOT NULL CHECK(json_valid(payload)), PRIMARY KEY(kind,id));
CREATE INDEX IF NOT EXISTS records_owner ON records(kind,session_id,task_id,run_id);
CREATE TABLE IF NOT EXISTS events (
seq INTEGER PRIMARY KEY AUTOINCREMENT, id TEXT NOT NULL UNIQUE, session_id TEXT NOT NULL REFERENCES sessions(id), project_id TEXT NOT NULL,
task_id TEXT, run_id TEXT, type TEXT NOT NULL, revision INTEGER NOT NULL, created_at TEXT NOT NULL, payload TEXT NOT NULL CHECK(json_valid(payload)));
CREATE INDEX IF NOT EXISTS events_session ON events(session_id,seq);
CREATE TABLE IF NOT EXISTS outbox (seq INTEGER PRIMARY KEY REFERENCES events(seq), published_at TEXT);
PRAGMA user_version=${Math.max(version, 1)};
`);
} catch (error) { this.database.close(); throw error; }
}
transaction(action) {
this.database.exec('BEGIN IMMEDIATE');
try { const result = action(); this.faultInjector?.('before_commit'); this.database.exec('COMMIT'); return result; }
catch (error) { try { this.database.exec('ROLLBACK'); } catch {} throw error; }
}
meta(key, fallback = null) {
// Legacy in-process readers receive the full ledger projection. The
// original metadata row remains unchanged for archived source verification.
if (key === 'modelAttempts' && this.database.prepare("SELECT value FROM metadata WHERE key='modelAttemptLedger'").get()) {
return this.database.prepare('SELECT payload,payload_sha256 FROM model_attempts ORDER BY seq').all().map(row => {
if (createHash('sha256').update(row.payload).digest('hex') !== row.payload_sha256) throw new Error('本机请求账本原记录 SHA256 不匹配,请核对保存来源。');
return JSON.parse(row.payload);
});
}
const row = this.database.prepare('SELECT value FROM metadata WHERE key=?').get(key);
return row ? JSON.parse(row.value) : structuredClone(fallback);
}
setMeta(key, value) {
this.database.prepare('INSERT INTO metadata(key,value) VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value').run(key, JSON.stringify(value));
}
get initialized() { return this.meta('initialized', false); }
get cursor() { return this.database.prepare('SELECT COALESCE(MAX(seq),0) AS seq FROM events').get().seq; }
writeProjects(projects) {
const statement = this.database.prepare('INSERT INTO projects(id,position,payload) VALUES(?,?,?) ON CONFLICT(id) DO UPDATE SET position=excluded.position,payload=excluded.payload');
projects.forEach((project, index) => statement.run(project.id, index, JSON.stringify(project)));
}
writeSession(session) {
const existing = this.database.prepare('SELECT project_id FROM sessions WHERE id=?').get(session.id);
if (existing && existing.project_id !== session.projectId) throw new Error('会话不能移动到其他项目。');
this.database.prepare('INSERT INTO sessions(id,project_id,revision,payload) VALUES(?,?,?,?) ON CONFLICT(id) DO UPDATE SET revision=excluded.revision,payload=excluded.payload').run(
session.id, session.projectId, session.revision ?? 0, JSON.stringify(session));
}
writeRecords(records) {
const statement = this.database.prepare(`INSERT INTO records(kind,id,session_id,project_id,task_id,run_id,status,payload) VALUES(?,?,?,?,?,?,?,?)
ON CONFLICT(kind,id) DO UPDATE SET status=excluded.status,payload=excluded.payload`);
for (const record of records) {
const existing = this.database.prepare('SELECT session_id,project_id,task_id,run_id FROM records WHERE kind=? AND id=?').get(record.kind, record.id);
if (existing && (existing.session_id !== record.sessionId || existing.project_id !== record.projectId || existing.task_id !== record.taskId || existing.run_id !== record.runId)) {
throw new Error('持久执行记录不能移动到其他任务或项目。');
}
statement.run(record.kind, record.id, record.sessionId, record.projectId, record.taskId, record.runId, record.status, JSON.stringify(record.value));
}
}
appendEvent(session, type, payload) {
const entry = { id: randomUUID(), sessionId: session.id, projectId: session.projectId,
taskId: session.taskId ?? null, runId: session.runId ?? null, revision: session.revision ?? 0,
type, createdAt: new Date().toISOString(), payload };
const result = this.database.prepare('INSERT INTO events(id,session_id,project_id,task_id,run_id,type,revision,created_at,payload) VALUES(?,?,?,?,?,?,?,?,?)').run(
entry.id, entry.sessionId, entry.projectId, entry.taskId, entry.runId, type, entry.revision, entry.createdAt, JSON.stringify(payload));
entry.seq = Number(result.lastInsertRowid);
this.database.prepare('INSERT INTO outbox(seq) VALUES(?)').run(entry.seq);
return entry;
}
initialize({ projects, config, sessions, records, migration }) {
return this.transaction(() => {
this.writeProjects(projects); this.setMeta('config', config);
for (const session of sessions) {
this.writeSession(session);
session.eventSeq = this.appendEvent(session, 'session.imported', { status: session.status, source: migration ? 'json-v1' : 'new' }).seq;
this.writeSession(session);
}
this.writeRecords(records); this.faultInjector?.('migration_records');
this.setMeta('migration', migration); this.setMeta('initialized', true);
});
}
save(session, records, type, payload) {
return this.transaction(() => {
this.writeSession(session); this.writeRecords(records); this.faultInjector?.('after_state');
const event = this.appendEvent(session, type, payload);
session.eventSeq = event.seq; this.writeSession(session); this.faultInjector?.('after_event');
return event;
});
}
load() {
return {
projects: this.database.prepare('SELECT payload FROM projects ORDER BY position').all().map(row => JSON.parse(row.payload)),
config: this.meta('config', {}),
sessions: this.database.prepare('SELECT payload FROM sessions').all().map(row => JSON.parse(row.payload)),
records: this.database.prepare('SELECT kind,payload FROM records').all().map(row => ({ kind: row.kind, value: JSON.parse(row.payload) })),
};
}
eventsAfter(cursor = 0, { sessionId = null, limit = 100 } = {}) {
if (!Number.isSafeInteger(cursor) || cursor < 0 || !Number.isInteger(limit) || limit < 1 || limit > 500) throw new Error('事件游标或分页范围无效。');
const rows = sessionId
? this.database.prepare('SELECT * FROM events WHERE seq>? AND session_id=? ORDER BY seq LIMIT ?').all(cursor, sessionId, limit + 1)
: this.database.prepare('SELECT * FROM events WHERE seq>? ORDER BY seq LIMIT ?').all(cursor, limit + 1);
const events = rows.slice(0, limit).map(row => ({ seq: row.seq, id: row.id, sessionId: row.session_id, projectId: row.project_id,
taskId: row.task_id, runId: row.run_id, revision: row.revision, type: row.type, createdAt: row.created_at, payload: JSON.parse(row.payload) }));
return { events, nextCursor: events.at(-1)?.seq ?? cursor, hasMore: rows.length > limit, currentCursor: this.cursor };
}
published(seq) { this.database.prepare('UPDATE outbox SET published_at=? WHERE seq=?').run(new Date().toISOString(), seq); }
pendingPublications() { return this.database.prepare('SELECT COUNT(*) AS count FROM outbox WHERE published_at IS NULL').get().count; }
close() { if (this.database) { this.database.close(); this.database = null; } }
}
export function runtimeOwnerAlive(owner) {
if (!owner?.pid || owner.pid === process.pid) return false;
try { process.kill(owner.pid, 0); return true; } catch (error) { return error.code === 'EPERM'; }
}