@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
269 lines (251 loc) • 10.7 kB
text/typescript
import { chmodSync, constants as fsConstants, copyFileSync, existsSync, linkSync, readFileSync, truncateSync, unlinkSync, writeFileSync } from "node:fs";
import { getConfigPath } from "./paths";
import { isMissingPathError, nextAtomicTempSequence } from "./atomic-write";
import { forgetEphemeralSecretPath, hardenSecretPath } from "../lib/windows-secret-acl";
export class OpenAiTierBackupCleanupError extends Error {
constructor() { super("OpenAI tier backup temporary cleanup failed"); this.name = "OpenAiTierBackupCleanupError"; }
}
export class OpenAiTierBackupRollbackError extends Error {
constructor() { super("OpenAI tier backup rollback failed"); this.name = "OpenAiTierBackupRollbackError"; }
}
export class OpenAiTierBackupCollisionError extends Error {
readonly configPath?: string;
constructor(configPath?: string) {
super("Existing OpenAI tier backup differs from the current config");
this.name = "OpenAiTierBackupCollisionError";
this.configPath = configPath;
}
}
export class OpenAiTierRollbackPreserveError extends Error {
readonly code?: "missing" | "not-rollback" | "mismatch" | "exhausted";
constructor(message: string, options?: ErrorOptions & { code?: OpenAiTierRollbackPreserveError["code"] }) {
super(message, options);
this.name = "OpenAiTierRollbackPreserveError";
this.code = options?.code;
}
}
export class OpenAiTierBackupSecretResidualError extends Error {
constructor(readonly tempPath: string, options?: ErrorOptions) {
super("OpenAI tier backup could not scrub or remove a secret-bearing temporary file", options);
this.name = "OpenAiTierBackupSecretResidualError";
}
}
export interface OpenAiTierBackupIO {
exists(path: string): boolean;
read(path: string): Uint8Array;
createExclusive(path: string): void;
write(path: string, bytes: Uint8Array): void;
harden(path: string): void;
publishNoReplace(temp: string, backup: string): void;
truncate(path: string): void;
unlink(path: string): void;
}
function sameBytes(left: Uint8Array, right: Uint8Array): boolean {
return left.byteLength === right.byteLength && left.every((value, index) => value === right[index]);
}
function isAlreadyExistsError(error: unknown): boolean {
return (error as NodeJS.ErrnoException | undefined)?.code === "EEXIST";
}
/**
* Classify an existing `.pre-openai-tiers-v2.bak` snapshot.
*
* - `"stale"`: unparseable JSON (not written by us / truncated) or already a
* post-migration (tier v2) snapshot — safe to delete or replace.
* - `"rollback"`: parses as a valid pre-migration (v1) config — a
* user-intentional rollback point that must never be silently destroyed.
*
* Shared by the startup migration backup path and `ocx init` cleanup so both
* apply the same preservation policy (issue #257 / sol review 260722).
*/
export function classifyOpenAiTierBackup(backupBytes: Uint8Array): "stale" | "rollback" {
try {
// Use Buffer.from to ensure proper UTF-8 decoding from Uint8Array/Buffer.
const parsed = JSON.parse(Buffer.from(backupBytes).toString("utf8")) as Record<string, unknown>;
return parsed.openaiProviderTierVersion === 2 ? "stale" : "rollback";
} catch {
// Unparseable: not a config file we created, treat as stale.
return "stale";
}
}
export function backupConfigBeforeOpenAiTierMigration(
configPath = getConfigPath(),
io: OpenAiTierBackupIO = {
exists: existsSync,
read: target => readFileSync(target),
createExclusive: target => { writeFileSync(target, new Uint8Array(), { flag: "wx", mode: 0o600 }); },
write: (target, bytes) => writeFileSync(target, bytes),
harden: target => {
try { chmodSync(target, 0o600); } catch { /* platform may ignore chmod */ }
// Soft-fail: a wedged/failed icacls on CI temp volumes must not abort
// startServer mid-suite (timeout + EBUSY cascade on shared TEST_DIR).
// chmod above still applies; live credential writes keep required:true.
if (process.platform === "win32") hardenSecretPath(target, { required: false });
},
publishNoReplace: (temp, backup) => linkSync(temp, backup),
truncate: target => truncateSync(target, 0),
unlink: unlinkSync,
},
): "absent" | "created" | "reused" {
const source = configPath;
if (!io.exists(source)) return "absent";
const original = io.read(source);
// v2 snapshot path. The historical `.pre-openai-tiers-v1.bak` is read only by restore
// docs/fixtures and is never reused or overwritten as the v2 snapshot.
const backup = `${source}.pre-openai-tiers-v2.bak`;
if (io.exists(backup)) {
if (!sameBytes(original, io.read(backup))) {
// The backup differs from the current config. Only treat it as stale when it is
// clearly not a user-intentional rollback point:
// - unparseable JSON: written by a different tool or truncated
// - already at tier version 2: the backup is from a post-migration config (e.g.
// ocx init wrote a fresh v2 config, making the old backup obsolete)
// A backup that parses as a valid pre-migration (v1) config is kept as-is and
// we throw a collision error, because silently replacing a user-created rollback
// point would be surprising and potentially destructive.
const backupBytes = io.read(backup);
if (classifyOpenAiTierBackup(backupBytes) === "rollback") {
throw new OpenAiTierBackupCollisionError(source);
}
console.warn("[openai-provider-migration] Replacing stale pre-migration backup (post-migration config was rewritten since last migration).");
io.unlink(backup);
} else {
return "reused";
}
}
const temp = `${backup}.ocx.${process.pid}.${nextAtomicTempSequence()}.tmp`;
let published = false;
let cleanupAttempted = false;
const scrubUnpublishedTemp = (): void => {
cleanupAttempted = true;
let scrubbed = false;
try {
io.truncate(temp);
scrubbed = true;
} catch (error) {
if (isMissingPathError(error)) scrubbed = true;
else {
try { io.write(temp, new Uint8Array()); scrubbed = true; } catch { /* removal may still succeed */ }
}
}
let removed = false;
try {
io.unlink(temp);
removed = true;
} catch (error) {
if (isMissingPathError(error)) {
removed = true;
}
else {
try { io.unlink(temp); removed = true; }
catch (retryError) {
if (isMissingPathError(retryError)) {
removed = true;
}
}
}
}
if (removed) forgetEphemeralSecretPath(temp);
if (!removed && !scrubbed) throw new OpenAiTierBackupSecretResidualError(temp);
if (!removed) throw new OpenAiTierBackupCleanupError();
};
try {
io.createExclusive(temp);
io.write(temp, original);
io.harden(temp);
try {
io.publishNoReplace(temp, backup);
} catch (cause) {
if (!isAlreadyExistsError(cause)) throw cause;
const winner = io.read(backup);
if (!sameBytes(original, winner)) throw new OpenAiTierBackupCollisionError(source);
scrubUnpublishedTemp();
return "reused";
}
published = true;
try {
io.unlink(temp);
forgetEphemeralSecretPath(temp);
} catch (firstError) {
if (isMissingPathError(firstError)) {
forgetEphemeralSecretPath(temp);
} else try {
io.unlink(temp);
forgetEphemeralSecretPath(temp);
} catch (secondError) {
if (isMissingPathError(secondError)) {
forgetEphemeralSecretPath(temp);
return "created";
}
// temp and backup are hard links to the same inode. Roll back the backup
// link before any truncation so the downgrade snapshot is never zeroed.
try { io.unlink(backup); } catch { throw new OpenAiTierBackupRollbackError(); }
published = false;
scrubUnpublishedTemp();
throw new OpenAiTierBackupCleanupError();
}
}
return "created";
} catch (cause) {
if (!published && !cleanupAttempted) {
scrubUnpublishedTemp();
}
throw cause;
}
}
export interface OpenAiTierRollbackPreserveIO {
exists(path: string): boolean;
read(path: string): Uint8Array;
copyExclusive(source: string, destination: string): void;
unlink(path: string): void;
}
const DEFAULT_ROLLBACK_PRESERVE_IO: OpenAiTierRollbackPreserveIO = {
exists: existsSync,
read: target => readFileSync(target),
copyExclusive: (source, destination) => {
copyFileSync(source, destination, fsConstants.COPYFILE_EXCL);
},
unlink: unlinkSync,
};
const OPENAI_TIER_ROLLBACK_PRESERVE_ATTEMPTS = 16;
/**
* Copy a rollback-classified `.pre-openai-tiers-v2.bak` to a unique
* `.pre-openai-tiers-v1-rollback.<timestamp>[suffix].bak` path, then unlink the
* blocking v2 name. The original bytes are copied with no-replace publication;
* the v2 path is removed only after the copy is verified. Shared by startup
* migration recovery and `ocx init` cleanup so the two paths cannot drift.
*/
export function preserveOpenAiTierRollbackSnapshot(
configPath = getConfigPath(),
io: OpenAiTierRollbackPreserveIO = DEFAULT_ROLLBACK_PRESERVE_IO,
): string {
const backup = `${configPath}.pre-openai-tiers-v2.bak`;
if (!io.exists(backup)) {
throw new OpenAiTierRollbackPreserveError("OpenAI tier rollback backup is missing", { code: "missing" });
}
const original = io.read(backup);
if (classifyOpenAiTierBackup(original) !== "rollback") {
throw new OpenAiTierRollbackPreserveError("OpenAI tier backup is not a rollback snapshot", { code: "not-rollback" });
}
for (let attempt = 0; attempt < OPENAI_TIER_ROLLBACK_PRESERVE_ATTEMPTS; attempt++) {
const preserved = `${configPath}.pre-openai-tiers-v1-rollback.${Date.now()}${attempt ? `-${attempt}` : ""}.bak`;
try {
io.copyExclusive(backup, preserved);
} catch (error) {
if (isAlreadyExistsError(error)) continue;
throw error;
}
let copied: Uint8Array;
try {
copied = io.read(preserved);
} catch (error) {
throw new OpenAiTierRollbackPreserveError("Failed to read preserved rollback snapshot", { cause: error, code: "mismatch" });
}
if (!sameBytes(original, copied)) {
try { io.unlink(preserved); } catch { /* keep the original backup; incomplete copy is best-effort */ }
throw new OpenAiTierRollbackPreserveError("Preserved rollback snapshot does not match source bytes", { code: "mismatch" });
}
io.unlink(backup);
return preserved;
}
throw new OpenAiTierRollbackPreserveError("Unable to find a unique rollback snapshot path", { code: "exhausted" });
}