UNPKG

@bitkyc08/opencodex

Version:

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

240 lines (221 loc) • 9.62 kB
import { closeSync, constants, fstatSync, existsSync, lstatSync, linkSync, openSync, readSync, readlinkSync, statSync, symlinkSync, unlinkSync, } from "node:fs"; import { posix, win32 } from "node:path"; import { sameFileIdentity, statTimeMs, type FileIdentity } from "../lib/file-identity"; import { SHIM_MARKER, UNIX_SHIM_REVISION_MARKER, WINDOWS_SHIM_REVISION_MARKER } from "./shim-templates"; import type { ShimFileState } from "./shim-state-file"; const CODEX_SHIM_PROBE_BYTES = 16 * 1024; interface ShimPathFingerprint { dev: number; ino: number; identity: FileIdentity; kind: "file" | "symlink"; mode: number; size: number; mtimeMs: number; ctimeMs: number; target?: Omit<ShimPathFingerprint, "target">; } interface StableShimPathProbe { fingerprint: ShimPathFingerprint; prefix: string; } function readShimProbePrefix(path: string): string { const fd = openSync(path, process.platform === "win32" ? "r" : constants.O_RDONLY | constants.O_NONBLOCK); try { if (process.platform !== "win32" && !fstatSync(fd).isFile()) throw new Error("Shim probe entry is not a regular file"); const buffer = Buffer.allocUnsafe(CODEX_SHIM_PROBE_BYTES); const bytesRead = readSync(fd, buffer, 0, buffer.length, 0); return buffer.toString("utf8", 0, bytesRead); } finally { closeSync(fd); } } function statFingerprint(path: string, follow: boolean): Omit<ShimPathFingerprint, "target"> | null { try { const stat = follow ? statSync(path, { bigint: true }) : lstatSync(path, { bigint: true }); if (follow ? !stat.isFile() : (!stat.isFile() && !stat.isSymbolicLink())) return null; return { dev: Number(stat.dev), ino: Number(stat.ino), identity: { dev: stat.dev, ino: stat.ino }, kind: stat.isSymbolicLink() ? "symlink" : "file", mode: Number(stat.mode), size: Number(stat.size), mtimeMs: statTimeMs(stat.mtimeNs), ctimeMs: statTimeMs(stat.ctimeNs), }; } catch { return null; } } function sameFingerprint( left: ShimPathFingerprint | Omit<ShimPathFingerprint, "target">, right: ShimPathFingerprint | Omit<ShimPathFingerprint, "target">, ): boolean { return !!left.identity && !!right.identity && sameFileIdentity(left.identity, right.identity) && left.kind === right.kind && left.mode === right.mode && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs && (!("target" in left) || !("target" in right) ? true : left.target === undefined && right.target === undefined ? true : left.target !== undefined && right.target !== undefined ? sameFingerprint(left.target, right.target) : false); } function sameFingerprintAfterRename(left: ShimPathFingerprint, right: ShimPathFingerprint): boolean { // rename changes the outer directory entry ctime on macOS; every other field, // including a symlink target fingerprint, must remain identical. return sameFingerprint({ ...left, ctimeMs: 0 }, { ...right, ctimeMs: 0 }); } function stableShimPathProbe(path: string): StableShimPathProbe | null { const before = statFingerprint(path, false); if (!before) return null; const targetBefore = before.kind === "symlink" ? statFingerprint(path, true) : undefined; if (before.kind === "symlink" && !targetBefore) return null; let prefix: string; try { prefix = readShimProbePrefix(path); } catch { return null; } const targetAfter = before.kind === "symlink" ? statFingerprint(path, true) : undefined; const after = statFingerprint(path, false); if (!after || !sameFingerprint(before, after)) return null; if (before.kind === "symlink") { if (!targetBefore || !targetAfter || !sameFingerprint(targetBefore, targetAfter)) return null; } const fingerprint: ShimPathFingerprint = { ...before, ...(targetBefore ? { target: targetBefore } : {}), }; const contentSize = fingerprint.target?.size ?? fingerprint.size; return contentSize > 0 ? { fingerprint, prefix } : null; } function sameStableShimPathProbe(left: StableShimPathProbe, right: StableShimPathProbe): boolean { return left.prefix === right.prefix && sameFingerprint(left.fingerprint, right.fingerprint); } /** * Identity of whatever sits at `path`, read from metadata alone. * * `stableShimPathProbe` answers a different question: it reads content to decide * whether a launcher looks like a healthy shim, and it deliberately returns null * for a zero-byte file. That makes it the wrong instrument for rollback * bookkeeping. A user can legitimately own an empty `codex` launcher, and a fresh * install moves it aside before writing our wrapper; if the move is recorded * without a fingerprint, rollback cannot prove the backup is still the file it * set aside and refuses to restore it — the launcher stays lost (#1625). * * Content is irrelevant to that proof, so this reads dev/ino/mode/size/times and * re-reads them to reject a path that changed under us, following a symlink to * fingerprint its target as well. */ function shimPathFingerprint(path: string): ShimPathFingerprint | null { const before = statFingerprint(path, false); if (!before) return null; if (before.kind !== "symlink") { const after = statFingerprint(path, false); return after && sameFingerprint(before, after) ? before : null; } const targetBefore = statFingerprint(path, true); if (!targetBefore) return null; const targetAfter = statFingerprint(path, true); const after = statFingerprint(path, false); if (!targetAfter || !after || !sameFingerprint(targetBefore, targetAfter) || !sameFingerprint(before, after)) return null; return { ...before, target: targetBefore }; } /** * Move `from` onto `to` without ever replacing an existing entry. * * `renameSync` silently clobbers the destination on POSIX, which is wrong for a * rollback restore: `sourceOccupied` is sampled before the fingerprint check, so * a concurrent installer can publish its own launcher at the original path in * between, and the restore would delete it. `link` fails EEXIST instead, which * is the no-replace primitive we need and needs no native helper. * * `link` follows a symlink to its target rather than preserving the link, so a * symlink launcher is republished with `symlink`, which is also no-replace: it * fails EEXIST on an occupied destination. Checking existence and then renaming * would reintroduce exactly the race this function exists to close. */ function restoreWithoutReplacing(from: string, to: string, guard?: () => void): void { const source = lstatSync(from); if (source.isSymbolicLink()) { symlinkSync(readlinkSync(from), to); guard?.(); unlinkSync(from); return; } linkSync(from, to); guard?.(); unlinkSync(from); } function isHealthyShimProbe(probe: StableShimPathProbe, platform: NodeJS.Platform): boolean { if (probe.prefix.length < 180 || !probe.prefix.includes(SHIM_MARKER) || !probe.prefix.includes("ensure")) return false; const mode = probe.fingerprint.target?.mode ?? probe.fingerprint.mode; return platform === "win32" || (mode & 0o111) !== 0; } function isCurrentUnixShimProbe(probe: StableShimPathProbe): boolean { return probe.prefix.includes(UNIX_SHIM_REVISION_MARKER); } /** A Windows wrapper is current when it carries its flavor's revision (CMD/PowerShell, or Git-Bash's Unix one). */ function isCurrentWindowsShimProbe(probe: StableShimPathProbe): boolean { return probe.prefix.includes(WINDOWS_SHIM_REVISION_MARKER) || probe.prefix.includes(UNIX_SHIM_REVISION_MARKER); } function isCurrentShimProbe(probe: StableShimPathProbe, platform: NodeJS.Platform): boolean { return platform === "win32" ? isCurrentWindowsShimProbe(probe) : isCurrentUnixShimProbe(probe); } function hasUsableBackingPath(file: ShimFileState): boolean { return [existsSync(file.backupPath) ? file.backupPath : undefined, file.realPath] .some(path => { if (!path) return false; const fingerprint = statFingerprint(path, true); return fingerprint !== null && fingerprint.size > 0; }); } /** * True when a Codex binary lives inside a version manager's install tree. * * These trees are rewritten in place on upgrade, which destroys both the shim * and the sibling .opencodex-real backup it restores from (#2412). The tempting * repair — adopt the newly installed binary as a fresh original — is wrong * twice: it records a provenance that never happened, and the next upgrade wipes * it again, so the repair silently un-repairs on the version manager's schedule. * * Scope is the three managers named in the report. nvm/fnm/npm-prefix are * deliberately excluded: a false positive here refuses a restore that would * otherwise be correct. */ export function isVersionManagerOwnedCodexPath( path: string, platform: NodeJS.Platform = process.platform, ): boolean { const normalized = (platform === "win32" ? win32.normalize(path).replace(/\\/g, "/") : posix.normalize(path)).toLowerCase(); return normalized.includes("/mise/installs/") || normalized.includes("/mise/shims/") || normalized.includes("/.asdf/installs/") || normalized.includes("/.asdf/shims/") || normalized.includes("/.volta/"); } export type { ShimPathFingerprint, StableShimPathProbe }; export { statFingerprint, sameFingerprint, sameFingerprintAfterRename, stableShimPathProbe, sameStableShimPathProbe, shimPathFingerprint, restoreWithoutReplacing, isHealthyShimProbe, isCurrentUnixShimProbe, isCurrentShimProbe, hasUsableBackingPath };