UNPKG

@bitkyc08/opencodex

Version:

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

230 lines (207 loc) • 8.39 kB
import { createHash } from "node:crypto"; import { chmodSync, closeSync, constants, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, truncateSync, unlinkSync, writeFileSync, } from "node:fs"; import { basename, isAbsolute, join, relative, resolve, toNamespacedPath } from "node:path"; import { Database } from "bun:sqlite"; import { getConfigDir } from "../config"; import { hardenSecretPath } from "../lib/windows-secret-acl"; import { renameAtomicFile } from "../lib/windows-atomic-replace"; import { decodeCompactionSummary, isCompactionItemType, SUMMARY_PREFIX, } from "../responses/compaction"; import { decodeRetainedCompaction } from "../responses/retained-compaction"; import { resolveCodexHomeDir } from "./home"; import { resolveCodexStateDbPath } from "./paths"; export interface OcxCompactionRewriteResult { content: string; replaced: number; } export interface OcxCompactionHistoryRecoveryResult { rolloutPath: string; backupPath: string | null; replaced: number; } export interface OcxCompactionHistoryRecoveryOptions { threadId: string; codexHome?: string; stateDbPath?: string; backupRoot?: string; now?: () => Date; } const THREAD_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i; function digest(content: string | Buffer): string { return createHash("sha256").update(content).digest("hex"); } function pathInside(root: string, candidate: string): boolean { const rel = relative(root, candidate); return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel)); } function resolveOwnedRolloutPath(codexHome: string, rawPath: string): string { const candidate = resolve(isAbsolute(rawPath) ? rawPath : join(codexHome, rawPath)); const roots = [join(codexHome, "sessions"), join(codexHome, "archived_sessions")] .filter(existsSync) .map(root => realpathSync.native(root)); const entry = lstatSync(candidate); if (!entry.isFile() || entry.isSymbolicLink()) { throw new Error("the referenced rollout is not a regular file"); } const canonical = realpathSync.native(candidate); if (!roots.some(root => pathInside(root, canonical))) { throw new Error("the referenced rollout is outside Codex session storage"); } return canonical; } function writePrivateFile(path: string, content: string): void { const fd = openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600); try { if (process.platform !== "win32") chmodSync(path, 0o600); // icacls needs the extended Windows spelling once backup/temp names exceed MAX_PATH. else hardenSecretPath(toNamespacedPath(path), { required: true, timeoutMemoKey: path }); writeFileSync(fd, content, "utf8"); fsyncSync(fd); } finally { closeSync(fd); } } function safeRemovePrivateFile(path: string): void { try { truncateSync(path, 0); } catch { /* best effort before unlink */ } try { unlinkSync(path); } catch { /* caller reports the original failure */ } } function isRecord(value: unknown): value is Record<string, unknown> { return value !== null && typeof value === "object" && !Array.isArray(value); } function lowerCompactionItem(item: unknown): { items: unknown[]; changed: boolean } { if (!isRecord(item) || !isCompactionItemType(item.type)) { return { items: [item], changed: false }; } if (typeof item.encrypted_content !== "string") { return { items: [item], changed: false }; } const retained = decodeRetainedCompaction(item.encrypted_content); const summary = retained?.summary ?? decodeCompactionSummary(item.encrypted_content); if (summary === null) return { items: [item], changed: false }; return { items: [{ type: "message", role: "user", content: [{ type: "input_text", text: `${SUMMARY_PREFIX}\n${summary}` }], }, ...(retained?.reasoning ?? []).map(text => ({ type: "message", role: "user", content: [{ type: "input_text", text }] }))], changed: true, }; } function rewriteJsonlLine(line: string): { line: string; replaced: number } { let record: unknown; try { record = JSON.parse(line); } catch { return { line, replaced: 0 }; } if (!isRecord(record) || record.type !== "compacted" || !isRecord(record.payload)) { return { line, replaced: 0 }; } const history = record.payload.replacement_history; if (!Array.isArray(history)) return { line, replaced: 0 }; let replaced = 0; const replacementHistory = history.flatMap(item => { const lowered = lowerCompactionItem(item); if (lowered.changed) replaced += 1; return lowered.items; }); if (replaced === 0) return { line, replaced: 0 }; return { line: JSON.stringify({ ...record, payload: { ...record.payload, replacement_history: replacementHistory }, }), replaced, }; } /** * Convert OpenCodeX-owned `ocx1:`/`ocx2:` compaction items into ordinary replayable user messages. * * Only the authoritative `compacted.payload.replacement_history` snapshot is changed. Earlier * response-item events are historical output and are deliberately preserved byte-for-byte. * Native opaque compactions are also untouched because OpenCodeX cannot decode them safely. */ export function rewriteOcxCompactionsForNativeReplay(content: string): OcxCompactionRewriteResult { const parts = content.split(/(\r?\n)/); let replaced = 0; for (let index = 0; index < parts.length; index += 2) { const line = parts[index]; if (!line) continue; const rewritten = rewriteJsonlLine(line); if (rewritten.replaced === 0) continue; parts[index] = rewritten.line; replaced += rewritten.replaced; } return replaced === 0 ? { content, replaced: 0 } : { content: parts.join(""), replaced }; } /** * Repair one explicitly selected Codex rollout for direct native replay. * * The original bytes are copied to an owner-private backup before the rollout is atomically * replaced. A last-moment digest check refuses a concurrent Codex append instead of losing it. */ export function recoverOcxCompactionHistory( options: OcxCompactionHistoryRecoveryOptions, ): OcxCompactionHistoryRecoveryResult { if (!THREAD_ID_RE.test(options.threadId)) throw new Error("thread id must be a UUID"); const codexHome = realpathSync.native(options.codexHome ?? resolveCodexHomeDir()); const stateDbPath = options.stateDbPath ?? resolveCodexStateDbPath({ codexHome }); if (!existsSync(stateDbPath)) throw new Error("Codex state database was not found"); const db = new Database(stateDbPath, { readonly: true }); let rawRolloutPath: string | undefined; try { db.exec("PRAGMA busy_timeout = 1000"); rawRolloutPath = db.query<{ rollout_path: string }, [string]>( "SELECT rollout_path FROM threads WHERE id = ? LIMIT 1", ).get(options.threadId)?.rollout_path; } finally { db.close(); } if (!rawRolloutPath) throw new Error("thread was not found in the Codex state database"); const rolloutPath = resolveOwnedRolloutPath(codexHome, rawRolloutPath); const originalBytes = readFileSync(rolloutPath); const original = originalBytes.toString("utf8"); if (!Buffer.from(original, "utf8").equals(originalBytes)) { throw new Error("the rollout is not valid UTF-8 and cannot be repaired safely"); } const rewritten = rewriteOcxCompactionsForNativeReplay(original); if (rewritten.replaced === 0) { return { rolloutPath, backupPath: null, replaced: 0 }; } const stamp = (options.now ?? (() => new Date()))().toISOString().replace(/[:.]/g, "-"); const backupDir = resolve(options.backupRoot ?? join(getConfigDir(), "history-recovery-backups", options.threadId)); mkdirSync(backupDir, { recursive: true, mode: 0o700 }); const backupPath = join(backupDir, `${basename(rolloutPath)}.${stamp}.bak`); writePrivateFile(backupPath, original); const tempPath = `${rolloutPath}.ocx-repair-${process.pid}-${crypto.randomUUID()}.tmp`; try { writePrivateFile(tempPath, rewritten.content); if (digest(readFileSync(rolloutPath)) !== digest(originalBytes)) { throw new Error("the rollout changed while it was being repaired; close Codex and retry"); } renameAtomicFile(tempPath, rolloutPath); } catch (error) { safeRemovePrivateFile(tempPath); throw error; } return { rolloutPath, backupPath, replaced: rewritten.replaced }; }