UNPKG

@bitkyc08/opencodex

Version:

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

109 lines (100 loc) • 6.43 kB
import { readdirSync } from "node:fs"; import { createHash } from "node:crypto"; import { join } from "node:path"; import { isPendingTeardownAbandoned, isValidPendingTeardownReceipt, type OutstandingTeardown, type PendingTeardownReceipt } from "../config/pending-teardown"; import { isAnyTeardownObligationFileName, pendingTeardownNonceFromFileName } from "../config/pending-teardown-names.mjs"; import { getConfigDir } from "../config/paths"; import { isLikelyOcxProcess, type ClientStopOwner, type RuntimePortState } from "../config/process-state"; import { readBoundedRegularFileSync } from "../lib/bounded-file-read"; import { isProcessAlive } from "../lib/process-control"; import { readSyncRuntime } from "./sync-runtime"; import { observeClientStopOwner, readClientStopProcessStart, type ClientStopOwnerStatus } from "./stop-teardown-owner"; export type LinkStopRuntime = Required<Pick<RuntimePortState, "pid" | "port" | "attestationSecret">>; export type NativeTeardownDecision = "restore" | "defer" | "refuse"; const host = (value: string) => value.trim().toLowerCase().replace(/^\[(.*)\]$/, "$1"); type TeardownSnapshot = { state: "valid"; path: string; bytes: Buffer; receipt: PendingTeardownReceipt }; export type LinkInheritedTeardown = OutstandingTeardown & { bytes?: Buffer }; type NativeTeardownEvidence = | TeardownSnapshot | { state: "invalid"; nonce: string; detail: string } | { state: "quarantined" } | { state: "unscannable"; detail: string }; /** The signal and parent preflight use the same bounded, no-follow disk evidence. */ export function readLinkNativeTeardownEvidence(): NativeTeardownEvidence[] { let names: string[]; try { names = readdirSync(getConfigDir()).filter(isAnyTeardownObligationFileName); } catch (error) { return (error as NodeJS.ErrnoException).code === "ENOENT" ? [] : [{ state: "unscannable", detail: "the opencodex home could not be listed" }]; } return names.map(name => { const nonce = pendingTeardownNonceFromFileName(name); if (!nonce) return { state: "quarantined" }; try { const path = join(getConfigDir(), name); const bytes = readBoundedRegularFileSync(path, 4 * 1024); const receipt: unknown = JSON.parse(bytes.toString("utf8")); return isValidPendingTeardownReceipt(receipt, nonce) ? { state: "valid", path, bytes, receipt } : { state: "invalid", nonce, detail: "malformed receipt" }; } catch { return { state: "invalid", nonce, detail: "receipt is not bounded regular JSON" }; } }); } /** Bind the original JSON bytes, which include each receipt's filename nonce. */ export function inheritedTeardownDigest(snapshots: readonly Buffer[]): string | undefined { if (snapshots.length === 0) return; const hash = createHash("sha256"); for (const bytes of [...snapshots].sort(Buffer.compare)) { hash.update(bytes).update("\0"); } return hash.digest("hex"); } /** Preserve the parent's recovery ownership rules and use one snapshot before/after stop. */ export function readLinkInheritedTeardowns(): LinkInheritedTeardown[] { // Multiple valid receipts can name the same stop incarnation. Their nonce is // validated against the filename above and does not change what the OS can prove. const owners = new Map<string, ClientStopOwnerStatus>(); return readLinkNativeTeardownEvidence().flatMap<LinkInheritedTeardown>(read => { if (read.state === "quarantined") return []; if (read.state === "valid" && read.receipt.ownerStartTime) { const { ownerPid: pid, ownerStartTime: startTime, nonce } = read.receipt; const key = `${pid}:${startTime}`; let status = owners.get(key); if (status === undefined) { status = pid === process.pid && readClientStopProcessStart(pid) === startTime ? "active" : observeClientStopOwner({ pid, startTime, nonce }); owners.set(key, status); } if (status === "active") return []; if (status === "unverified") return [{ state: "unscannable", detail: "the pending-teardown receipt's stop owner could not be verified" }]; return [read]; } return isPendingTeardownAbandoned(read, pid => isProcessAlive(pid) && isLikelyOcxProcess(pid)) ? [read] : []; }); } /** Before a receipt is issued, the bound owner already excludes concurrent recycle. */ function activeClientStopOwner(runtime: RuntimePortState): ClientStopOwner | undefined { const owner = runtime.clientStopOwner; if (runtime.clientStopping && runtime.clientStopRequested && owner && observeClientStopOwner(owner) === "active") return owner; } /** Receipts alone never release a socket still named by native loopback routing. */ export function linkNativeTeardownDecision(expected?: LinkStopRuntime): NativeTeardownDecision { const evidence = readLinkNativeTeardownEvidence(); if (evidence.length === 0) return "restore"; try { const runtime = readSyncRuntime(); if (!expected || expected.pid !== process.pid || !runtime || runtime.pid !== expected.pid || runtime.port !== expected.port || runtime.attestationSecret !== expected.attestationSecret || host(runtime.hostname ?? "127.0.0.1") !== "127.0.0.1" || runtime.clientStopping !== true || runtime.clientStopRequested !== true) return "refuse"; // A malformed/guessed inherited obligation blocks the parent's restore too. if (evidence.some(read => read.state === "invalid" || read.state === "unscannable" || read.state === "valid" && read.receipt.endpointSource !== "exact")) return "refuse"; const sameEndpoint = (read: TeardownSnapshot) => read.receipt.endpoint.port === expected.port && host(read.receipt.endpoint.hostname) === "127.0.0.1"; const owner = activeClientStopOwner(runtime); const claim = owner && evidence.find(read => read.state === "valid" && sameEndpoint(read) && read.receipt.nonce === owner.nonce && read.receipt.ownerPid === owner.pid && read.receipt.ownerStartTime === owner.startTime); const foreign = evidence.flatMap(read => read.state === "valid" && !sameEndpoint(read) ? [read.bytes] : []); if (claim?.state === "valid" && inheritedTeardownDigest(foreign) === claim.receipt.inheritedTeardownDigest && readBoundedRegularFileSync(claim.path, 4 * 1024).equals(claim.bytes) && Bun.deepEquals(readSyncRuntime(), runtime, true)) return "defer"; } catch { /* unreadable or replaced runtime evidence is not an active parent */ } return "refuse"; }