UNPKG

@bitkyc08/opencodex

Version:

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

152 lines (139 loc) • 5.67 kB
import { closeSync, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readSync, writeFileSync, type Stats, } from "node:fs"; import { join } from "node:path"; import { getConfigDir } from "../config"; import { recordOwnedConfigPath } from "../lib/config-ownership"; export const CODEX_SHIM_STATE_MAX_BYTES = 1024 * 1024; interface ShimState { platform: NodeJS.Platform; wrapperPath: string; originalPath: string; backupPath: string; wrappers?: ShimFileState[]; } interface ShimFileState { wrapperPath: string; originalPath: string; backupPath: string; realPath?: string; preserveOnly?: boolean; } interface ShimStateReadResult { state: ShimState | null; present: boolean; warning?: string; } function fileErrorCode(error: unknown): string | undefined { return error && typeof error === "object" && "code" in error ? String((error as { code?: unknown }).code) : undefined; } function readBoundedRegularFile(path: string, maxBytes: number): { bytes: Buffer; content: string } | { warning: string } | null { let lexicalBefore: Stats; try { lexicalBefore = lstatSync(path); if (lexicalBefore.isSymbolicLink() || !lexicalBefore.isFile()) { return { warning: `Codex shim state is not a direct regular file at ${path}; auto-restore skipped.` }; } } catch (error) { if (fileErrorCode(error) === "ENOENT") return null; return { warning: `Codex shim state could not be inspected at ${path}.` }; } let fd: number; try { fd = openSync(path, "r"); } catch (error) { if (fileErrorCode(error) === "ENOENT") return null; return { warning: `Codex shim state could not be opened as a regular file at ${path}.` }; } try { const before = fstatSync(fd); if (!before.isFile()) return { warning: `Codex shim state is not a regular file at ${path}; auto-restore skipped.` }; if (before.size > maxBytes) { return { warning: `Codex shim state exceeds the 1 MiB startup limit at ${path}; auto-restore skipped.` }; } const buffer = Buffer.allocUnsafe(before.size); let offset = 0; while (offset < buffer.length) { const bytesRead = readSync(fd, buffer, offset, buffer.length - offset, offset); if (bytesRead === 0) return { warning: `Codex shim state changed while being read at ${path}; auto-restore skipped.` }; offset += bytesRead; } const extra = Buffer.allocUnsafe(1); if (readSync(fd, extra, 0, 1, offset) !== 0) { return { warning: `Codex shim state exceeds the 1 MiB startup limit at ${path}; auto-restore skipped.` }; } const after = fstatSync(fd); let lexicalAfter: Stats; try { lexicalAfter = lstatSync(path); } catch { return { warning: `Codex shim state changed while being read at ${path}; auto-restore skipped.` }; } if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs || lexicalBefore.dev !== before.dev || lexicalBefore.ino !== before.ino || lexicalAfter.isSymbolicLink() || lexicalAfter.dev !== after.dev || lexicalAfter.ino !== after.ino) { return { warning: `Codex shim state changed while being read at ${path}; auto-restore skipped.` }; } return { bytes: buffer, content: buffer.toString("utf8") }; } finally { closeSync(fd); } } function readStateResult(path = statePath()): ShimStateReadResult { const bounded = readBoundedRegularFile(path, CODEX_SHIM_STATE_MAX_BYTES); if (!bounded) return { state: null, present: false }; if ("warning" in bounded) return { state: null, present: true, warning: bounded.warning }; try { const value = JSON.parse(bounded.content) as unknown; if (!value || typeof value !== "object") return { state: null, present: true }; const state = value as Record<string, unknown>; if (typeof state.platform !== "string") return { state: null, present: true }; const validFile = (item: unknown): item is ShimFileState => { if (!item || typeof item !== "object") return false; const file = item as Record<string, unknown>; return typeof file.wrapperPath === "string" && typeof file.originalPath === "string" && typeof file.backupPath === "string" && (file.realPath === undefined || typeof file.realPath === "string") && (file.preserveOnly === undefined || typeof file.preserveOnly === "boolean"); }; if (state.wrappers !== undefined) { if (!Array.isArray(state.wrappers) || state.wrappers.length === 0 || !state.wrappers.every(validFile)) return { state: null, present: true }; } else if (!validFile(state)) { return { state: null, present: true }; } return { state: state as unknown as ShimState, present: true }; } catch { return { state: null, present: true }; } } function readState(): ShimState | null { return readStateResult().state; } function statePath(): string { return join(getConfigDir(), "codex-shim.json"); } function writeState(state: ShimState): void { const path = statePath(); recordOwnedConfigPath(getConfigDir(), path); if (!existsSync(getConfigDir())) mkdirSync(getConfigDir(), { recursive: true }); writeFileSync(path, JSON.stringify(state, null, 2) + "\n", "utf8"); } function stateFiles(state: ShimState): ShimFileState[] { return state.wrappers?.length ? state.wrappers : [{ wrapperPath: state.wrapperPath, originalPath: state.originalPath, backupPath: state.backupPath }]; } export type { ShimState, ShimFileState }; export { fileErrorCode, readStateResult, readState, statePath, writeState, stateFiles };