UNPKG

@bitkyc08/opencodex

Version:

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

259 lines (230 loc) • 8.29 kB
import { existsSync, readdirSync } from "node:fs"; import { join } from "node:path"; import { Database } from "bun:sqlite"; import type { CleanupErrorCode } from "./types"; const STATE_DB_FILE = /^state_(\d+)\.sqlite$/; const LOGS_DB_FILE = /^logs_(\d+)\.sqlite$/; const GOALS_DB_FILE = /^goals_(\d+)\.sqlite$/; const MEMORIES_DB_FILE = /^memories_(\d+)\.sqlite$/; /** Chunk size for `IN (...)` binds; spawn-edge checks bind each id twice. */ export const SQLITE_ID_CHUNK = 200; export function chunkIds(ids: string[], chunkSize: number): string[][] { const chunks: string[][] = []; for (let i = 0; i < ids.length; i += chunkSize) chunks.push(ids.slice(i, i + chunkSize)); return chunks; } /** Newest `prefix_N.sqlite` under CODEX_HOME, or null when absent. */ function newestVersionedDb(codexHome: string, pattern: RegExp): string | null { let best: string | null = null; let bestVersion = -1; let names: string[] = []; try { names = readdirSync(codexHome); } catch { return null; } for (const name of names) { const match = name.match(pattern); if (!match) continue; const version = Number(match[1]); if (version > bestVersion) { bestVersion = version; best = name; } } return best ? join(codexHome, best) : null; } function newestStateDb(codexHome: string): string | null { return newestVersionedDb(codexHome, STATE_DB_FILE); } export interface RuntimeDbPaths { state: string | null; logs: string | null; goals: string | null; memories: string | null; } export function discoverRuntimeDbPaths(codexHome: string): RuntimeDbPaths { return { state: newestVersionedDb(codexHome, STATE_DB_FILE), logs: newestVersionedDb(codexHome, LOGS_DB_FILE), goals: newestVersionedDb(codexHome, GOALS_DB_FILE), memories: newestVersionedDb(codexHome, MEMORIES_DB_FILE), }; } export function openDbWritable(dbPath: string, busyTimeoutMs = 100): Database { const db = new Database(dbPath); try { // bun:sqlite exposes a binding-level timeout; set both so Windows lock waits // honor the caller's budget (pragma alone has been flaky under CI contention). (db as Database & { timeout?: number }).timeout = busyTimeoutMs; } catch { /* older bindings */ } try { db.exec(`PRAGMA busy_timeout = ${busyTimeoutMs}`); } catch { /* older sqlite */ } try { db.exec("PRAGMA foreign_keys = ON"); } catch { /* ignore */ } return db; } function isBusyError(error: unknown): boolean { const msg = error instanceof Error ? error.message : String(error); const code = (error as { code?: string })?.code ?? ""; return ( code === "SQLITE_BUSY" || code === "SQLITE_LOCKED" || /SQLITE_BUSY|SQLITE_LOCKED|database is locked|database table is locked/i.test(msg) ); } export function mapDbError(error: unknown): CleanupErrorCode { if (isBusyError(error)) return "codex_busy"; return "db_reconcile_failed"; } /** Probe a single DB with BEGIN IMMEDIATE; missing path is a no-op success. */ function probeDbWritable( path: string | null, busyTimeoutMs: number, ): { ok: true } | { ok: false; error: CleanupErrorCode } { if (!path || !existsSync(path)) return { ok: true }; let db: Database | undefined; try { db = openDbWritable(path, busyTimeoutMs); db.exec("BEGIN IMMEDIATE"); db.exec("ROLLBACK"); return { ok: true }; } catch (error) { if (isBusyError(error)) return { ok: false, error: "codex_busy" }; return { ok: false, error: "db_reconcile_failed" }; } finally { try { db?.close(); } catch { /* */ } } } /** * True when every present Codex runtime DB can be written (BEGIN IMMEDIATE). * Busy / corrupt stores abort cleanup before any filesystem mutation. */ export function probeStateDbWritable( codexHome: string, busyTimeoutMs = 100, ): { ok: true; path: string } | { ok: false; error: CleanupErrorCode } { const paths = discoverRuntimeDbPaths(codexHome); for (const path of [paths.state, paths.logs, paths.goals, paths.memories]) { const probed = probeDbWritable(path, busyTimeoutMs); if (!probed.ok) return probed; } return { ok: true, path: paths.state ?? "" }; } export function tableExists(db: Database, name: string): boolean { const row = db.query<{ name: string }, [string]>( `SELECT name FROM sqlite_master WHERE type='table' AND name=?`, ).get(name); return Boolean(row); } export function columnExists(db: Database, table: string, column: string): boolean { if (!tableExists(db, table)) return false; // `table` is only ever a hardcoded identifier already verified via sqlite_master. const rows = db.query<{ name: string }, []>( `PRAGMA table_info("${table.replaceAll('"', '""')}")`, ).all(); return rows.some(r => r.name === column); } export interface ReconcileErr { ok: false; error: CleanupErrorCode; /** True when satellite rows were mutated and could not all be restored. */ satelliteRestoreFailed?: boolean; } export type SqlRow = Record<string, string | number | bigint | null | Uint8Array>; function quoteIdent(name: string): string { return `"${name.replaceAll('"', '""')}"`; } export function selectRows(db: Database, sql: string, params: Array<string | number>): SqlRow[] { return db.query<SqlRow, Array<string | number>>(sql).all(...params) as SqlRow[]; } export function tableColumnNames(db: Database, table: string): Set<string> { if (!tableExists(db, table)) return new Set(); const rows = db.query<{ name: string }, []>( `PRAGMA table_info("${table.replaceAll('"', '""')}")`, ).all(); return new Set(rows.map(r => r.name)); } /** Insert rows with ON CONFLICT DO NOTHING; returns only rows that were newly inserted. */ export function insertRowsConflictIgnore(db: Database, table: string, rows: SqlRow[]): SqlRow[] { const inserted: SqlRow[] = []; if (rows.length === 0) return inserted; const allowed = tableColumnNames(db, table); for (const row of rows) { const cols = Object.keys(row).filter(c => allowed.has(c)); if (cols.length === 0) continue; const result = db.run( `INSERT INTO ${quoteIdent(table)} (${cols.map(quoteIdent).join(", ")}) VALUES (${cols.map(() => "?").join(", ")}) ON CONFLICT DO NOTHING`, cols.map(c => row[c] as string | number | bigint | null | Uint8Array), ); if (result.changes > 0) inserted.push(row); } return inserted; } export function updateRowFromSnapshot( db: Database, table: string, row: SqlRow, pkCols: string[], ): void { const cols = Object.keys(row).filter(c => !pkCols.includes(c)); if (cols.length === 0) return; const sets = cols.map(c => `${quoteIdent(c)} = ?`).join(", "); const where = pkCols.map(c => `${quoteIdent(c)} = ?`).join(" AND "); db.run( `UPDATE ${quoteIdent(table)} SET ${sets} WHERE ${where}`, [ ...cols.map(c => row[c] as string | number | bigint | null | Uint8Array), ...pkCols.map(c => row[c] as string | number | bigint | null | Uint8Array), ], ); } function normalizeSqlValue( v: string | number | bigint | null | Uint8Array | undefined, ): string { if (v === null || v === undefined) return ""; if (typeof v === "bigint") return v.toString(); if (v instanceof Uint8Array) return Buffer.from(v).toString("base64"); return String(v); } export function sqlRowEqual(a: SqlRow, b: SqlRow): boolean { const keys = new Set([...Object.keys(a), ...Object.keys(b)]); for (const key of keys) { if (normalizeSqlValue(a[key]) !== normalizeSqlValue(b[key])) return false; } return true; } export function withWritableDb( path: string, busyTimeoutMs: number, body: (db: Database) => void, ): { ok: true } | ReconcileErr { let db: Database | undefined; try { db = openDbWritable(path, busyTimeoutMs); db.exec("BEGIN IMMEDIATE"); try { body(db); db.exec("COMMIT"); return { ok: true }; } catch (error) { try { db.exec("ROLLBACK"); } catch { /* */ } throw error; } } catch (error) { return { ok: false, error: mapDbError(error) }; } finally { try { db?.close(); } catch { /* */ } } } export function isSqlRowArray(value: unknown): value is SqlRow[] { return Array.isArray(value) && value.every(row => row && typeof row === "object" && !Array.isArray(row)); }