UNPKG

@bitkyc08/opencodex

Version:

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

190 lines (181 loc) • 7.81 kB
import { existsSync, readFileSync, statSync } from "node:fs"; import { readProcessStartMsBatch } from "./app-server-processes"; import type { CodexRoutingKind } from "./inject"; import { JOURNAL_PATH } from "./journal"; import { listCodexClientProcesses, type CodexClientProcessList, } from "./native-profile-processes"; export type RoutingAdoption = "not-applicable" | "adopted" | "pending-client-restart" | "unknown"; export interface RoutingAdoptionEvidence { adoption: RoutingAdoption; injectedAtMs: number | null; staleClients: Array<{ pid: number; startedAtMs: number }>; observedClients: number; } export interface CollectRoutingAdoptionOptions { routingKind: CodexRoutingKind; platform?: NodeJS.Platform; listClients?: () => CodexClientProcessList; readStartMsBatch?: (pids: readonly number[], platform: NodeJS.Platform) => Map<number, number | null>; injectedAtMs?: number | null; } /** * Infer whether running Codex clients had an opportunity to read the * injected opencodex-local route (#4550). * * "adopted" is not an observation of live traffic. It means every matched * running Codex client started after the route was written. That is the * inference the operator needed, and it is also the overclaim we must not * make. Known sources of a false adopted this evidence does not cover: * a client the matcher does not recognise; a restored or resumed thread * that keeps an already-open direct WebSocket even though the process * started after injection; OPENAI_BASE_URL / profile overrides in the * client's own environment; a start time in the SAME second as the * injection, which we deliberately treat as not stale; an empty match * set, which is vacuously adopted; a client running against a different * CODEX_HOME or config path than the journal we read; and Codex surfaces * the CLI predicate does not match at all, such as codex-code-mode-host, * Electron helpers, and VS Code extension hosts. Anything that cannot * be verified is "unknown", never a clean bill of health — matching the * #476 restart contract where enumeration failure means no verified * targets. */ export function deriveRoutingAdoption(inputs: { routingKind: CodexRoutingKind; injectedAtMs: number | null; clients: ReadonlyArray<{ pid: number; startedAtMs: number | null }>; enumerationFailed?: boolean; }): RoutingAdoptionEvidence { const observedClients = inputs.clients.length; if (inputs.routingKind !== "opencodex-local") { return { adoption: "not-applicable", injectedAtMs: null, staleClients: [], observedClients: 0 }; } if (inputs.enumerationFailed) { return { adoption: "unknown", injectedAtMs: inputs.injectedAtMs, staleClients: [], observedClients }; } if (inputs.injectedAtMs === null) { return { adoption: "unknown", injectedAtMs: null, staleClients: [], observedClients }; } const injectedAtMs = inputs.injectedAtMs; const staleClients: Array<{ pid: number; startedAtMs: number }> = []; let unreadableStart = false; for (const client of inputs.clients) { if (client.startedAtMs === null) { unreadableStart = true; continue; } if (startedBeforeInjection(client.startedAtMs, injectedAtMs)) { staleClients.push({ pid: client.pid, startedAtMs: client.startedAtMs }); } } staleClients.sort((left, right) => left.pid - right.pid); if (staleClients.length > 0) { return { adoption: "pending-client-restart", injectedAtMs, staleClients, observedClients }; } if (unreadableStart) { return { adoption: "unknown", injectedAtMs, staleClients: [], observedClients }; } return { adoption: "adopted", injectedAtMs, staleClients: [], observedClients }; } /** * ps lstart is second-granularity; app-server-processes.ts uses <= for catalog * staleness for the opposite reason (a rewrite in the same second may be unseen). * Here a start in the same wall-clock second as the injection cannot be proven * to predate it, so a rounding artifact must not produce a false pending-restart * warning (#4550). Truncate both sides to seconds; strictly earlier seconds are * stale. */ function startedBeforeInjection(startedAtMs: number, injectedAtMs: number): boolean { return Math.floor(startedAtMs / 1000) < Math.floor(injectedAtMs / 1000); } /** * Gather journal + process evidence for deriveRoutingAdoption. * * Injection time is the newer of the journal timestamp and JOURNAL_PATH mtime: * writeJournal records the native snapshot time and then no-ops, while * markJournalInjectedState rewrites the file (mtime moves) without touching * timestamp. The journal is parsed here instead of through readJournal, which * can delete a corrupt file; a status read must never mutate state. Ownership * matches journaledInjectedOpenaiBaseUrl plus journalOwner: we only bound a * route we recorded writing. */ export function collectRoutingAdoption(options: CollectRoutingAdoptionOptions): RoutingAdoptionEvidence { const { routingKind } = options; if (routingKind !== "opencodex-local") { return deriveRoutingAdoption({ routingKind, injectedAtMs: null, clients: [] }); } const injectedAtMs = options.injectedAtMs !== undefined ? options.injectedAtMs : readOwnedInjectionBoundMs(); let listed: CodexClientProcessList; try { listed = (options.listClients ?? (() => listCodexClientProcesses({ platform: options.platform })))(); } catch { listed = { status: "unavailable" }; } if (listed.status === "unavailable") { return deriveRoutingAdoption({ routingKind, injectedAtMs, clients: [], enumerationFailed: true, }); } const platform = options.platform ?? process.platform; const pids = listed.processes.map(proc => proc.pid); let starts: Map<number, number | null>; try { starts = pids.length === 0 ? new Map() : (options.readStartMsBatch ?? readProcessStartMsBatch)(pids, platform); } catch { starts = new Map(pids.map(pid => [pid, null])); } const clients = listed.processes.map(proc => ({ pid: proc.pid, startedAtMs: starts.get(proc.pid) ?? null, })); return deriveRoutingAdoption({ routingKind, injectedAtMs, clients }); } function readOwnedInjectionBoundMs(): number | null { try { if (!existsSync(JOURNAL_PATH)) return null; const journal = JSON.parse(readFileSync(JOURNAL_PATH, "utf-8")) as { version?: unknown; timestamp?: unknown; injectedOpenaiBaseUrl?: unknown; owner?: { kind?: unknown; pid?: unknown; apiKeyId?: unknown }; pid?: unknown; }; if (journal === null || typeof journal !== "object" || journal.version !== 1) return null; const injectedUrl = typeof journal.injectedOpenaiBaseUrl === "string" ? journal.injectedOpenaiBaseUrl : ""; if (!injectedUrl) return null; if (!journalHasOwner(journal)) return null; const recordedMs = typeof journal.timestamp === "string" ? Date.parse(journal.timestamp) : Number.NaN; let mtimeMs = Number.NaN; try { mtimeMs = statSync(JOURNAL_PATH).mtimeMs; } catch { mtimeMs = Number.NaN; } const bound = Math.max( Number.isFinite(recordedMs) ? recordedMs : Number.NEGATIVE_INFINITY, Number.isFinite(mtimeMs) ? mtimeMs : Number.NEGATIVE_INFINITY, ); return Number.isFinite(bound) ? bound : null; } catch { return null; } } function journalHasOwner(journal: { owner?: { kind?: unknown; pid?: unknown; apiKeyId?: unknown }; pid?: unknown; }): boolean { const owner = journal.owner; if (owner?.kind === "client" && typeof owner.apiKeyId === "string" && owner.apiKeyId) return true; if (owner?.kind === "process" && Number.isSafeInteger(owner.pid) && Number(owner.pid) > 0) return true; return Number.isSafeInteger(journal.pid) && Number(journal.pid) > 0; }