@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
192 lines (184 loc) • 7.96 kB
text/typescript
import { readRuntimePort, type RuntimePortState } from "../config/process-state";
import { timingSafeEqual } from "node:crypto";
import { createGuiPairIntent, GUI_PAIR_INTENT_HEADER, type GuiPairIntent } from "../lib/gui-pair-intent";
import {
LOCAL_ATTESTATION_CHALLENGE_HEADER,
LOCAL_ATTESTATION_PROOF_HEADER,
createLocalAttestationChallenge,
verifyLocalAttestationProof,
} from "../lib/local-management-attestation";
import {
GUI_PAIR_BROWSER_ORIGIN_HEADER,
GUI_PAIR_CAPABILITY_HEADER,
GUI_PAIR_CAPABILITY_TTL_MS,
GUI_PAIR_CAPABILITY_VERSION,
GUI_PAIR_EXPECTED_PID_HEADER,
GUI_PAIR_EXPIRES_AT_HEADER,
GUI_PAIR_METHOD,
GUI_PAIR_NONCE_HEADER,
GUI_PAIR_PATH,
DESKTOP_GUI_PAIR_PATH,
canonicalGuiBrowserOrigin,
canonicalHttpOrigin,
createGuiPairCapability,
} from "../lib/gui-pair-capability";
import { directLocalHttpFetch } from "../server/direct-local-http";
import {
isOpencodexHealthz,
probeHostname,
type HealthzIdentity,
type LiveProxy,
} from "../server/proxy-liveness";
export type GuiPairRequestResult =
| { kind: "created"; grant: string; browserOrigin: string; serverOrigin: string; expiresAt: number }
| { kind: "unavailable"; reason: "unattested-target" | "runtime-mismatch" | "attestation" | "capability" | "transport" | "rejected" | "local-intent" | "origin-refused" | "rate-limited" };
export interface GuiPairClientDeps {
desktopPurpose?: boolean;
fetchImpl?: typeof fetch;
readRuntime?: (pid: number) => RuntimePortState | null;
createChallenge?: () => string;
now?: () => number;
timeoutMs?: number;
/** Hub invitation policy is unchanged; standalone commands require local write intent. */
requireLocalIntent?: boolean;
createIntent?: typeof createGuiPairIntent;
}
const GUI_PAIR_REQUEST_TIMEOUT_MS = 10_000;
function sameRuntime(left: RuntimePortState, right: RuntimePortState | null): boolean {
const leftSecret = Buffer.from(left.attestationSecret ?? "");
const rightSecret = Buffer.from(right?.attestationSecret ?? "");
return !!right?.attestationSecret
&& right.pid === left.pid
&& right.port === left.port
&& right.hostname === left.hostname
&& leftSecret.length === rightSecret.length
&& timingSafeEqual(leftSecret, rightSecret);
}
/**
* Which refusal the grant route sent, as one fixed word; the body itself never surfaces.
*
* Only the route's plain 403 "GUI pairing grant refused" (no `code`) means its loaded config did not
* admit this origin, the one case an allow-list edit or a restart can cure (#8319). Its 429 is the
* per-minute grant limit. A coded refusal, a capability refusal and anything else stay `rejected`,
* so the caller does not send an operator to edit a correct allow-list (#8495 review).
*
* This is a heuristic: the route answers the same uncoded 403 for any unexpected failure inside
* grant creation, not only for a refused origin. Those are rare and the advice (check the two origin
* settings, restart) is harmless there; an explicit server code would make it exact.
*/
async function refusalReason(response: Response): Promise<"origin-refused" | "rate-limited" | "rejected"> {
if (response.status === 429) return "rate-limited";
if (response.status !== 403) return "rejected";
const body: unknown = await response.json().catch(() => null);
if (!body || typeof body !== "object" || Array.isArray(body)) return "rejected";
const record = body as Record<string, unknown>;
return record.error === "GUI pairing grant refused" && record.code === undefined ? "origin-refused" : "rejected";
}
function parseCreatedResult(value: unknown, browserOrigin: string): GuiPairRequestResult | null {
if (!value || typeof value !== "object" || Array.isArray(value)) return null;
const record = value as Record<string, unknown>;
if (
typeof record.grant !== "string"
|| !/^ocx_pair_[A-Za-z0-9_-]{43}$/.test(record.grant)
|| canonicalGuiBrowserOrigin(record.browserOrigin) !== browserOrigin
|| typeof record.expiresAt !== "number"
|| !Number.isSafeInteger(record.expiresAt)
) return null;
const serverOrigin = canonicalHttpOrigin(record.serverOrigin);
if (!serverOrigin) return null;
return {
kind: "created",
grant: record.grant,
browserOrigin,
serverOrigin,
expiresAt: record.expiresAt,
};
}
export async function requestBoundGuiPairingGrant(
target: LiveProxy,
browserOrigin: string,
deps: GuiPairClientDeps = {},
): Promise<GuiPairRequestResult> {
if (target.source !== "runtime" || target.pid === null || target.pid <= 0) {
return { kind: "unavailable", reason: "unattested-target" };
}
const canonicalOrigin = canonicalGuiBrowserOrigin(browserOrigin);
if (!canonicalOrigin || canonicalOrigin !== browserOrigin) {
return { kind: "unavailable", reason: "capability" };
}
const readRuntime = deps.readRuntime ?? readRuntimePort;
const runtime = readRuntime(target.pid);
if (!runtime?.attestationSecret || runtime.pid !== target.pid || runtime.port !== target.port) {
return { kind: "unavailable", reason: "runtime-mismatch" };
}
const fetchImpl = deps.fetchImpl ?? directLocalHttpFetch;
const timeoutMs = deps.timeoutMs ?? GUI_PAIR_REQUEST_TIMEOUT_MS;
const challenge = (deps.createChallenge ?? createLocalAttestationChallenge)();
const baseUrl = `http://${probeHostname(target.hostname)}:${target.port}`;
let proofResponse: Response;
try {
proofResponse = await fetchImpl(`${baseUrl}/healthz`, {
headers: { [LOCAL_ATTESTATION_CHALLENGE_HEADER]: challenge },
signal: AbortSignal.timeout(timeoutMs),
});
} catch {
return { kind: "unavailable", reason: "transport" };
}
const body = await proofResponse.json().catch(() => null) as HealthzIdentity | null;
if (
!proofResponse.ok
|| !isOpencodexHealthz(body)
|| body?.pid !== target.pid
|| body?.port !== target.port
|| !verifyLocalAttestationProof(
runtime.attestationSecret,
challenge,
target.pid,
target.port,
proofResponse.headers.get(LOCAL_ATTESTATION_PROOF_HEADER),
)
) return { kind: "unavailable", reason: "attestation" };
if (body.guiPairCapability !== GUI_PAIR_CAPABILITY_VERSION) {
return { kind: "unavailable", reason: "capability" };
}
if (!sameRuntime(runtime, readRuntime(target.pid))) {
return { kind: "unavailable", reason: "runtime-mismatch" };
}
const expiresAt = (deps.now ?? Date.now)() + GUI_PAIR_CAPABILITY_TTL_MS;
const path = deps.desktopPurpose ? DESKTOP_GUI_PAIR_PATH : GUI_PAIR_PATH;
const capability = createGuiPairCapability(
runtime.attestationSecret,
challenge,
GUI_PAIR_METHOD,
path,
browserOrigin,
target.pid,
target.port,
expiresAt,
);
if (!capability) return { kind: "unavailable", reason: "capability" };
let intent: GuiPairIntent | undefined;
try {
if (deps.desktopPurpose || deps.requireLocalIntent !== false) intent = (deps.createIntent ?? createGuiPairIntent)(capability);
} catch { return { kind: "unavailable", reason: "local-intent" }; }
try {
const response = await fetchImpl(`${baseUrl}${path}`, {
method: GUI_PAIR_METHOD,
headers: {
"Content-Length": "0",
[GUI_PAIR_EXPECTED_PID_HEADER]: String(target.pid),
[GUI_PAIR_NONCE_HEADER]: challenge,
[GUI_PAIR_EXPIRES_AT_HEADER]: String(expiresAt),
[GUI_PAIR_BROWSER_ORIGIN_HEADER]: browserOrigin,
[GUI_PAIR_CAPABILITY_HEADER]: capability,
...(intent ? { [GUI_PAIR_INTENT_HEADER]: intent.proof } : {}),
},
signal: AbortSignal.timeout(timeoutMs),
});
if (!response.ok) return { kind: "unavailable", reason: await refusalReason(response) };
const result = parseCreatedResult(await response.json().catch(() => null), browserOrigin);
return result ?? { kind: "unavailable", reason: "rejected" };
} catch {
return { kind: "unavailable", reason: "transport" };
} finally { intent?.dispose(); }
}