@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
495 lines (463 loc) • 20.7 kB
text/typescript
import { createHash } from "node:crypto";
import { readFileSync, statSync } from "node:fs";
import { join } from "node:path";
import { readCodexTokens } from "./auth-collision";
import {
decodeJwtPayload,
extractAccountId,
refreshChatGPTToken,
} from "../oauth/chatgpt";
import type { OAuthCredentials } from "../oauth/types";
import { extractChatgptPlanType } from "./plan";
import { MAIN_CODEX_ACCOUNT_ID } from "./account-id";
import {
refreshGrantFingerprintForToken,
withCodexRefreshFileLock,
} from "./account-store";
import { atomicWriteFile, resolveWriteTarget } from "../config/atomic-write";
import { resolveCodexHomeDir } from "./home";
import { assertNotRealCodexHomeUnderTest } from "../lib/test-home-guard";
import { clearAccountNeedsReauth } from "./account-runtime-state";
import { advanceCodexCredentialMutationEpoch } from "./credential-mutation-epoch";
import { withNativeMainExclusiveClaim } from "./native-main-claim";
import { resolveNativeProfileContext } from "./native-profile-store";
import { isNativeMainTrafficBlocked } from "./native-profile-startup";
export { MAIN_CODEX_ACCOUNT_ID } from "./account-id";
/**
* Main account plan (e.g. "plus", "go", "free", "team"), populated from the WHAM usage
* fetch. Used by the rotation usage-score so go/free main accounts score on monthly
* percent, matching pool-account behavior.
*/
let mainAccountPlan: string | null = null;
let jwtPlanAttempted = false;
const MAIN_TOKEN_REFRESH_SKEW_MS = 60_000;
let beforeMainAuthJsonRenameForTests: (() => void) | null = null;
type MainAuthJsonCredential = {
path: string;
rawSha256: string;
/**
* Filesystem identity of the file the hash was taken from (#2999).
*
* A content hash cannot tell "unchanged" from "replaced with a file that happens to
* hash the same", and more importantly it is read at a different instant than the
* rename. Carrying dev+ino lets the pre-rename guard ask the sharper question: is this
* still the same file, not merely one with the same bytes. `null` when the target could
* not be stat'ed, which is treated as "cannot prove identity" rather than "matches".
*/
identity: { dev: number; ino: number } | null;
root: Record<string, unknown>;
tokens: Record<string, unknown>;
accessToken?: string;
refreshToken?: string;
chatgptAccountId: string;
};
export interface NativeMainRefreshDependencies {
refreshToken?: (refreshToken: string, options: { signal: AbortSignal }) => Promise<OAuthCredentials>;
signal?: AbortSignal;
/** Metadata-only refresh must not retract a concurrent traffic reauth quarantine. */
preserveReauth?: boolean;
}
export class MainAuthJsonChangedDuringRefreshError extends Error {
constructor() {
super("Codex auth.json changed while its token was refreshing");
this.name = "MainAuthJsonChangedDuringRefreshError";
}
}
export class MainAccountTokenRefreshError extends Error {
constructor(readonly reason: "reauth" | "transient", options?: ErrorOptions) {
super(reason === "reauth"
? "Codex main account needs reauthentication"
: "Codex main token refresh did not complete", options);
this.name = "MainAccountTokenRefreshError";
}
}
function nonEmptyString(value: unknown): string | undefined {
return typeof value === "string" && value.trim() ? value : undefined;
}
function sha256(value: string): string {
return createHash("sha256").update(value).digest("hex");
}
/**
* Filesystem identity of a path, or null when it cannot be read.
*
* Null is deliberately NOT "matches anything": a caller that cannot prove identity must
* fail closed, because the whole point here is refusing to overwrite a file we can no
* longer vouch for.
*/
function statIdentity(path: string): { dev: number; ino: number } | null {
try {
const stat = statSync(path);
return { dev: Number(stat.dev), ino: Number(stat.ino) };
} catch {
return null;
}
}
function readMainAuthJsonCredential(): MainAuthJsonCredential | null {
const path = resolveWriteTarget(join(resolveCodexHomeDir(), "auth.json"));
let raw: string;
try {
raw = readFileSync(path, "utf8");
} catch {
return null;
}
try {
const parsed = JSON.parse(raw) as unknown;
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
const root = parsed as Record<string, unknown>;
const tokenValue = root.tokens;
if (!tokenValue || typeof tokenValue !== "object" || Array.isArray(tokenValue)) return null;
const tokens = tokenValue as Record<string, unknown>;
const accessToken = nonEmptyString(tokens.access_token);
const refreshToken = nonEmptyString(tokens.refresh_token);
if (!accessToken && !refreshToken) return null;
const idToken = nonEmptyString(tokens.id_token);
const chatgptAccountId = extractAccountId(idToken, accessToken)
?? nonEmptyString(tokens.account_id)
?? "";
return {
path,
rawSha256: sha256(raw),
identity: statIdentity(path),
root,
tokens,
...(accessToken ? { accessToken } : {}),
...(refreshToken ? { refreshToken } : {}),
chatgptAccountId,
};
} catch {
return null;
}
}
function mainAccessTokenFresh(accessToken: string | undefined, now: number, skewMs: number): boolean {
if (!accessToken) return false;
const payload = decodeJwtPayload(accessToken);
const exp = typeof payload?.exp === "number" ? payload.exp * 1000 : undefined;
return exp === undefined || exp > now + skewMs;
}
/** A refresh grant makes native main routeable even when the current access token is expired. */
export function isMainAccountCredentialUsable(now = Date.now()): boolean {
const current = readMainAuthJsonCredential();
return !!current?.refreshToken || mainAccessTokenFresh(current?.accessToken, now, 0);
}
export function hasMainAccountRefreshGrant(): boolean {
return !!readMainAuthJsonCredential()?.refreshToken;
}
function assertMainAuthJsonSnapshotUnchanged(expected: MainAuthJsonCredential): void {
const current = readMainAuthJsonCredential();
if (!current || current.path !== expected.path || current.rawSha256 !== expected.rawSha256) {
throw new MainAuthJsonChangedDuringRefreshError();
}
// Identity, not just content (#2999). A writer can land between this check and the
// rename, and rename(2) replaces unconditionally - so the narrower the question asked
// here, the smaller the window where a Codex login gets silently overwritten. An
// unreadable identity on either side fails closed: unprovable is not the same as equal.
assertMainAuthJsonIdentityUnchanged(expected);
}
function assertMainAuthJsonIdentityUnchanged(expected: MainAuthJsonCredential): void {
const identity = statIdentity(expected.path);
if (!identity
|| !expected.identity
|| identity.dev !== expected.identity.dev
|| identity.ino !== expected.identity.ino) {
throw new MainAuthJsonChangedDuringRefreshError();
}
}
function persistRefreshedMainAuthJson(
expected: MainAuthJsonCredential,
refreshed: OAuthCredentials,
): { accessToken: string; chatgptAccountId: string } {
assertNotRealCodexHomeUnderTest(resolveCodexHomeDir());
const accessToken = refreshed.access;
const refreshToken = refreshed.refresh || expected.refreshToken!;
const chatgptAccountId = refreshed.accountId
?? extractAccountId(undefined, accessToken)
?? expected.chatgptAccountId;
const tokens = {
...expected.tokens,
access_token: accessToken,
refresh_token: refreshToken,
account_id: chatgptAccountId,
};
atomicWriteFile(
expected.path,
JSON.stringify({ ...expected.root, tokens }, null, 2) + "\n",
undefined,
{
beforeRename: () => {
assertMainAuthJsonSnapshotUnchanged(expected);
const hook = beforeMainAuthJsonRenameForTests;
beforeMainAuthJsonRenameForTests = null;
hook?.();
},
// Runs immediately before rename(2), after the test hook has had its chance to
// simulate an external writer. Full snapshot check (content AND identity): this is
// the last look we get, so it asks everything it can rather than the cheap question.
validateBeforeRename: () => assertMainAuthJsonSnapshotUnchanged(expected),
},
);
advanceCodexCredentialMutationEpoch();
return { accessToken, chatgptAccountId };
}
export function setMainAuthJsonBeforeRenameHookForTests(hook: (() => void) | null): void {
beforeMainAuthJsonRenameForTests = hook;
}
/** Complete token set a native device reauth commits into the main slot (#3898). */
export interface NativeMainReauthTokens {
accessToken: string;
refreshToken: string;
idToken: string;
chatgptAccountId: string;
}
export class NativeMainReauthUnavailableError extends Error {
constructor(message = "Native main credential cannot be reauthenticated in this state") {
super(message);
this.name = "NativeMainReauthUnavailableError";
}
}
export class NativeMainReauthIdentityMismatchError extends Error {
constructor() {
super("Device login completed for a different ChatGPT account than the native main identity");
this.name = "NativeMainReauthIdentityMismatchError";
}
}
/**
* The reauth twin of persistRefreshedMainAuthJson (#3898). That function
* spreads expected.tokens and never writes id_token, which would keep the
* OLD identity token beside the new grant; this sibling sets all four
* credential fields together and overwrites any prior id_token. Everything
* else — allowed root metadata, the pre-rename snapshot guards, the
* mutation epoch — follows the refresh path exactly.
*/
function persistNativeMainReauthTokens(
expected: MainAuthJsonCredential,
tokens: NativeMainReauthTokens,
): void {
assertNotRealCodexHomeUnderTest(resolveCodexHomeDir());
const nextTokens = {
...expected.tokens,
access_token: tokens.accessToken,
refresh_token: tokens.refreshToken,
id_token: tokens.idToken,
account_id: tokens.chatgptAccountId,
};
atomicWriteFile(
expected.path,
JSON.stringify({ ...expected.root, tokens: nextTokens }, null, 2) + "\n",
undefined,
{
beforeRename: () => {
assertMainAuthJsonSnapshotUnchanged(expected);
const hook = beforeMainAuthJsonRenameForTests;
beforeMainAuthJsonRenameForTests = null;
hook?.();
},
validateBeforeRename: () => assertMainAuthJsonSnapshotUnchanged(expected),
},
);
advanceCodexCredentialMutationEpoch();
}
/**
* Prepare a same-identity reauth of the native __main__ slot (#3898).
*
* The existing credential snapshot is captured NOW and held only inside the
* closure — callers (the device-reauth service) never see the expected
* account id, so a flow cannot be steered toward a different identity. No
* claim is held while the human completes the device page. The returned
* commit, called once the device grant exists:
*
* 1. requires the SAME chatgpt account identity as the snapshot;
* 2. acquires the owner-independent exclusive claim (native-main-claim) —
* deliberately NOT assertNativeMainOwner, which a headless hub cannot
* satisfy;
* 3. re-verifies the snapshot (path + hash + dev/ino) inside the claim;
* 4. writes access/refresh/id token + account_id atomically and clears the
* main account's reauth quarantine for the new credential generation.
*/
export function beginNativeMainReauth(): {
commit: (
tokens: NativeMainReauthTokens,
options?: { signal?: AbortSignal },
) => Promise<{ chatgptAccountId: string }>;
} {
const expected = readMainAuthJsonCredential();
if (!expected || !expected.chatgptAccountId) {
throw new NativeMainReauthUnavailableError(
"No native main credential exists to reauthenticate; enrollment is the native profile workflow",
);
}
return {
async commit(
tokens: NativeMainReauthTokens,
options: { signal?: AbortSignal } = {},
): Promise<{ chatgptAccountId: string }> {
if (!tokens.accessToken || !tokens.refreshToken || !tokens.idToken) {
throw new NativeMainReauthUnavailableError("Device grant did not produce a complete token set");
}
if (tokens.chatgptAccountId !== expected.chatgptAccountId) {
throw new NativeMainReauthIdentityMismatchError();
}
return withNativeMainExclusiveClaim(resolveNativeProfileContext(), async () => {
// Recovery/admission recheck (080): a recovery-blocked or not-ready
// home fails native_main_unavailable rather than rewriting auth.json
// underneath the gate. The claim waits bounded like the refresh path
// (30s) so a busy claim is not an instant refusal.
if (isNativeMainTrafficBlocked()) {
throw new NativeMainReauthUnavailableError(
"Native main traffic is blocked by startup or recovery state",
);
}
if (options.signal?.aborted) throw options.signal.reason;
assertMainAuthJsonSnapshotUnchanged(expected);
persistNativeMainReauthTokens(expected, tokens);
clearAccountNeedsReauth(MAIN_CODEX_ACCOUNT_ID);
return { chatgptAccountId: tokens.chatgptAccountId };
}, { waitMs: 30_000, signal: options.signal });
},
};
}
async function resolveMainAccountToken(
dependencies: NativeMainRefreshDependencies = {},
rejectedAccessToken?: string,
): Promise<{ accessToken: string; chatgptAccountId: string } | null> {
const initial = readMainAuthJsonCredential();
if (!initial) return null;
const now = Date.now();
if (initial.accessToken !== rejectedAccessToken
&& mainAccessTokenFresh(initial.accessToken, now, MAIN_TOKEN_REFRESH_SKEW_MS)) {
return { accessToken: initial.accessToken!, chatgptAccountId: initial.chatgptAccountId };
}
if (!initial.refreshToken) {
return initial.accessToken !== rejectedAccessToken
&& mainAccessTokenFresh(initial.accessToken, now, 0)
? { accessToken: initial.accessToken!, chatgptAccountId: initial.chatgptAccountId }
: null;
}
const refreshTimeout = AbortSignal.timeout(30_000);
const signal = dependencies.signal
? AbortSignal.any([dependencies.signal, refreshTimeout])
: refreshTimeout;
const lockKey = refreshGrantFingerprintForToken(initial.refreshToken);
// Two locks, because they guard two different things that live in two different
// homes. `withCodexRefreshFileLock` is keyed on the grant fingerprint and lives
// under OPENCODEX_HOME; it serializes refreshes of the SAME grant within one
// install. The file being rewritten is `auth.json` under CODEX_HOME, which every
// OpenCodex install on the machine shares no matter what its own home is -- so two
// proxies with distinct OPENCODEX_HOMEs took two unrelated fingerprint locks and
// refreshed the one credential concurrently (#2999).
//
// The outer claim is the CODEX_HOME coordination the other native-main paths
// already use (`.opencodex-native-main.claim.sqlite`), so this needs no new
// primitive and no FFI. Order is claim (machine-wide) then fingerprint lock
// (per-grant), never the reverse: two processes holding different fingerprint
// locks and then reaching for the same claim would deadlock.
try {
return await withNativeMainExclusiveClaim(
resolveNativeProfileContext(),
() => withCodexRefreshFileLock(lockKey, signal, async () => {
const locked = readMainAuthJsonCredential();
if (!locked) throw new MainAuthJsonChangedDuringRefreshError();
if (!locked.refreshToken
|| refreshGrantFingerprintForToken(locked.refreshToken) !== lockKey) {
if (locked.accessToken !== rejectedAccessToken
&& mainAccessTokenFresh(locked.accessToken, Date.now(), 0)) {
return { accessToken: locked.accessToken!, chatgptAccountId: locked.chatgptAccountId };
}
throw new MainAuthJsonChangedDuringRefreshError();
}
if (locked.accessToken !== rejectedAccessToken
&& mainAccessTokenFresh(locked.accessToken, Date.now(), MAIN_TOKEN_REFRESH_SKEW_MS)) {
return { accessToken: locked.accessToken!, chatgptAccountId: locked.chatgptAccountId };
}
const refresh = dependencies.refreshToken
?? ((refreshToken: string, options: { signal: AbortSignal }) => refreshChatGPTToken(refreshToken, options));
let refreshed: OAuthCredentials;
try {
refreshed = await refresh(locked.refreshToken, { signal });
} catch (cause) {
const message = cause instanceof Error ? cause.message.toLowerCase() : "";
const reason = /invalid_grant|invalidated|revoked|expired/.test(message)
? "reauth" as const
: "transient" as const;
throw new MainAccountTokenRefreshError(reason, { cause });
}
// The refresh may resolve after the caller went away (an implementation that does
// not observe the signal, or an abort landing in the window between resolution and
// commit). A cancelled request's late refresh must not rewrite auth.json on behalf
// of a request that no longer exists -- the same fence the reauth twin applies
// before its own commit above.
if (dependencies.signal?.aborted) throw dependencies.signal.reason;
const result = persistRefreshedMainAuthJson(locked, refreshed);
if (dependencies.preserveReauth !== true) clearAccountNeedsReauth(MAIN_CODEX_ACCOUNT_ID);
return result;
}),
{ waitMs: 30_000, signal },
);
} catch (cause) {
if (refreshTimeout.aborted && !dependencies.signal?.aborted) {
throw new MainAccountTokenRefreshError("transient", { cause });
}
throw cause;
}
}
/** Refresh the CLI-owned native credential before upstream I/O and publish it atomically. */
export function getValidMainAccountToken(
dependencies: NativeMainRefreshDependencies = {},
): Promise<{ accessToken: string; chatgptAccountId: string } | null> {
return resolveMainAccountToken(dependencies);
}
/** Force refresh after upstream rejected this exact bearer once. */
export function forceRefreshMainAccountToken(
rejectedAccessToken: string,
dependencies: NativeMainRefreshDependencies = {},
): Promise<{ accessToken: string; chatgptAccountId: string } | null> {
return resolveMainAccountToken(dependencies, rejectedAccessToken);
}
export function setMainAccountPlan(plan: string | null): void {
mainAccountPlan = plan;
if (plan === null) jwtPlanAttempted = false;
}
export function getMainAccountPlan(): string | undefined {
if (mainAccountPlan) return mainAccountPlan;
if (jwtPlanAttempted) return undefined;
jwtPlanAttempted = true;
const tokens = readCodexTokens();
const jwtPlan = tokens
? extractChatgptPlanType(tokens.id_token, tokens.access_token)
: undefined;
if (jwtPlan) mainAccountPlan = jwtPlan;
return jwtPlan;
}
/** Read-only main account token from ~/.codex/auth.json, or null when not logged in. */
export function getMainAccountToken(): { accessToken: string; chatgptAccountId: string } | null {
const tokens = readCodexTokens();
if (!tokens?.access_token) return null;
return { accessToken: tokens.access_token, chatgptAccountId: tokens.account_id };
}
/**
* The main token is usable when it exists and — if its JWT carries a decodable `exp` — is
* not expired. When `exp` cannot be decoded we treat the token as live (best-effort); an
* actually-invalid token then surfaces via the upstream 401 → cooldown path.
*/
export function isMainAccountTokenLive(now = Date.now()): boolean {
const tokens = readCodexTokens();
if (!tokens?.access_token) return false;
const payload = decodeJwtPayload(tokens.access_token);
const exp = typeof payload?.exp === "number" ? payload.exp * 1000 : undefined;
return exp === undefined || exp > now;
}
/**
* Strict liveness for auth-terminality decisions: true only when the access-token JWT
* carries a decodable `exp` that is still in the future.
*
* Unlike {@link isMainAccountTokenLive}, an undecodable `exp` counts as NOT live here.
* This gate decides whether a bare WHAM 401 is downgraded to a transient failure; if an
* undecodable token could vouch for itself, a genuinely dead credential would keep every
* 401 "transient" and needsReauth could never flip.
*/
export function isMainAccountTokenVerifiablyLive(now = Date.now()): boolean {
const tokens = readCodexTokens();
if (!tokens?.access_token) return false;
const payload = decodeJwtPayload(tokens.access_token);
const exp = typeof payload?.exp === "number" ? payload.exp * 1000 : undefined;
return exp !== undefined && exp > now;
}