@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
148 lines (132 loc) • 6.24 kB
text/typescript
import { join } from "node:path";
import { getCodexAccountCredential } from "./account-store";
import { loadConfig } from "../config";
import { resolveCodexHomeDir } from "./home";
import { extractAccountId } from "../oauth/chatgpt";
import { isSelectableCodexPoolAccount, MAIN_CODEX_ACCOUNT_ID } from "./account-id";
import { codexPlanKey } from "./plan";
import { getObservedMainCodexCollisionIdentity, sameCodexCollisionIdentity, type CodexCollisionIdentity } from "./collision-identity";
import { readNativeMainAuthBytes } from "./native-main-auth-file";
export interface CodexTokens {
access_token: string;
account_id: string;
id_token?: string;
}
/**
* Why a read *outcome* and not just `Tokens | null`: callers need to tell a real sign-out apart
* from a transient read failure. A single null collapsed "file absent", "malformed JSON", and
* "read error" into one answer, so a half-written `auth.json` looked exactly like a logout and
* callers destroyed healthy cached account state because of it.
*/
export type CodexTokenReadResult =
| { status: "ok"; tokens: CodexTokens }
| { status: "missing" | "invalid" | "unreadable" };
function parseCodexTokens(raw: string): CodexTokenReadResult {
try {
const j = JSON.parse(raw) as {
tokens?: { access_token?: string; account_id?: string; id_token?: string };
};
if (!j?.tokens?.access_token) return { status: "invalid" };
return {
status: "ok",
tokens: {
access_token: j.tokens.access_token,
account_id: j.tokens.account_id ?? "",
id_token: j.tokens.id_token,
},
};
} catch {
return { status: "invalid" };
}
}
function hasErrnoCode(error: unknown, code: string): boolean {
return typeof error === "object" && error !== null && "code" in error
&& (error as { code?: unknown }).code === code;
}
/**
* Reads the Codex CLI credential file and classifies the outcome. Reads once instead of doing an
* `existsSync` pre-check, so a file replaced between check and read cannot be misread as absent.
* An already-owned lifecycle may supply its pinned auth path instead of resolving ambient home.
* `bounded` opts into the native-profile bounded reader (regular file, size-capped, no-follow,
* non-blocking) for startup observation paths that run inside the owner claim; bounded violations
* classify as `unreadable`. Legacy callers keep the unbounded read.
* Never returns or logs the raw error or any token material.
*/
export function readCodexTokensResult(
authPath = join(resolveCodexHomeDir(), "auth.json"),
options?: { bounded?: boolean },
): CodexTokenReadResult {
let raw: string;
try {
raw = readNativeMainAuthBytes(authPath, options?.bounded === true ? "bounded" : "plain").toString("utf-8");
} catch (error) {
return { status: hasErrnoCode(error, "ENOENT") ? "missing" : "unreadable" };
}
return parseCodexTokens(raw);
}
/**
* Compatibility wrapper: any usable-token check keeps the original null contract, which keeps
* request routing fail-closed. Only callers that must distinguish the failure reason should use
* `readCodexTokensResult()`.
*/
export function readCodexTokens(): CodexTokens | null {
const result = readCodexTokensResult();
return result.status === "ok" ? result.tokens : null;
}
export function getMainChatgptAccountId(): string | null {
const tokens = readCodexTokens();
if (!tokens) return null;
return extractAccountId(tokens.id_token, tokens.access_token) ?? (tokens.account_id || null);
}
function normalizedEmail(email: string | undefined | null): string | null {
const trimmed = email?.trim().toLowerCase();
return trimmed || null;
}
function isWorkspacePlan(plan: unknown): boolean {
const key = codexPlanKey(plan);
return !!key && /team|business|enterprise|workspace|edu/.test(key);
}
// Main login and pool accounts share the account id + email collision guard.
// Personal and workspace subscriptions remain separate buckets.
export function checkAccountIdCollision(
chatgptAccountId: string,
email?: string | null,
plan?: unknown,
excludeAccountId?: string | null,
main: CodexCollisionIdentity | null = getObservedMainCodexCollisionIdentity() ?? null,
): { collision: true; reason: string } | { collision: false } {
const candidateEmail = normalizedEmail(email);
const candidateWorkspace = isWorkspacePlan(plan);
if (excludeAccountId !== MAIN_CODEX_ACCOUNT_ID && main
&& sameCodexCollisionIdentity({ accountId: chatgptAccountId, email, plan }, main)) {
return { collision: true, reason: "Account is already configured as the native Codex main account." };
}
for (const account of loadConfig().codexAccounts ?? []) {
if (excludeAccountId && account.id === excludeAccountId) continue;
if (!isSelectableCodexPoolAccount(account)) continue;
if (isWorkspacePlan(account.plan) !== candidateWorkspace) continue;
const cred = getCodexAccountCredential(account.id);
const poolEmail = normalizedEmail(account.email);
if (cred && cred.chatgptAccountId === chatgptAccountId && (!candidateEmail || !poolEmail || poolEmail === candidateEmail)) {
return { collision: true, reason: `Account is already in the pool (${account.id}).` };
}
}
return { collision: false };
}
export type MainAuth = CodexTokenReadResult | { status: "api-key-only" };
/** A valid API-key login has no ChatGPT identity; anything else unreadable stays unknown. */
export function readMainAuth(authPath = join(resolveCodexHomeDir(), "auth.json")): MainAuth {
const main = readCodexTokensResult(authPath, { bounded: true });
if (main.status !== "invalid") return main;
try {
const j: unknown = JSON.parse(readNativeMainAuthBytes(authPath, "bounded").toString("utf-8"));
if (j === null || typeof j !== "object" || Array.isArray(j)) return main;
const envelope = j as { auth_mode?: unknown; OPENAI_API_KEY?: unknown; tokens?: unknown };
const apiKeyOnly = envelope.tokens == null
&& (envelope.auth_mode === undefined || envelope.auth_mode === "api_key")
&& typeof envelope.OPENAI_API_KEY === "string" && envelope.OPENAI_API_KEY.trim() !== "";
return apiKeyOnly ? { status: "api-key-only" } : main;
} catch {
return main;
}
}