@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
202 lines (185 loc) • 9.69 kB
text/typescript
import { createHmac, randomBytes } from "node:crypto";
import type { CodexAuthContext } from "./auth-context";
import { MAIN_CODEX_ACCOUNT_ID } from "./account-id";
import { nativeUserIdClaims } from "./reserve-availability";
export type ContextSessionOwner = Readonly<
| { kind: "stored"; accountId: string; physicalIdentity: string; userIdentity?: string;
callerCredentialIdentity: string; ambiguous: boolean }
| { kind: "caller"; physicalIdentity?: string; userIdentity?: string;
callerCredentialIdentity: string; ambiguous: boolean }
>;
const TTL_MS = 24 * 60 * 60_000;
const MAX_ENTRIES = 2048;
const MAX_BYTES = 1024 * 1024;
const salt = randomBytes(32);
type Entry = { owner: ContextSessionOwner; destination: string; touchedAt: number; bytes: number };
const owners = new Map<string, Entry>();
let totalBytes = 0;
function digest(domain: string, value: string): string {
return createHmac("sha256", salt).update(domain).update("\0").update(value).digest("hex");
}
function validId(value: string | null | undefined): value is string {
return typeof value === "string" && /^[A-Za-z0-9._:-]{1,512}$/.test(value);
}
function destinationIdentity(destination: string): string | undefined {
if (!destination || destination.length > 4096) return undefined;
try {
const url = new URL(destination);
if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash) return undefined;
return digest("destination", url.href.replace(/\/+$/, ""));
} catch { return undefined; }
}
function physicalIdentity(headers: Headers): string | undefined {
const account = headers.get("chatgpt-account-id");
return validId(account) ? digest("physical-account", account) : undefined;
}
/**
* The stable person behind an accepted credential, when the token says so.
*
* `chatgpt-account-id` names a WORKSPACE, and two people in one workspace send the same value.
* Ownership therefore also binds the user claim carried by the credential that upstream actually
* accepted. The claim is read without signature verification, which is why upstream acceptance
* remains the evidence and a conflicting pair of claims fails closed instead of picking one.
*/
function stableUserIdentity(headers: Headers): { identity?: string; conflict: boolean } {
const authorization = headers.get("authorization");
if (!authorization || authorization.length > 32_768 || !/^Bearer [^\s]+$/i.test(authorization)) {
return { conflict: false };
}
const claims = nativeUserIdClaims(authorization.slice(7));
if (claims.conflict) return { conflict: true };
return { ...(claims.userId ? { identity: digest("native-user", claims.userId) } : {}), conflict: false };
}
function callerCredentialIdentity(headers: Headers): string | undefined {
const authorization = headers.get("authorization");
if (!authorization || authorization.length > 32_768 || !/^Bearer [^\s]+$/i.test(authorization)) return undefined;
const account = headers.get("chatgpt-account-id");
if (account !== null && !validId(account)) return undefined;
return digest("caller-credential", JSON.stringify([authorization.slice(7), account]));
}
/**
* Whether two accepted observations describe the same owner.
*
* A proven stable user may present a refreshed credential. Without that proof on BOTH sides the
* only continuity evidence left is the credential itself, because a workspace id is shared by
* everyone in the organization and would otherwise let one member rebind another session.
*/
function sameOwnerIdentity(prior: ContextSessionOwner, next: ContextSessionOwner): boolean {
if (prior.kind !== next.kind) return false;
if (prior.physicalIdentity !== next.physicalIdentity) return false;
return prior.userIdentity !== undefined && next.userIdentity !== undefined
? prior.userIdentity === next.userIdentity
: prior.callerCredentialIdentity === next.callerCredentialIdentity;
}
function remove(key: string): void {
const prior = owners.get(key);
if (!prior) return;
owners.delete(key);
totalBytes -= prior.bytes;
}
function sweep(now: number): void {
for (const [key, entry] of owners) {
if (now < entry.touchedAt || now - entry.touchedAt >= TTL_MS) remove(key);
}
}
/** Called only after a model attempt was accepted by its actual destination. */
export function recordContextSessionOwner(
principalId: string | undefined, inboundHeaders: Headers, destination: string, auth: CodexAuthContext,
outboundHeaders: Headers, substituteMainCredential: boolean, now = Date.now(),
): void {
// Ownership is partitioned per admission principal. Without one there is no caller identity to
// own anything, so nothing is recorded rather than creating an entry any local process matches.
if (!principalId || !Number.isFinite(now)) return;
// A malformed explicit parent must not fall back to an unrelated local session.
const root = inboundHeaders.get("x-codex-parent-thread-id") ?? inboundHeaders.get("session-id");
if (!validId(root)) return;
const destinationKey = destinationIdentity(destination);
const credential = callerCredentialIdentity(outboundHeaders);
if (!destinationKey || !credential) return;
const physical = physicalIdentity(outboundHeaders);
const user = stableUserIdentity(outboundHeaders);
if (user.conflict) {
// An accepted credential naming two different users is evidence of nobody. Whatever entry
// this session already had stops being trustworthy at that moment.
markContextSessionAmbiguous(principalId, root, now);
return;
}
let owner: ContextSessionOwner;
if (auth.kind !== "main" || substituteMainCredential) {
if (!physical) return;
if (auth.kind !== "main" && (!validId(auth.accountId)
|| auth.chatgptAccountId !== outboundHeaders.get("chatgpt-account-id"))) return;
// Direct proxy-bearer substitution has no token snapshot in its `main` context;
// its accepted outbound identity is still evidence for the stored main slot.
owner = { kind: "stored", accountId: auth.kind === "main" ? MAIN_CODEX_ACCOUNT_ID : auth.accountId,
physicalIdentity: physical, ...(user.identity ? { userIdentity: user.identity } : {}),
callerCredentialIdentity: credential, ambiguous: false };
} else {
owner = { kind: "caller", ...(physical ? { physicalIdentity: physical } : {}),
...(user.identity ? { userIdentity: user.identity } : {}),
callerCredentialIdentity: credential, ambiguous: false };
}
sweep(now);
const key = digest("root-session", `${principalId}\u0000${root}`);
const prior = owners.get(key);
if (prior) {
// Same workspace, different person is exactly the case a workspace id cannot see, and a
// credential proving nobody must not inherit an entry just by sharing that id.
if (prior.owner.ambiguous || prior.destination !== destinationKey
|| !sameOwnerIdentity(prior.owner, owner)) {
owner = { ...prior.owner, ambiguous: true };
}
}
const ownerDestination = prior?.destination ?? destinationKey;
const bytes = Buffer.byteLength(JSON.stringify([key, ownerDestination, owner]), "utf8");
remove(key);
owners.set(key, { owner: Object.freeze(owner), destination: ownerDestination, touchedAt: now, bytes });
totalBytes += bytes;
while (owners.size > MAX_ENTRIES || totalBytes > MAX_BYTES) {
const oldest = owners.keys().next().value;
if (oldest === undefined) break;
remove(oldest);
}
}
/** Missing/expired/evicted ownership is unknown; never infer it from active routing. */
export function getContextSessionOwner(
principalId: string | undefined, sessionId: string, destination: string, now = Date.now(),
): ContextSessionOwner | undefined {
if (!principalId || !validId(sessionId) || !Number.isFinite(now)) return undefined;
const destinationKey = destinationIdentity(destination);
if (!destinationKey) return undefined;
sweep(now);
const key = digest("root-session", `${principalId}\u0000${sessionId}`);
const entry = owners.get(key);
if (!entry || entry.destination !== destinationKey) return undefined;
owners.delete(key);
entry.touchedAt = now;
owners.set(key, entry);
return entry.owner;
}
/** Compare only already-materialized headers; this function never reads credentials. */
export function contextSessionOwnerMatches(owner: ContextSessionOwner, headers: Headers): boolean {
if (owner.ambiguous) return false;
const user = stableUserIdentity(headers);
if (user.conflict) return false;
if (owner.physicalIdentity !== physicalIdentity(headers)) return false;
if (owner.userIdentity !== user.identity) return false;
// A stored credential was minted by this proxy for the account it selected, so a proven user
// may present a refreshed token. A caller-supplied bearer is not ours: it becomes this
// session credential only when a model turn was accepted with it, so history has to present
// exactly that credential rather than any token carrying the same claims.
return owner.kind === "stored" && owner.userIdentity !== undefined
? true
: owner.callerCredentialIdentity === callerCredentialIdentity(headers);
}
/** Poison an entry whose accepted evidence stopped being coherent. */
function markContextSessionAmbiguous(principalId: string, root: string | null, now: number): void {
if (!validId(root)) return;
const key = digest("root-session", principalId + "\u0000" + root);
const prior = owners.get(key);
if (!prior || prior.owner.ambiguous) return;
owners.set(key, { ...prior, owner: Object.freeze({ ...prior.owner, ambiguous: true }), touchedAt: now });
}
export function clearContextSessionOwnersForTests(): void {
owners.clear(); totalBytes = 0;
}