@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
100 lines (95 loc) • 4.7 kB
text/typescript
import { lstatSync } from "node:fs";
import { isLinkConnection } from "../client/state";
import { markSiblingStart } from "../codex/sibling-start";
import { isMissingPathError } from "../config/atomic-write";
import { getPidPath, getRuntimePortPath } from "../config/process-state";
import { acquireOwnershipMutationLease } from "../service/ownership-mutation-lease.mjs";
import { serviceChildOwnershipDecisionForClassifiedChild, type ServiceChildOwnershipDecision } from "../service/service-child-ownership";
import { serviceStatePaths } from "../service/state";
import { serviceStayOutExitCode } from "../service/windows-wrapper-exit";
import { observeProxyLiveness, START_OWNERSHIP_LIVENESS } from "../server/proxy-liveness";
import type { OcxClientConnectionConfig } from "../types";
import { findCrossHomeOwner, markCrossHomeSibling } from "./cross-home-owner";
function ownershipRecordIsAbsent(path: string): boolean {
try { lstatSync(path); return false; }
catch (error) { return isMissingPathError(error); }
}
/** Called under the publication lease, before the client can bind or write ownership records. */
async function recheckClientStartOwnership(sibling: boolean, requestedPort?: number): Promise<number | null> {
const fenced = await observeProxyLiveness(START_OWNERSHIP_LIVENESS);
if (fenced.kind === "live") {
const { pid, port } = fenced.live;
if (process.env.OCX_SERVICE === "1") {
console.log(`Proxy already running (PID ${pid ?? "unknown"}, port ${port}); service wrapper staying out of the way.`);
return serviceStayOutExitCode();
}
// A config-port hit can be foreign even when this home has no owner. Only the
// explicit sibling path may disregard it, and only with fresh cross-home proof.
if (sibling && requestedPort !== undefined && requestedPort !== port && fenced.live.source === "config"
&& await findCrossHomeOwner({ listener: fenced.live }) === port
&& ownershipRecordIsAbsent(getPidPath()) && ownershipRecordIsAbsent(getRuntimePortPath())) {
markSiblingStart(port);
return null;
}
console.error(`⚠️ Proxy appeared before bind (PID ${pid ?? "unknown"}, port ${port}). Use 'ocx stop' first.`);
return 1;
}
if (fenced.kind === "unknown") throw new Error("Proxy ownership is unverified; client startup refused before bind.");
if (!sibling) await markCrossHomeSibling();
return null;
}
/**
* Connected-client starts publish PID and runtime records too, so a supervised service child
* must not reach them past a foreign owner any more than the server path may. The server path
* rechecks inside `bindAndPublishStartOwnership`; this is the same fence for
* `startClientRuntime`, which binds, publishes and then blocks for the process lifetime.
*
* The lease is held from acquisition until the runtime reports its records published (or the
* start fails), and the ownership decision is re-read under it before anything binds. A refusal
* releases the lease and hands the refusal to `stayOut`, which exits.
*/
export async function startClientRuntimeUnderOwnershipLease(deps: {
acquireLease: () => { release(): void };
decide: () => ServiceChildOwnershipDecision;
stayOut: (refusal: string) => never;
start: (afterPublish: () => void) => Promise<void>;
}): Promise<void> {
const lease = deps.acquireLease();
let released = false;
const release = () => {
if (released) return;
released = true;
lease.release();
};
try {
const decision = deps.decide();
if (decision.kind === "stay-out") {
release();
deps.stayOut(decision.refusal);
}
await deps.start(release);
} finally {
release();
}
}
export async function startConnectedClientWithOwnershipFence({
connection, siblingStart, supervisedServiceChild, requestedPort, block,
}: {
connection: OcxClientConnectionConfig;
siblingStart: boolean;
supervisedServiceChild: boolean;
requestedPort?: number;
block?: boolean;
}): Promise<void> {
const { startClientRuntime } = await import("../client/runtime");
await startClientRuntimeUnderOwnershipLease({
acquireLease: () => acquireOwnershipMutationLease(serviceStatePaths()),
decide: () => serviceChildOwnershipDecisionForClassifiedChild(supervisedServiceChild),
stayOut: refusal => { console.error("❌ " + refusal); process.exit(serviceStayOutExitCode()); },
start: async afterPublish => {
const refusal = await recheckClientStartOwnership(siblingStart, isLinkConnection(connection) ? undefined : requestedPort);
if (refusal !== null) { process.exitCode = refusal; return; }
await startClientRuntime({ port: requestedPort, block, afterPublish });
},
});
}