UNPKG

@bitkyc08/opencodex

Version:

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

250 lines (229 loc) • 8.19 kB
import { chmodSync, linkSync, mkdirSync, readFileSync, truncateSync, unlinkSync, writeFileSync } from "node:fs"; import { dirname } from "node:path"; import { AtomicWriteResidualTempError, AtomicWriteSecretResidualError, atomicWriteFile, getConfigDir, resolveWriteTarget, type AtomicWriteIO, } from "../../config"; import { assertCatalogWritePermit, type CatalogWritePermit, } from "../catalog-write-serialization"; import { forgetEphemeralSecretPath, hardenSecretPath, } from "../../lib/windows-secret-acl"; import { resetCodexAppServerCatalogStateCache } from "../app-server-processes"; import { recordOwnedConfigPath } from "../../lib/config-ownership"; export interface PreparedCatalogFileWrite { readonly path: string; readonly content: string; } export type CatalogBackupPublication = "written" | "preserved"; export interface CatalogBackupWriteIO { readonly resolveTarget: (path: string) => string; readonly write: (path: string, content: string) => void; readonly harden: (path: string) => void; /** Must fail with EEXIST rather than replacing an existing destination. */ readonly publishNoReplace: (source: string, destination: string) => void; readonly truncate: (path: string) => void; readonly unlink: (path: string) => void; } let backupTempSequence = 0; /** * Do the prepared bytes differ from what is already on disk at `prepared.path`? * * The single no-op rule for both files the catalog layer owns — the active catalog * and Codex's models cache — so the two writers cannot drift apart. Every * mtime-keyed reader has to treat a rewrite as a change: the app-server staleness * classifier (#857) compares a file's mtime against each running Codex's start * time, so rewriting identical bytes marks every already-running Codex as stale * even though nothing changed. #1459 established this rule for the catalog; the * cache is the second writer that has to apply it, because * `refreshCodexModelCatalog` reports `cacheSynced` straight into the startup * warning in `handleStart`. * * Deliberately a Buffer rather than a decoded string: `readFileSync(path, "utf8")` * substitutes U+FFFD for every invalid byte, so a file holding a raw 0x80 decodes * equal to prepared content holding a legitimately encoded U+FFFD. Comparing * decoded strings would then classify a malformed file as identical, skip the * atomic repair write, and leave the corruption on disk. * * An unreadable or absent file reports "differs", so the caller performs the real * write; that also converges a file that does not exist yet. */ export function preparedBytesDifferFromDisk(prepared: PreparedCatalogFileWrite): boolean { let onDisk: Buffer; try { onDisk = readFileSync(prepared.path); } catch { return true; } return !onDisk.equals(Buffer.from(prepared.content, "utf8")); } function isMissingPathError(error: unknown): boolean { return (error as NodeJS.ErrnoException | undefined)?.code === "ENOENT"; } function isExistingPathError(error: unknown): boolean { return (error as NodeJS.ErrnoException | undefined)?.code === "EEXIST"; } function defaultBackupWriteIO(destinationPath: string): CatalogBackupWriteIO { return { resolveTarget: resolveWriteTarget, write: (path, content) => writeFileSync(path, content, { encoding: "utf8", mode: 0o600 }), harden: path => { try { chmodSync(path, 0o600); } catch { /* platform may ignore chmod */ } if (process.platform === "win32") { hardenSecretPath(path, { required: true, timeoutMemoKey: destinationPath }); } }, publishNoReplace: linkSync, truncate: path => truncateSync(path, 0), unlink: unlinkSync, }; } function removePublishedTemp(tempPath: string, io: CatalogBackupWriteIO): void { try { io.unlink(tempPath); forgetEphemeralSecretPath(tempPath); return; } catch (firstError) { if (isMissingPathError(firstError)) { forgetEphemeralSecretPath(tempPath); return; } try { io.unlink(tempPath); forgetEphemeralSecretPath(tempPath); return; } catch (retryError) { if (isMissingPathError(retryError)) { forgetEphemeralSecretPath(tempPath); return; } throw new AtomicWriteResidualTempError(tempPath, true, { cause: retryError }); } } } function scrubAndRemoveUnpublishedTemp( tempPath: string, hardened: boolean, io: CatalogBackupWriteIO, cause: unknown, ): void { let scrubbed = false; try { io.truncate(tempPath); scrubbed = true; } catch (error) { if (isMissingPathError(error)) scrubbed = true; else { try { io.write(tempPath, ""); scrubbed = true; } catch { /* removal may still succeed */ } } } let removed = false; try { io.unlink(tempPath); removed = true; } catch (error) { if (isMissingPathError(error)) removed = true; else { try { io.unlink(tempPath); removed = true; } catch (retryError) { if (isMissingPathError(retryError)) removed = true; } } } if (!removed && !scrubbed) { throw new AtomicWriteSecretResidualError(tempPath, { cause }); } if (!removed && !hardened) { try { io.harden(tempPath); hardened = true; } catch { /* zero-byte residual is reported honestly */ } } if (removed) forgetEphemeralSecretPath(tempPath); if (!removed) throw new AtomicWriteResidualTempError(tempPath, hardened, { cause }); } function publishCatalogBackup( prepared: PreparedCatalogFileWrite, suppliedIo?: CatalogBackupWriteIO, onPublished?: () => void, ): CatalogBackupPublication { const io = suppliedIo ?? defaultBackupWriteIO(prepared.path); const target = io.resolveTarget(prepared.path); if (!suppliedIo) mkdirSync(dirname(target), { recursive: true, mode: 0o700 }); const tempPath = `${target}.ocx.${process.pid}.backup.${++backupTempSequence}.tmp`; let hardened = false; try { io.write(tempPath, prepared.content); io.harden(tempPath); hardened = true; io.publishNoReplace(tempPath, target); } catch (error) { scrubAndRemoveUnpublishedTemp(tempPath, hardened, io, error); if (isExistingPathError(error)) return "preserved"; throw error; } try { // Publication already succeeded; cleanup failure must not erase that ownership. onPublished?.(); } finally { removePublishedTemp(tempPath, io); } return "written"; } /** Replace the active catalog with the caller's already-prepared bytes. */ export function replaceActiveCodexCatalog( permit: CatalogWritePermit, owningCodexHome: string, prepared: PreparedCatalogFileWrite, io?: AtomicWriteIO, ): void { assertCatalogWritePermit(permit, owningCodexHome); atomicWriteFile(prepared.path, prepared.content, io); resetCodexAppServerCatalogStateCache(); } /** Atomically publish the catalog-path-keyed immutable backup without clobbering. */ export function publishHashedCodexCatalogBackup( permit: CatalogWritePermit, owningCodexHome: string, prepared: PreparedCatalogFileWrite, io?: CatalogBackupWriteIO, ): CatalogBackupPublication { assertCatalogWritePermit(permit, owningCodexHome); return publishCatalogBackup(prepared, io, io ? undefined : () => { // Called only after a new no-replace publication, never for preserved winners. recordOwnedConfigPath(getConfigDir(), prepared.path); }); } /** Atomically publish the legacy immutable backup without clobbering. */ export function publishLegacyCodexCatalogBackup( permit: CatalogWritePermit, owningCodexHome: string, prepared: PreparedCatalogFileWrite, io?: CatalogBackupWriteIO, ): CatalogBackupPublication { assertCatalogWritePermit(permit, owningCodexHome); return publishCatalogBackup(prepared, io); } /** Replace Codex's models cache with the caller's already-prepared bytes. */ export function replaceCodexModelsCache( permit: CatalogWritePermit, owningCodexHome: string, prepared: PreparedCatalogFileWrite, io?: AtomicWriteIO, ): void { assertCatalogWritePermit(permit, owningCodexHome); atomicWriteFile(prepared.path, prepared.content, io); resetCodexAppServerCatalogStateCache(); }