@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
54 lines (48 loc) • 2.7 kB
text/typescript
/**
* Process-local internal-call capability.
*
* Some requests ARE the proxy itself talking to its own data plane: the advisor sidecar's
* loopback consultation is the first user. Such a request must be recognized as INTERNAL without
* trusting anything the client controls. A client-supplied header value is not evidence — any
* external caller can send it — and neither is the peer address: a public listener reached
* through Docker, WSL, a tunnel, or port forwarding can present as loopback on the last hop, as
* the local-management attestation notes.
*
* The authority is therefore process-owned: a 256-bit random value minted once per process, kept
* in memory only. It is never written to config or disk, never logged, never returned by the
* management API, never placed in usage or request metadata, and never forwarded upstream. A new
* process mints a new value, so a token captured from an older process is worthless. Comparison
* is timing-safe and shape-checked, reusing the same secret shape as the local attestation
* module.
*
* Local Chat helpers also pair this capability with a request-lifetime registration.
*/
import { randomBytes, timingSafeEqual } from "node:crypto";
import { isLocalAttestationSecret } from "./local-management-attestation";
/** Header an internal sidecar presents on its own loopback request. */
export const ADVISOR_INTERNAL_CAPABILITY_HEADER = "x-opencodex-advisor-internal";
let processCapability: string | null = null;
/**
* The current process's internal-call capability. Minted lazily on first use (one random draw,
* no I/O), so an install that never enables the advisor never generates one.
*/
export function internalCallCapability(): string {
if (processCapability === null) processCapability = randomBytes(32).toString("base64url");
return processCapability;
}
/** Test seam: install a deterministic value, or `null` to force a fresh mint. */
export function setInternalCallCapabilityForTests(value: string | null): void {
processCapability = value;
}
/**
* True only when the supplied header value IS this process's capability. Shape-checked first so
* a malformed value cannot reach the comparison, then compared in constant time.
*/
export function isInternalCallCapability(supplied: string | null | undefined): boolean {
if (typeof supplied !== "string" || !isLocalAttestationSecret(supplied)) return false;
if (processCapability === null) return false;
const expected = processCapability;
const suppliedBytes = Buffer.from(supplied);
const expectedBytes = Buffer.from(expected);
return suppliedBytes.length === expectedBytes.length && timingSafeEqual(suppliedBytes, expectedBytes);
}