@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
385 lines (356 loc) • 15.7 kB
text/typescript
/** xAI OAuth flow (Grok account login). Ported from jawcode oauth/xai.ts. */
import { abortError, sleepWithAbort } from "../lib/upstream-retry";
import { OAuthCallbackFlow, type OAuthCallbackFlowOptions } from "./callback-server";
import { generatePKCE } from "./pkce";
import type { LocalTokenImportMode, OAuthController, OAuthCredentials } from "./types";
const XAI_OAUTH_ISSUER = "https://auth.x.ai";
export const XAI_OAUTH_DISCOVERY_URL = `${XAI_OAUTH_ISSUER}/.well-known/openid-configuration`;
export const XAI_OAUTH_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
export const XAI_OAUTH_SCOPE = "openid profile email offline_access grok-cli:access api:access";
const XAI_OAUTH_CALLBACK_PORT = 56121;
const XAI_OAUTH_CALLBACK_PATH = "/callback";
const XAI_OAUTH_REFRESH_SKEW_MS = 2 * 60 * 1000;
const TOKEN_REQUEST_TIMEOUT_MS = 30_000;
const RETRY_AFTER_MAX_DELAY_MS = 60_000;
const JITTER_DELAY_CAP_MS = 2_000;
const XAI_TRUSTED_AUTH_HOSTS = new Set(["auth.x.ai", "accounts.x.ai"]);
export const XAI_LOCAL_CLI_DETACH_WARNING =
"[oauth:xai] Grok CLI credential was stale; refreshed into OpenCodex ownership. Grok CLI may require login again.";
interface XaiDiscovery {
authorizationEndpoint: string;
tokenEndpoint: string;
}
interface XaiDiscoveryPayload {
authorization_endpoint?: unknown;
token_endpoint?: unknown;
}
export interface XaiTokenPayload {
access_token?: unknown;
refresh_token?: unknown;
expires_in?: unknown;
id_token?: unknown;
token_type?: unknown;
}
interface XaiJwtPayload {
sub?: unknown;
email?: unknown;
[key: string]: unknown;
}
function requestSignal(signal: AbortSignal | undefined): AbortSignal {
const timeoutSignal = AbortSignal.timeout(TOKEN_REQUEST_TIMEOUT_MS);
return signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
}
function validateXaiEndpoint(rawUrl: string): string {
let parsed: URL;
try {
parsed = new URL(rawUrl);
} catch {
throw new Error("xAI OAuth discovery returned an unparseable endpoint URL");
}
const host = parsed.hostname.toLowerCase();
if (
parsed.protocol !== "https:"
|| parsed.username !== ""
|| parsed.password !== ""
|| parsed.port !== ""
|| !XAI_TRUSTED_AUTH_HOSTS.has(host)
) {
throw new Error(`xAI OAuth discovery returned an unexpected endpoint (host: ${host || "none"})`);
}
return parsed.toString();
}
export async function discoverXaiOAuthEndpoints(signal?: AbortSignal): Promise<XaiDiscovery> {
const response = await fetch(XAI_OAUTH_DISCOVERY_URL, {
headers: { Accept: "application/json" },
signal: requestSignal(signal),
});
if (!response.ok) {
throw new Error(`xAI OAuth discovery failed: ${response.status} ${await response.text()}`);
}
const payload = (await response.json()) as XaiDiscoveryPayload;
if (typeof payload.authorization_endpoint !== "string" || typeof payload.token_endpoint !== "string") {
throw new Error("xAI OAuth discovery response missing authorization/token endpoints");
}
return {
authorizationEndpoint: validateXaiEndpoint(payload.authorization_endpoint),
tokenEndpoint: validateXaiEndpoint(payload.token_endpoint),
};
}
function decodeJwtPayload(token: string): XaiJwtPayload | undefined {
const parts = token.split(".");
const payload = parts[1];
if (parts.length !== 3 || !payload) return undefined;
try {
return JSON.parse(Buffer.from(payload, "base64url").toString("utf8")) as XaiJwtPayload;
} catch {
return undefined;
}
}
function getTokenIdentity(accessToken: string, idToken: string | undefined): { accountId?: string; email?: string } {
const payload = (idToken ? decodeJwtPayload(idToken) : undefined) ?? decodeJwtPayload(accessToken);
const accountId = typeof payload?.sub === "string" && payload.sub.length > 0 ? payload.sub : undefined;
const email =
typeof payload?.email === "string" && payload.email.length > 0 ? payload.email.toLowerCase() : undefined;
return { accountId, email };
}
export class XaiTokenRequestError extends Error { constructor(public readonly status?:number,public readonly oauthError?:string,message="xAI token request failed",options?:{cause?:unknown}){super(message,options);this.name="XaiTokenRequestError";} }
export interface XaiTokenRetryDeps { sleep?:(ms:number)=>Promise<void>; random?:()=>number }
const IMF_FIXDATE_RE = /^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{2}):(\d{2}):(\d{2}) GMT$/i;
const RFC850_DATE_RE = /^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{2}):(\d{2}):(\d{2}) GMT$/i;
const ASCTIME_DATE_RE = /^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( \d|\d{2}) (\d{2}):(\d{2}):(\d{2}) (\d{4})$/i;
const HTTP_MONTH_INDEX: Record<string, number> = {
jan: 0, feb: 1, mar: 2, apr: 3, may: 4, jun: 5,
jul: 6, aug: 7, sep: 8, oct: 9, nov: 10, dec: 11,
};
function parseUtcDateParts(
year: number,
monthName: string,
day: number,
hour: number,
minute: number,
second: number,
): number | undefined {
const month = HTTP_MONTH_INDEX[monthName.toLowerCase()];
if (month === undefined) return undefined;
const timestamp = Date.UTC(year, month, day, hour, minute, second);
const parsed = new Date(timestamp);
return parsed.getUTCFullYear() === year
&& parsed.getUTCMonth() === month
&& parsed.getUTCDate() === day
&& parsed.getUTCHours() === hour
&& parsed.getUTCMinutes() === minute
&& parsed.getUTCSeconds() === second
? timestamp
: undefined;
}
function parseHttpDateMs(value: string, now: number): number | undefined {
const match = IMF_FIXDATE_RE.exec(value);
if (match) {
return parseUtcDateParts(
Number(match[3]), match[2]!, Number(match[1]),
Number(match[4]), Number(match[5]), Number(match[6]),
);
}
const rfc850 = RFC850_DATE_RE.exec(value);
if (rfc850) {
// Two-digit years more than 50 years in the future are in the past (RFC 9110).
const currentYear = new Date(now).getUTCFullYear();
let year = Math.floor(currentYear / 100) * 100 + Number(rfc850[3]);
const candidateTimeOfYear = Date.UTC(
2000, HTTP_MONTH_INDEX[rfc850[2]!.toLowerCase()]!, Number(rfc850[1]),
Number(rfc850[4]), Number(rfc850[5]), Number(rfc850[6]),
);
const current = new Date(now);
const currentTimeOfYear = Date.UTC(
2000, current.getUTCMonth(), current.getUTCDate(),
current.getUTCHours(), current.getUTCMinutes(), current.getUTCSeconds(),
current.getUTCMilliseconds(),
);
const yearDelta = year - currentYear;
if (yearDelta < -50 || (yearDelta === -50 && candidateTimeOfYear < currentTimeOfYear)) {
year += 100;
} else if (yearDelta > 50 || (yearDelta === 50 && candidateTimeOfYear > currentTimeOfYear)) {
year -= 100;
}
return parseUtcDateParts(
year, rfc850[2]!, Number(rfc850[1]),
Number(rfc850[4]), Number(rfc850[5]), Number(rfc850[6]),
);
}
const asctime = ASCTIME_DATE_RE.exec(value);
if (!asctime) return undefined;
return parseUtcDateParts(
Number(asctime[6]), asctime[1]!, Number(asctime[2]),
Number(asctime[3]), Number(asctime[4]), Number(asctime[5]),
);
}
function parseRetryAfterMs(retryAfter: string | null): number | undefined {
const text = retryAfter?.trim();
if (!text) return undefined;
if (/^\d+(?:\.\d+)?$/.test(text)) {
const ms = Math.ceil(Number(text) * 1000);
return ms > 0 ? ms : undefined;
}
const now = Date.now();
const timestamp = parseHttpDateMs(text, now);
if (timestamp === undefined) return undefined;
const delay = timestamp - now;
return delay > 0 ? delay : undefined;
}
function jitterDelay(attempt: number, random: () => number): number {
const base = attempt === 1 ? 100 : 250;
return Math.min(JITTER_DELAY_CAP_MS, Math.round(base * (0.75 + random() * 0.5)));
}
/**
* Delay before the next attempt, or undefined when the server asked for a wait
* beyond the retry budget — retrying earlier than Retry-After would hammer the
* token endpoint, so the caller fails the request instead of clamping.
*/
function retryDelay(attempt: number, retryAfter: string | null, random: () => number): number | undefined {
const serverMs = parseRetryAfterMs(retryAfter);
if (serverMs === undefined) return jitterDelay(attempt, random);
return serverMs <= RETRY_AFTER_MAX_DELAY_MS ? serverMs : undefined;
}
async function sleepAbortable(
ms: number,
sleep: (ms: number) => Promise<void>,
signal: AbortSignal | undefined,
): Promise<void> {
if (!signal) return sleep(ms);
if (signal.aborted) throw abortError(signal);
let onAbort!: () => void;
try {
await Promise.race([
sleep(ms),
new Promise<never>((_, reject) => {
onAbort = () => reject(abortError(signal));
signal.addEventListener("abort", onAbort, { once: true });
}),
]);
} finally {
signal.removeEventListener("abort", onAbort);
}
}
async function readTokenError(response:Response):Promise<XaiTokenRequestError>{let oauthError:string|undefined,detail="";try{const body=await response.json() as {error?:unknown;error_description?:unknown};if(typeof body.error==="string")oauthError=body.error;if(typeof body.error_description==="string")detail=body.error_description;}catch{/* non-JSON error body: fall through to the generic message */}const suffix=detail?`: ${detail}`:oauthError?`: ${oauthError}`:"";return new XaiTokenRequestError(response.status,oauthError,`xAI token request failed: ${response.status}${suffix}`);}
export async function postXaiToken(
tokenEndpoint: string,
body: Record<string, string>,
signal?: AbortSignal, deps:XaiTokenRetryDeps={},
): Promise<XaiTokenPayload> {
const sleep=deps.sleep??((ms:number)=>sleepWithAbort(ms,signal)),random=deps.random??Math.random;let last:unknown;
for(let attempt=1;attempt<=3;attempt++){let response:Response;try{response=await fetch(tokenEndpoint, {
method: "POST",
headers: {
Accept: "application/json",
"Content-Type": "application/x-www-form-urlencoded",
},
body: new URLSearchParams(body).toString(),
signal: requestSignal(signal),
});}catch(error){
if(signal?.aborted)throw error;
const name=(error as {name?:string}|undefined)?.name;
if(name==="AbortError"||name==="TimeoutError")throw error;
last=error;
if(attempt===3)throw new XaiTokenRequestError(undefined,undefined,"xAI token request failed: network error",{cause:error});
await sleepAbortable(jitterDelay(attempt,random),sleep,signal);
continue;
}if(response.ok)return await response.json() as XaiTokenPayload;const error=await readTokenError(response);last=error;if(!(response.status===429||response.status>=500)||attempt===3)throw error;if(signal?.aborted)throw error;const delay=retryDelay(attempt,response.headers.get("retry-after"),random);if(delay===undefined)throw error;await sleepAbortable(delay,sleep,signal);}throw last;
}
function credentialsFromTokenPayload(payload: XaiTokenPayload, refreshFallback = ""): OAuthCredentials {
if (typeof payload.access_token !== "string" || payload.access_token.length === 0) {
throw new Error("xAI token response did not include an access token");
}
const refresh =
typeof payload.refresh_token === "string" && payload.refresh_token.length > 0
? payload.refresh_token
: refreshFallback;
if (!refresh) {
throw new Error("xAI token response did not include a refresh token");
}
const expiresIn =
typeof payload.expires_in === "number" && Number.isFinite(payload.expires_in) ? payload.expires_in : 3600;
const idToken = typeof payload.id_token === "string" ? payload.id_token : undefined;
const { accountId, email } = getTokenIdentity(payload.access_token, idToken);
return {
refresh,
access: payload.access_token,
expires: Date.now() + expiresIn * 1000 - XAI_OAUTH_REFRESH_SKEW_MS,
accountId,
email,
};
}
export class XaiOAuthFlow extends OAuthCallbackFlow {
#verifier = "";
#discovery: XaiDiscovery | undefined;
constructor(ctrl: OAuthController) {
super(ctrl, {
preferredPort: XAI_OAUTH_CALLBACK_PORT,
callbackPath: XAI_OAUTH_CALLBACK_PATH,
callbackHostname: "127.0.0.1",
callbackBindHostname: "127.0.0.1",
redirectUri: `http://127.0.0.1:${XAI_OAUTH_CALLBACK_PORT}${XAI_OAUTH_CALLBACK_PATH}`,
} satisfies OAuthCallbackFlowOptions);
}
async generateAuthUrl(state: string, redirectUri: string): Promise<{ url: string; instructions?: string }> {
const pkce = await generatePKCE();
this.#verifier = pkce.verifier;
this.#discovery = await discoverXaiOAuthEndpoints(this.ctrl.signal);
const params = new URLSearchParams({
response_type: "code",
client_id: XAI_OAUTH_CLIENT_ID,
redirect_uri: redirectUri,
scope: XAI_OAUTH_SCOPE,
code_challenge: pkce.challenge,
code_challenge_method: "S256",
state,
nonce: crypto.randomUUID(),
});
return {
url: `${this.#discovery.authorizationEndpoint}?${params.toString()}`,
instructions:
"Complete xAI/Grok login in your browser. If the browser cannot reach this machine, paste the final redirect URL or authorization code when prompted.",
};
}
async exchangeToken(code: string, _state: string, redirectUri: string): Promise<OAuthCredentials> {
if (!this.#verifier) {
throw new Error("xAI OAuth PKCE verifier was not initialized");
}
const discovery = this.#discovery ?? (await discoverXaiOAuthEndpoints(this.ctrl.signal));
const tokenPayload = await postXaiToken(
discovery.tokenEndpoint,
{
grant_type: "authorization_code",
client_id: XAI_OAUTH_CLIENT_ID,
code,
redirect_uri: redirectUri,
code_verifier: this.#verifier,
},
this.ctrl.signal,
);
return credentialsFromTokenPayload(tokenPayload);
}
}
export async function loginXai(
ctrl: OAuthController,
opts?: { importLocal?: LocalTokenImportMode },
): Promise<OAuthCredentials> {
const importLocal = opts?.importLocal ?? "off";
if (importLocal !== "off") {
const { detectGrokCliToken } = await import("./local-token-detect");
const local = detectGrokCliToken();
if (local) {
ctrl.onProgress?.("Found Grok CLI token, importing automatically");
if (local.expires >= Date.now() + 60_000) return local;
try {
const fresh = await refreshXaiToken(local.refresh, ctrl.signal);
ctrl.onProgress?.(XAI_LOCAL_CLI_DETACH_WARNING);
return { ...fresh, source: "oauth" };
} catch (error) {
if (importLocal === "only") {
throw new Error(
`Grok CLI token is expired and could not be refreshed: ${error instanceof Error ? error.message : String(error)}`,
);
}
}
} else if (importLocal === "only") {
throw new Error("No Grok CLI token found at ~/.grok/auth.json. Run 'ocx login xai' for browser OAuth.");
}
}
return new XaiOAuthFlow(ctrl).login();
}
export async function refreshXaiToken(refreshToken: string, signal?: AbortSignal): Promise<OAuthCredentials> {
if (!refreshToken) {
throw new Error("xAI credentials are expired and do not include a refresh token");
}
const discovery = await discoverXaiOAuthEndpoints(signal);
const tokenPayload = await postXaiToken(
discovery.tokenEndpoint,
{
grant_type: "refresh_token",
client_id: XAI_OAUTH_CLIENT_ID,
refresh_token: refreshToken,
},
signal,
);
return credentialsFromTokenPayload(tokenPayload, refreshToken);
}