UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

475 lines (442 loc) • 16.9 kB
import { existsSync, readFileSync, unlinkSync } from "node:fs"; import { join } from "node:path"; import { Database } from "bun:sqlite"; import { SQLITE_ID_CHUNK, chunkIds, columnExists, insertRowsConflictIgnore, openDbWritable, selectRows, sqlRowEqual, tableExists, updateRowFromSnapshot, withWritableDb } from "./db"; import type { RuntimeDbPaths, SqlRow } from "./db"; import { writePrivateFile } from "./paths"; const JOB_KIND_MEMORY_STAGE1 = "memory_stage1"; const JOB_KIND_MEMORY_CONSOLIDATE_GLOBAL = "memory_consolidate_global"; const MEMORY_CONSOLIDATION_JOB_KEY = "global"; const DEFAULT_RETRY_REMAINING = 3; export interface SatelliteBackup { threadIds: string[]; /** Full `threads` row images (SELECT *) captured under the state write lock. */ threads?: SqlRow[]; dynamicTools?: SqlRow[]; spawnEdges?: SqlRow[]; logs?: { path: string; rows: SqlRow[] }; memories?: { path: string; stage1: SqlRow[]; stage1Jobs: SqlRow[]; consolidateJob: SqlRow | null; consolidateTouched: boolean; /** Row image after deleteMemoriesInTx; set before memories commit (in-memory only). */ consolidatePostImage?: SqlRow | null; }; goals?: { path: string; goals: SqlRow[]; deferrals: SqlRow[]; }; } type SatelliteBackupRead = | { status: "missing" } | { status: "ok"; backup: SatelliteBackup } | { status: "invalid" }; export const SATELLITE_BACKUP_FILE = "satellite-backup.json"; /** Snapshot state-DB dependents that cleanup deletes with the thread rows. */ export function snapshotStateDependents( db: Database, threadIds: string[], ): Pick<SatelliteBackup, "threads" | "dynamicTools" | "spawnEdges"> { const out: Pick<SatelliteBackup, "threads" | "dynamicTools" | "spawnEdges"> = {}; if (threadIds.length === 0 || !tableExists(db, "threads")) return out; const threads: SqlRow[] = []; for (const chunk of chunkIds(threadIds, SQLITE_ID_CHUNK * 2)) { const placeholders = chunk.map(() => "?").join(","); threads.push(...selectRows(db, `SELECT * FROM threads WHERE id IN (${placeholders})`, chunk)); } out.threads = threads; if (tableExists(db, "thread_dynamic_tools")) { const dynamicTools: SqlRow[] = []; for (const chunk of chunkIds(threadIds, SQLITE_ID_CHUNK * 2)) { const placeholders = chunk.map(() => "?").join(","); dynamicTools.push(...selectRows( db, `SELECT * FROM thread_dynamic_tools WHERE thread_id IN (${placeholders})`, chunk, )); } out.dynamicTools = dynamicTools; } if (tableExists(db, "thread_spawn_edges")) { const spawnEdges: SqlRow[] = []; for (const chunk of chunkIds(threadIds, SQLITE_ID_CHUNK)) { const placeholders = chunk.map(() => "?").join(","); spawnEdges.push(...selectRows( db, `SELECT * FROM thread_spawn_edges WHERE parent_thread_id IN (${placeholders}) OR child_thread_id IN (${placeholders})`, [...chunk, ...chunk], )); } out.spawnEdges = spawnEdges; } return out; } /** Remap serialized absolute DB paths onto the newest DBs under the current Codex home. */ export function remapSatelliteBackupPaths( backup: SatelliteBackup, paths: RuntimeDbPaths, ): { ok: true; backup: SatelliteBackup } | { ok: false } { const next: SatelliteBackup = { threadIds: backup.threadIds, ...(backup.threads ? { threads: backup.threads } : {}), ...(backup.dynamicTools ? { dynamicTools: backup.dynamicTools } : {}), ...(backup.spawnEdges ? { spawnEdges: backup.spawnEdges } : {}), }; if (backup.logs) { if (!paths.logs) return { ok: false }; next.logs = { ...backup.logs, path: paths.logs }; } if (backup.memories) { if (!paths.memories) return { ok: false }; next.memories = { ...backup.memories, path: paths.memories }; } if (backup.goals) { if (!paths.goals) return { ok: false }; next.goals = { ...backup.goals, path: paths.goals }; } return { ok: true, backup: next }; } export function readConsolidateGlobalJob(db: Database): SqlRow | null { if (!tableExists(db, "jobs")) return null; return db.query<SqlRow, [string, string]>( "SELECT * FROM jobs WHERE kind = ? AND job_key = ?", ).get(JOB_KIND_MEMORY_CONSOLIDATE_GLOBAL, MEMORY_CONSOLIDATION_JOB_KEY) as SqlRow | null; } /** Revert delete-time enqueue only when the row still matches cleanup's post-delete image. */ export function restoreConsolidateGlobalJob( db: Database, snapshot: SqlRow | null, postImage: SqlRow | null | undefined, ): void { if (!postImage) return; const current = readConsolidateGlobalJob(db); if (!current) { if (snapshot) insertRowsConflictIgnore(db, "jobs", [snapshot]); return; } if (!sqlRowEqual(current, postImage)) return; if (snapshot) { updateRowFromSnapshot(db, "jobs", snapshot, ["kind", "job_key"]); } else { db.run( "DELETE FROM jobs WHERE kind = ? AND job_key = ?", [JOB_KIND_MEMORY_CONSOLIDATE_GLOBAL, MEMORY_CONSOLIDATION_JOB_KEY], ); } } /** * Atomically replace satellite-backup.json: private temp in the stage, full write + fsync, * rename (with Windows sharing-violation retries), then best-effort directory fsync. * An interrupted update never truncates the last valid backup that was written before a * satellite DB commit. */ export function writeSatelliteBackup( stageDir: string, backup: SatelliteBackup, options?: { failWrite?: boolean; failReplaceBeforeRename?: boolean }, ): void { if (options?.failWrite) throw new Error("test_fail_satellite_backup_write"); const dest = join(stageDir, SATELLITE_BACKUP_FILE); const replacing = existsSync(dest); writePrivateFile(dest, JSON.stringify(backup), () => { if (options?.failReplaceBeforeRename && replacing) { throw new Error("test_fail_satellite_backup_replace"); } }); } export function clearSatelliteBackup(stageDir: string): void { try { unlinkSync(join(stageDir, SATELLITE_BACKUP_FILE)); } catch { /* */ } } interface SatelliteWriteLock { path: string; db: Database; } export interface SatelliteWriteLocks { logs?: SatelliteWriteLock; memories?: SatelliteWriteLock; goals?: SatelliteWriteLock; } /** Deterministic order: logs → memories → goals. Each present DB gets BEGIN IMMEDIATE. */ export function beginSatelliteWriteLocks( paths: RuntimeDbPaths, busyTimeoutMs: number, only?: Partial<Record<"logs" | "memories" | "goals", boolean>>, ): SatelliteWriteLocks { const locks: SatelliteWriteLocks = {}; const order: Array<{ key: "logs" | "memories" | "goals"; path: string | null }> = [ { key: "logs", path: paths.logs }, { key: "memories", path: paths.memories }, { key: "goals", path: paths.goals }, ]; try { for (const { key, path } of order) { if (only && !only[key]) continue; if (!path || !existsSync(path)) continue; const db = openDbWritable(path, busyTimeoutMs); try { db.exec("BEGIN IMMEDIATE"); locks[key] = { path, db }; } catch (error) { try { db.close(); } catch { /* */ } throw error; } } return locks; } catch (error) { rollbackAllSatelliteLocks(locks); throw error; } } function rollbackSatelliteLock(lock: SatelliteWriteLock | undefined): void { if (!lock) return; try { lock.db.exec("ROLLBACK"); } catch { /* */ } try { lock.db.close(); } catch { /* */ } } export function rollbackAllSatelliteLocks(locks: SatelliteWriteLocks): void { rollbackSatelliteLock(locks.logs); rollbackSatelliteLock(locks.memories); rollbackSatelliteLock(locks.goals); locks.logs = undefined; locks.memories = undefined; locks.goals = undefined; } export function commitSatelliteLock(lock: SatelliteWriteLock | undefined): void { if (!lock) return; lock.db.exec("COMMIT"); lock.db.close(); } function snapshotLogsInTx( db: Database, path: string, threadIds: string[], ): SatelliteBackup["logs"] { if (threadIds.length === 0) return undefined; if (!tableExists(db, "logs")) throw new Error("missing_logs_table"); const rows: SqlRow[] = []; for (const chunk of chunkIds(threadIds, SQLITE_ID_CHUNK * 2)) { const placeholders = chunk.map(() => "?").join(","); rows.push(...selectRows(db, `SELECT * FROM logs WHERE thread_id IN (${placeholders})`, chunk)); } return { path, rows }; } function snapshotMemoriesInTx( db: Database, path: string, threadIds: string[], ): SatelliteBackup["memories"] { if (threadIds.length === 0) return undefined; if (!tableExists(db, "stage1_outputs")) throw new Error("missing_stage1_outputs_table"); const stage1: SqlRow[] = []; let stage1Jobs: SqlRow[] = []; for (const chunk of chunkIds(threadIds, SQLITE_ID_CHUNK * 2)) { const placeholders = chunk.map(() => "?").join(","); stage1.push(...selectRows( db, `SELECT * FROM stage1_outputs WHERE thread_id IN (${placeholders})`, chunk, )); if (tableExists(db, "jobs")) { stage1Jobs.push(...selectRows( db, `SELECT * FROM jobs WHERE kind = ? AND job_key IN (${placeholders})`, [JOB_KIND_MEMORY_STAGE1, ...chunk], )); } } let consolidateJob: SqlRow | null = null; let selectedForPhase2 = 0; if (columnExists(db, "stage1_outputs", "selected_for_phase2")) { selectedForPhase2 = stage1.filter(r => Number(r.selected_for_phase2 ?? 0) !== 0).length; } if (tableExists(db, "jobs")) { consolidateJob = readConsolidateGlobalJob(db); } return { path, stage1, stage1Jobs, consolidateJob, consolidateTouched: selectedForPhase2 > 0, }; } function snapshotGoalsInTx( db: Database, path: string, threadIds: string[], ): SatelliteBackup["goals"] { if (threadIds.length === 0) return undefined; if (!tableExists(db, "thread_goals")) throw new Error("missing_thread_goals_table"); const goals: SqlRow[] = []; let deferrals: SqlRow[] = []; for (const chunk of chunkIds(threadIds, SQLITE_ID_CHUNK * 2)) { const placeholders = chunk.map(() => "?").join(","); goals.push(...selectRows( db, `SELECT * FROM thread_goals WHERE thread_id IN (${placeholders})`, chunk, )); if (tableExists(db, "thread_goal_continuation_deferrals")) { deferrals.push(...selectRows( db, `SELECT * FROM thread_goal_continuation_deferrals WHERE thread_id IN (${placeholders})`, chunk, )); } } return { path, goals, deferrals }; } /** Snapshot every present satellite under its write lock (rows stable until commit). */ export function snapshotSatelliteBackupInLocks( locks: SatelliteWriteLocks, threadIds: string[], ): SatelliteBackup { const backup: SatelliteBackup = { threadIds }; if (locks.logs) { backup.logs = snapshotLogsInTx(locks.logs.db, locks.logs.path, threadIds); } if (locks.memories) { backup.memories = snapshotMemoriesInTx(locks.memories.db, locks.memories.path, threadIds); } if (locks.goals) { backup.goals = snapshotGoalsInTx(locks.goals.db, locks.goals.path, threadIds); } return backup; } export function deleteLogsInTx(db: Database, rows: SqlRow[]): void { if (rows.length === 0) return; if (!tableExists(db, "logs")) throw new Error("missing_logs_table"); const ids = rows.map(r => r.id).filter(id => id !== null && id !== undefined); if (ids.length === 0) return; for (const chunk of chunkIds(ids as string[], SQLITE_ID_CHUNK * 2)) { const placeholders = chunk.map(() => "?").join(","); db.run(`DELETE FROM logs WHERE id IN (${placeholders})`, chunk as Array<string | number>); } } export function deleteMemoriesInTx( db: Database, section: NonNullable<SatelliteBackup["memories"]>, ): void { if (!tableExists(db, "stage1_outputs")) throw new Error("missing_stage1_outputs_table"); const stage1Ids = section.stage1.map(r => String(r.thread_id)); for (const chunk of chunkIds(stage1Ids, SQLITE_ID_CHUNK * 2)) { if (chunk.length === 0) continue; const placeholders = chunk.map(() => "?").join(","); db.run(`DELETE FROM stage1_outputs WHERE thread_id IN (${placeholders})`, chunk); } if (tableExists(db, "jobs")) { const jobKeys = section.stage1Jobs.map(r => String(r.job_key)); for (const chunk of chunkIds(jobKeys, SQLITE_ID_CHUNK * 2)) { if (chunk.length === 0) continue; const placeholders = chunk.map(() => "?").join(","); db.run( `DELETE FROM jobs WHERE kind = ? AND job_key IN (${placeholders})`, [JOB_KIND_MEMORY_STAGE1, ...chunk], ); } if (section.consolidateTouched) { const now = Math.floor(Date.now() / 1000); db.run( `INSERT INTO jobs ( kind, job_key, status, worker_id, ownership_token, started_at, finished_at, lease_until, retry_at, retry_remaining, last_error, input_watermark, last_success_watermark ) VALUES (?, ?, 'pending', NULL, NULL, NULL, NULL, NULL, NULL, ?, NULL, ?, 0) ON CONFLICT(kind, job_key) DO UPDATE SET status = CASE WHEN jobs.status = 'running' THEN 'running' ELSE 'pending' END, retry_at = CASE WHEN jobs.status = 'running' THEN jobs.retry_at ELSE NULL END, retry_remaining = max(jobs.retry_remaining, excluded.retry_remaining), input_watermark = CASE WHEN excluded.input_watermark > COALESCE(jobs.input_watermark, 0) THEN excluded.input_watermark ELSE COALESCE(jobs.input_watermark, 0) + 1 END`, [JOB_KIND_MEMORY_CONSOLIDATE_GLOBAL, MEMORY_CONSOLIDATION_JOB_KEY, DEFAULT_RETRY_REMAINING, now], ); } } } export function deleteGoalsInTx( db: Database, section: NonNullable<SatelliteBackup["goals"]>, ): void { if (!tableExists(db, "thread_goals")) throw new Error("missing_thread_goals_table"); const deferralIds = section.deferrals.map(r => String(r.thread_id)); if (tableExists(db, "thread_goal_continuation_deferrals")) { for (const chunk of chunkIds(deferralIds, SQLITE_ID_CHUNK * 2)) { if (chunk.length === 0) continue; const placeholders = chunk.map(() => "?").join(","); db.run( `DELETE FROM thread_goal_continuation_deferrals WHERE thread_id IN (${placeholders})`, chunk, ); } } const goalIds = section.goals.map(r => String(r.thread_id)); for (const chunk of chunkIds(goalIds, SQLITE_ID_CHUNK * 2)) { if (chunk.length === 0) continue; const placeholders = chunk.map(() => "?").join(","); db.run(`DELETE FROM thread_goals WHERE thread_id IN (${placeholders})`, chunk); } } /** Restore only snapshotted rows; concurrent inserts/updates after commit stay intact. */ export function restoreSatelliteBackup( backup: SatelliteBackup, busyTimeoutMs: number, failRestore = false, ): boolean { if (failRestore) return false; try { if (backup.logs) { const restored = withWritableDb(backup.logs.path, busyTimeoutMs, db => { if (!tableExists(db, "logs")) throw new Error("missing_logs_table"); insertRowsConflictIgnore(db, "logs", backup.logs!.rows); }); if (!restored.ok) return false; } if (backup.memories) { const mem = backup.memories; const restored = withWritableDb(mem.path, busyTimeoutMs, db => { if (!tableExists(db, "stage1_outputs")) throw new Error("missing_stage1_outputs_table"); insertRowsConflictIgnore(db, "stage1_outputs", mem.stage1); if (tableExists(db, "jobs")) { insertRowsConflictIgnore(db, "jobs", mem.stage1Jobs); if (mem.consolidateTouched) { restoreConsolidateGlobalJob(db, mem.consolidateJob, mem.consolidatePostImage); } } }); if (!restored.ok) return false; } if (backup.goals) { const g = backup.goals; const restored = withWritableDb(g.path, busyTimeoutMs, db => { if (!tableExists(db, "thread_goals")) throw new Error("missing_thread_goals_table"); insertRowsConflictIgnore(db, "thread_goals", g.goals); if (tableExists(db, "thread_goal_continuation_deferrals")) { insertRowsConflictIgnore(db, "thread_goal_continuation_deferrals", g.deferrals); } }); if (!restored.ok) return false; } return true; } catch { return false; } } export function readSatelliteBackupFile(stageDir: string): SatelliteBackupRead { const path = join(stageDir, SATELLITE_BACKUP_FILE); if (!existsSync(path)) return { status: "missing" }; try { const raw = JSON.parse(readFileSync(path, "utf8")) as unknown; if (!raw || typeof raw !== "object") return { status: "invalid" }; const o = raw as SatelliteBackup; if (!Array.isArray(o.threadIds)) return { status: "invalid" }; return { status: "ok", backup: o }; } catch { // File exists but is truncated / malformed — distinct from a missing backup. return { status: "invalid" }; } }