@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
163 lines (149 loc) • 5.64 kB
text/typescript
/**
* Opt-in Codex affinity diagnostics for account-switch compatibility failures.
*
* The provider debug stream may compare values only within the current process. It never emits
* raw header values, credentials, account identifiers, or durable unsalted hashes.
*/
import { createHmac, randomBytes } from "node:crypto";
import { isDebugEnabled } from "../lib/debug-settings";
import { debugProviderDiagnostic } from "../lib/debug";
const MAX_TAGGED_VALUE_BYTES = 16 * 1024;
const RUN_KEY = randomBytes(32);
let nextSequence = 0;
const SAFE_AFFINITY_HEADERS = [
"openai-beta",
"originator",
"session_id",
"session-id",
"thread-id",
"x-client-request-id",
"x-codex-beta-features",
"x-codex-installation-id",
"x-codex-parent-thread-id",
"x-codex-turn-metadata",
"x-codex-turn-state",
"x-codex-window-id",
"x-openai-subagent",
"x-responsesapi-include-timing-metrics",
] as const;
const KNOWN_TURN_FIELDS = [
"forked_from_thread_id",
"parent_thread_id",
"request_kind",
"session_id",
"subagent_kind",
"thread_id",
] as const;
type SizeBucket = "0" | "1-31" | "32-127" | "128-511" | "512-2047" | "2048-16384" | "oversized";
export interface CodexAffinityValueTag {
name: string;
size: SizeBucket;
tag?: string;
}
export interface CodexAffinityJsonSummary {
shape: "absent" | "malformed" | "oversized" | "array" | "scalar" | "object";
knownFields?: Array<CodexAffinityValueTag & { kind: "string" | "number" | "boolean" | "null" | "array" | "object" }>;
unknownFieldCount?: number;
}
export interface CodexAffinityDiagnosticInput {
inboundHeaders: Headers;
outboundHeaders: HeadersInit;
authKind: "main" | "pool" | "main-pool";
accountMode: "direct" | "pool" | undefined;
fixedAccount: boolean;
credentialSubstituted: boolean;
accountGatedModel: boolean;
wireModelNormalized: boolean;
status: number;
}
function sizeBucket(bytes: number): SizeBucket {
if (bytes === 0) return "0";
if (bytes <= 31) return "1-31";
if (bytes <= 127) return "32-127";
if (bytes <= 511) return "128-511";
if (bytes <= 2047) return "512-2047";
if (bytes <= MAX_TAGGED_VALUE_BYTES) return "2048-16384";
return "oversized";
}
function valueTag(name: string, value: string): CodexAffinityValueTag {
const bytes = Buffer.byteLength(value, "utf8");
const size = sizeBucket(bytes);
if (size === "oversized") return { name, size };
const tag = createHmac("sha256", RUN_KEY)
.update(name)
.update("\0")
.update(value)
.digest("hex")
.slice(0, 12);
return { name, size, tag };
}
function headerTags(headers: Headers): CodexAffinityValueTag[] {
const rows: CodexAffinityValueTag[] = [];
for (const name of SAFE_AFFINITY_HEADERS) {
const value = headers.get(name);
if (value !== null) rows.push(valueTag(name, value));
}
return rows;
}
function jsonSummary(headers: Headers, name: "x-codex-turn-metadata" | "x-codex-turn-state"): CodexAffinityJsonSummary {
const raw = headers.get(name);
if (raw === null) return { shape: "absent" };
if (Buffer.byteLength(raw, "utf8") > MAX_TAGGED_VALUE_BYTES) return { shape: "oversized" };
let parsed: unknown;
try {
parsed = JSON.parse(raw) as unknown;
} catch {
return { shape: "malformed" };
}
if (Array.isArray(parsed)) return { shape: "array" };
if (!parsed || typeof parsed !== "object") return { shape: "scalar" };
const record = parsed as Record<string, unknown>;
const knownFields: NonNullable<CodexAffinityJsonSummary["knownFields"]> = [];
for (const field of KNOWN_TURN_FIELDS) {
if (!Object.hasOwn(record, field)) continue;
const value = record[field];
if (value === null) {
knownFields.push({ name: field, kind: "null", size: "0" });
} else {
const scalarKind = typeof value;
if (scalarKind === "string" || scalarKind === "number" || scalarKind === "boolean") {
knownFields.push({ ...valueTag(`${name}.${field}`, String(value)), name: field, kind: scalarKind });
continue;
}
knownFields.push({ name: field, kind: Array.isArray(value) ? "array" : "object", size: "0" });
}
}
const known = new Set<string>(KNOWN_TURN_FIELDS);
const unknownFieldCount = Object.keys(record).filter(key => !known.has(key)).length;
return {
shape: "object",
...(knownFields.length > 0 ? { knownFields } : {}),
...(unknownFieldCount > 0 ? { unknownFieldCount } : {}),
};
}
/** Emit one observation-only, privacy-bounded provider-debug record. */
export function captureCodexAffinityDiagnostic(input: CodexAffinityDiagnosticInput): void {
if (!isDebugEnabled()) return;
try {
const outbound = new Headers(input.outboundHeaders);
debugProviderDiagnostic("codex", "affinity", {
sequence: ++nextSequence,
authKind: input.authKind,
accountMode: input.accountMode ?? "unset",
fixedAccount: input.fixedAccount,
credentialSubstituted: input.credentialSubstituted,
accountGatedModel: input.accountGatedModel,
wireModelNormalized: input.wireModelNormalized,
status: input.status,
inbound: headerTags(input.inboundHeaders),
outbound: headerTags(outbound),
inboundTurnMetadata: jsonSummary(input.inboundHeaders, "x-codex-turn-metadata"),
outboundTurnMetadata: jsonSummary(outbound, "x-codex-turn-metadata"),
inboundTurnState: jsonSummary(input.inboundHeaders, "x-codex-turn-state"),
outboundTurnState: jsonSummary(outbound, "x-codex-turn-state"),
});
} catch {
// Diagnostics must never affect request handling.
}
}
export const CODEX_AFFINITY_DEBUG_SAFE_HEADERS = SAFE_AFFINITY_HEADERS;