@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
348 lines (320 loc) • 14 kB
text/typescript
import { existsSync } from "node:fs";
import { join } from "node:path";
import { Database } from "bun:sqlite";
import { SQLITE_ID_CHUNK, chunkIds, columnExists, mapDbError, openDbWritable, tableExists } from "./db";
import type { ReconcileErr, RuntimeDbPaths } from "./db";
import { normalizeArchivedRolloutPath } from "./paths";
import { beginSatelliteWriteLocks, clearSatelliteBackup, commitSatelliteLock, deleteGoalsInTx, deleteLogsInTx, deleteMemoriesInTx, readConsolidateGlobalJob, restoreSatelliteBackup, rollbackAllSatelliteLocks, snapshotSatelliteBackupInLocks, snapshotStateDependents, writeSatelliteBackup } from "./satellite";
import type { SatelliteBackup, SatelliteWriteLocks } from "./satellite";
import type { ArchivedCandidate, CleanupErrorCode } from "./types";
export interface ThreadSnapshot {
id: string;
rollout_path: string;
archived: number | null;
history_mode?: string | null;
is_pinned?: number | null;
}
/**
* Load archived threads matching the candidate set.
* Optional columns are detected via PRAGMA; missing `threads` / query failures throw
* so callers map to `db_reconcile_failed` / `codex_busy` instead of treating them as empty.
*/
function loadMatchingThreads(db: Database, candidates: ArchivedCandidate[], codexHome: string): ThreadSnapshot[] {
if (!tableExists(db, "threads")) {
throw new Error("missing_threads_table");
}
const logicalSet = new Set(candidates.map(c => c.relPath));
const hasArchived = columnExists(db, "threads", "archived");
const hasHistoryMode = columnExists(db, "threads", "history_mode");
const hasIsPinned = columnExists(db, "threads", "is_pinned");
const selectCols = ["id", "rollout_path"];
if (hasArchived) selectCols.push("archived");
if (hasHistoryMode) selectCols.push("history_mode");
if (hasIsPinned) selectCols.push("is_pinned");
const rows = db.query<
{ id: string; rollout_path: string; archived?: number | null; history_mode?: string | null; is_pinned?: number | null },
[]
>(`SELECT ${selectCols.join(", ")} FROM threads`).all();
return rows
.filter(row => {
// When the archived column is present, only archived=1 rows may be deleted.
if (hasArchived && Number(row.archived ?? 0) !== 1) {
return false;
}
const normalized = normalizeArchivedRolloutPath(row.rollout_path, codexHome);
return normalized !== null && logicalSet.has(normalized);
})
.map(row => ({
id: row.id,
rollout_path: row.rollout_path,
archived: hasArchived ? (row.archived ?? null) : null,
history_mode: hasHistoryMode ? (row.history_mode ?? null) : null,
is_pinned: hasIsPinned ? (row.is_pinned ?? null) : null,
}));
}
/**
* Partition matched threads into deletable and referenced snapshots. Linked spawn/fork
* history and paginated histories stay in the skipped set. Throws real DB errors.
*/
function filterReferencedHistory(
db: Database,
threads: ThreadSnapshot[],
): { safe: ThreadSnapshot[]; skipped: ThreadSnapshot[] } {
let safe = threads.filter(t => (t.history_mode ?? "").toLowerCase() !== "paginated");
const skipped = new Map(threads
.filter(t => (t.history_mode ?? "").toLowerCase() === "paginated")
.map(t => [t.id, t]));
while (safe.length > 0) {
const idSet = new Set(safe.map(t => t.id));
const unsafeIds = new Set<string>();
// Spawn edges that cross the delete boundary keep history reachable.
if (tableExists(db, "thread_spawn_edges")) {
for (const chunk of chunkIds([...idSet], SQLITE_ID_CHUNK)) {
const placeholders = chunk.map(() => "?").join(",");
const edges = db.query<{ parent_thread_id: string; child_thread_id: string }, string[]>(
`SELECT parent_thread_id, child_thread_id FROM thread_spawn_edges
WHERE parent_thread_id IN (${placeholders}) OR child_thread_id IN (${placeholders})`,
).all(...chunk, ...chunk);
for (const edge of edges) {
if (!idSet.has(edge.parent_thread_id)) unsafeIds.add(edge.child_thread_id);
if (!idSet.has(edge.child_thread_id)) unsafeIds.add(edge.parent_thread_id);
}
}
}
// Other threads that list one of ours as forked_from / parent (when columns exist).
for (const column of ["forked_from_id", "parent_thread_id", "source_thread_id"] as const) {
if (!columnExists(db, "threads", column)) continue;
for (const chunk of chunkIds([...idSet], SQLITE_ID_CHUNK * 2)) {
const placeholders = chunk.map(() => "?").join(",");
const rows = db.query<{ id: string; ref: string }, string[]>(
`SELECT id, ${column} AS ref FROM threads WHERE ${column} IN (${placeholders})`,
).all(...chunk);
for (const row of rows) {
if (!idSet.has(row.id)) unsafeIds.add(row.ref);
}
}
}
if (unsafeIds.size === 0) break;
for (const thread of safe) {
if (unsafeIds.has(thread.id)) skipped.set(thread.id, thread);
}
safe = safe.filter(thread => !unsafeIds.has(thread.id));
}
return { safe, skipped: [...skipped.values()] };
}
function deleteThreadsAndDependents(db: Database, threadIds: string[]): void {
if (threadIds.length === 0) return;
// Upstream deletes dynamic tools before spawn edges before threads.
if (tableExists(db, "thread_dynamic_tools")) {
for (const chunk of chunkIds(threadIds, SQLITE_ID_CHUNK * 2)) {
const placeholders = chunk.map(() => "?").join(",");
db.run(`DELETE FROM thread_dynamic_tools WHERE thread_id IN (${placeholders})`, chunk);
}
}
if (tableExists(db, "thread_spawn_edges")) {
for (const chunk of chunkIds(threadIds, SQLITE_ID_CHUNK)) {
const placeholders = chunk.map(() => "?").join(",");
db.run(
`DELETE FROM thread_spawn_edges WHERE parent_thread_id IN (${placeholders}) OR child_thread_id IN (${placeholders})`,
[...chunk, ...chunk],
);
}
}
for (const chunk of chunkIds(threadIds, SQLITE_ID_CHUNK * 2)) {
const placeholders = chunk.map(() => "?").join(",");
db.run(`DELETE FROM threads WHERE id IN (${placeholders})`, chunk);
}
}
interface ReconcileOk {
ok: true;
threads: ThreadSnapshot[];
skipped: ThreadSnapshot[];
}
interface ReconcileTestHooks {
/** Runs at the top of reconcileDeletedThreads, before the write lock is taken. */
beforeReconcileLock?: () => void;
failAfterLogsMutation?: boolean;
failAfterMemoriesMutation?: boolean;
failAfterGoalsMutation?: boolean;
failBeforeStateCommit?: boolean;
failSatelliteRestore?: boolean;
failSatelliteBackupWrite?: boolean;
/**
* Fail a satellite-backup.json *replacement* after the temp is durable but before
* rename — exercises crash-safety of the post-memories rewrite without truncating
* the last valid backup.
*/
failSatelliteBackupReplace?: boolean;
/** Runs after satellite deletes are committed, before state thread deletion. */
afterSatelliteMutations?: () => void;
}
/** Delete snapshotted primary-key rows and commit each satellite write transaction. */
function deleteAndCommitSatellites(
locks: SatelliteWriteLocks,
backup: SatelliteBackup,
stageDir: string,
hooks?: ReconcileTestHooks,
): void {
try {
if (locks.logs && backup.logs) {
deleteLogsInTx(locks.logs.db, backup.logs.rows);
commitSatelliteLock(locks.logs);
locks.logs = undefined;
if (hooks?.failAfterLogsMutation) throw new Error("test_fail_after_logs");
}
if (locks.memories && backup.memories) {
deleteMemoriesInTx(locks.memories.db, backup.memories);
if (backup.memories.consolidateTouched) {
// Capture under the write lock, but persist only after COMMIT+close.
// Holding BEGIN IMMEDIATE across a durable backup rewrite lets Windows CI
// disk/AV latency stall the lock long enough for concurrent reopen hooks
// (and bun's default 5s test timeout) to hang — see PR #558 windows-latest.
backup.memories.consolidatePostImage = readConsolidateGlobalJob(locks.memories.db);
}
commitSatelliteLock(locks.memories);
locks.memories = undefined;
if (backup.memories.consolidateTouched) {
writeSatelliteBackup(stageDir, backup, {
failReplaceBeforeRename: hooks?.failSatelliteBackupReplace,
});
}
if (hooks?.failAfterMemoriesMutation) throw new Error("test_fail_after_memories");
}
if (locks.goals && backup.goals) {
deleteGoalsInTx(locks.goals.db, backup.goals);
commitSatelliteLock(locks.goals);
locks.goals = undefined;
if (hooks?.failAfterGoalsMutation) throw new Error("test_fail_after_goals");
}
} catch (error) {
rollbackAllSatelliteLocks(locks);
throw error;
}
}
/** Load matching archived threads and retain referenced history — no deletes yet. */
export function loadThreadsForCleanup(
stateDbPath: string,
candidates: ArchivedCandidate[],
codexHome: string,
busyTimeoutMs: number,
): ReconcileOk | ReconcileErr {
if (!stateDbPath || !existsSync(stateDbPath)) return { ok: true, threads: [], skipped: [] };
let db: Database | undefined;
try {
db = openDbWritable(stateDbPath, busyTimeoutMs);
const threads = loadMatchingThreads(db, candidates, codexHome);
if (threads.some(t => Number(t.is_pinned ?? 0) === 1)) {
return { ok: false, error: "pinned_thread" };
}
const filtered = filterReferencedHistory(db, threads);
return { ok: true, threads: filtered.safe, skipped: filtered.skipped };
} catch (error) {
return { ok: false, error: mapDbError(error) };
} finally {
try { db?.close(); } catch { /* */ }
}
}
/**
* Reconcile all Codex per-thread stores for the matched archived candidates.
*
* Freezes the thread-ID set under the state write lock, persists a complete
* satellite backup, then mutates satellites (logs → memories → goals). Any later
* failure restores satellite rows before the caller restores staged files.
*/
export function reconcileDeletedThreads(
paths: RuntimeDbPaths,
candidates: ArchivedCandidate[],
codexHome: string,
busyTimeoutMs: number,
stageDir: string,
hooks?: ReconcileTestHooks,
): ReconcileOk | ReconcileErr {
if (!paths.state || !existsSync(paths.state)) return { ok: true, threads: [], skipped: [] };
if (hooks?.beforeReconcileLock) hooks.beforeReconcileLock();
let stateDb: Database | undefined;
let backup: SatelliteBackup | undefined;
let satellitesMutated = false;
let satelliteLocks: SatelliteWriteLocks | undefined;
const failWithRestore = (error: CleanupErrorCode, mapped?: CleanupErrorCode): ReconcileErr => {
const code = mapped ?? error;
let satelliteRestoreFailed = false;
if (satellitesMutated && backup) {
satelliteRestoreFailed = !restoreSatelliteBackup(
backup,
busyTimeoutMs,
Boolean(hooks?.failSatelliteRestore),
);
// Keep on-disk backup + manifest when restore cannot complete.
if (!satelliteRestoreFailed) clearSatelliteBackup(stageDir);
} else {
clearSatelliteBackup(stageDir);
}
return {
ok: false,
error: code,
...(satelliteRestoreFailed ? { satelliteRestoreFailed: true } : {}),
};
};
try {
stateDb = openDbWritable(paths.state, busyTimeoutMs);
stateDb.exec("BEGIN IMMEDIATE");
// Freeze the exact delete set under the write lock before any satellite mutation.
const threads = loadMatchingThreads(stateDb, candidates, codexHome);
// A pin applied after selection must stop the delete, even though the
// staged files are already in trash staging — the caller restores them.
if (threads.some(t => Number(t.is_pinned ?? 0) === 1)) {
stateDb.exec("ROLLBACK");
return { ok: false, error: "pinned_thread" };
}
if (filterReferencedHistory(stateDb, threads).safe.length !== threads.length) {
stateDb.exec("ROLLBACK");
return { ok: false, error: "referenced_history" };
}
const threadIds = threads.map(t => t.id);
satelliteLocks = beginSatelliteWriteLocks(paths, busyTimeoutMs);
try {
backup = snapshotSatelliteBackupInLocks(satelliteLocks, threadIds);
const stateDeps = snapshotStateDependents(stateDb, threadIds);
backup.threads = stateDeps.threads;
backup.dynamicTools = stateDeps.dynamicTools;
backup.spawnEdges = stateDeps.spawnEdges;
try {
writeSatelliteBackup(stageDir, backup, {
failWrite: hooks?.failSatelliteBackupWrite,
});
} catch {
rollbackAllSatelliteLocks(satelliteLocks);
stateDb.exec("ROLLBACK");
clearSatelliteBackup(stageDir);
return { ok: false, error: "fs_failed" };
}
const hasSatelliteWork = Boolean(backup.logs || backup.memories || backup.goals);
if (hasSatelliteWork) {
satellitesMutated = true;
deleteAndCommitSatellites(satelliteLocks, backup, stageDir, hooks);
} else {
rollbackAllSatelliteLocks(satelliteLocks);
}
satelliteLocks = undefined;
if (hooks?.afterSatelliteMutations) hooks.afterSatelliteMutations();
// Re-check under the same lock before committing state deletes.
if (filterReferencedHistory(stateDb, threads).safe.length !== threads.length) {
stateDb.exec("ROLLBACK");
return failWithRestore("referenced_history");
}
deleteThreadsAndDependents(stateDb, threadIds);
if (hooks?.failBeforeStateCommit) throw new Error("test_fail_before_state_commit");
stateDb.exec("COMMIT");
// Keep satellite-backup.json for quarantine restore; permanent purge removes the stage.
return { ok: true, threads, skipped: [] };
} catch (error) {
if (satelliteLocks) rollbackAllSatelliteLocks(satelliteLocks);
throw error;
}
} catch (error) {
try { stateDb?.exec("ROLLBACK"); } catch { /* */ }
return failWithRestore("db_reconcile_failed", mapDbError(error));
} finally {
try { stateDb?.close(); } catch { /* */ }
}
}