UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

520 lines (487 loc) • 24.5 kB
import { AnthropicTokenError } from "./anthropic"; import { parseCallbackInput } from "./callback-server"; import { XaiRedirectRefusedError, XaiTokenRequestError } from "./xai"; import { retainedUtf8Bytes } from "../lib/admission"; import type { GenerationContext } from "../lib/state-store-sweeper"; /** * In-flight login flow state and the manual paste slot that feeds it. * * Split out of `index.ts` when that file crossed the repository file-size ratchet at 2009 * lines. The cut follows a seam rather than a line count: everything here is bookkeeping for * a login that has started and not yet settled, and none of it reads or writes a stored * credential. `index.ts` re-exports the two public names, so existing importers are unaffected. * * Every map here is keyed by FLOW ID, not by provider. A code-display flow binds no socket, so * a hosted login host can have several in flight for one provider at once; each must have its * own paste slot and its own abort scope, or one user's paste settles another's login. The * provider-only public APIs (`getLoginStatus`, `submitManualLoginCode`, `cancelLoginFlow`) * resolve through `latestLoginFlowKey`, which is the one place that rule is written down. */ /** Human-facing continuation only: never retain credentials or provider response objects. */ export interface OAuthLoginHint { url: string; instructions?: string; deviceCode?: string; } /** * Machine-readable outcome of a code-display login, so a caller that only ever sees one HTTP * response can tell a bad paste from a dead flow from an unreachable provider. Never carries * any part of the code, verifier, state or token. */ export type LoginCodeError = | "state_mismatch" | "invalid_or_expired_code" | "no_pending_login" | "provider_unreachable" | "malformed_input" | "code_mode_unsupported" /** * The provider answered definitively and the client will not retry: today, a redirect the * device poll refused to follow. Distinct from `invalid_or_expired_code` (the input was * wrong) and `provider_unreachable` (the request never got an answer), because both of those * invite a retry that can only fail the same way. Same spelling as the CLI's terminal reason. */ | "oauth_authentication_failed"; export interface LoginFlowState { error?: string; done: boolean; hint?: OAuthLoginHint; /** Absent means the default localhost-callback flow; "code" is the code-display flow. */ mode?: "callback" | "code"; /** * Which provider this flow logs into, since the key no longer says. Absent on a row written * straight into this map by a caller that predates flow-id keying, where the key IS the * provider name — `loginFlowProvider` resolves both. */ provider?: string; flowId?: string; /** Epoch ms after which a paste is refused as `no_pending_login`. */ expiresAt?: number; errorCode?: LoginCodeError; /** Account row this flow persisted, once it settled successfully. An id, never a credential. */ accountId?: string; /** An outer login can still need this exact outcome after OAuth has settled. */ retainOutcome?: () => boolean; } /** Keyed by flow id. */ export const loginState = new Map<string, LoginFlowState>(); /** Keyed by flow id; `provider` is what a provider-scoped caller is checked against. */ export const loginAbort = new Map<string, { controller: AbortController; provider?: string }>(); export const kiroLoginSettling = new Set<string>(); /** The provider a flow belongs to, or undefined when no such flow is recorded. */ export function loginFlowProvider(flowKey: string): string | undefined { const state = loginState.get(flowKey); return state === undefined ? undefined : state.provider ?? flowKey; } /** Flow ids recorded for a provider, oldest first (Map iteration is insertion order). */ export function loginFlowKeys(provider: string): string[] { // ponytail: linear scan over in-flight logins (bounded by MAX_LOGIN_FLOWS_PER_PROVIDER); // add a provider -> keys index if that bound ever grows. const keys: string[] = []; // `(state.provider ?? key)` must be parenthesised: `===` binds tighter than `??`, so the // unparenthesised form reads as `state.provider ?? (key === provider)` and returns the truthy // provider string for every flow -- matching every provider against every other. for (const [key, state] of loginState) if ((state.provider ?? key) === provider) keys.push(key); return keys; } /** * The flow that a provider-only API acts on: the NEWEST flow still in progress, or — when none * is — the newest flow overall, so a login that just settled still reports its outcome. With a * single flow (every callback login, and every GUI/CLI login) this is that flow, unchanged. */ export function latestLoginFlowKey(provider: string): string | undefined { const keys = loginFlowKeys(provider); return keys.findLast(key => loginState.get(key)?.done === false) ?? keys.at(-1); } /** * Rows kept per provider. Concurrent code flows mean an authenticated caller can start logins * nobody ever finishes, each holding a PKCE verifier, an AbortController and an open paste * promise. Expired flows are reaped first; this is the backstop that bounds the rest. */ const MAX_LOGIN_FLOWS_PER_PROVIDER = 64; /** Abort a flow, drop its paste slot, and record a terminal outcome for anything awaiting it. */ export function abandonLoginFlow(flowKey: string, outcome: { error: string; errorCode: LoginCodeError }): void { loginAbort.get(flowKey)?.controller.abort("cancelled"); loginAbort.delete(flowKey); clearManualCodeSlot(flowKey); settleLoginFlow(flowKey, outcome); } /** * Refuse a login that cannot safely share this process with what is already in flight, after * reaping dead rows. A code-display flow binds nothing, so several can run at once for one * provider — that is what lets a hosted login host serve more than one user. The callback flow * binds the fixed loopback port and genuinely cannot run twice, so any overlap involving one is * refused, as is anything past the per-provider row cap. */ export function admitLoginFlow(provider: string, codeMode: boolean): void { reapLoginFlows(provider); const inFlight = loginFlowKeys(provider) .map(key => loginState.get(key)) .filter(state => state?.done === false); const overlapAllowed = codeMode && inFlight.every(state => state?.mode === "code"); if ((inFlight.length > 0 && !overlapAllowed) || (provider === "kiro" && kiroLoginSettling.has(provider))) { throw new Error(`A login for ${provider} is already in progress`); } if (loginFlowKeys(provider).length >= MAX_LOGIN_FLOWS_PER_PROVIDER) { throw new Error(`Too many logins in progress for ${provider}`); } } /** * Drop a provider's dead rows: code flows past their paste window (they can never complete), * then the oldest settled rows once the cap is reached. Called when a flow starts, which is * the only moment the count can grow. Never evicts a flow still in progress. */ function reapLoginFlows(provider: string): void { const now = Date.now(); for (const key of loginFlowKeys(provider)) { const state = loginState.get(key); if (state && !state.done && state.expiresAt !== undefined && now > state.expiresAt) { abandonLoginFlow(key, { error: "Login expired", errorCode: "no_pending_login" }); } } const keys = loginFlowKeys(provider); // +1 leaves room for the flow about to be recorded. const excess = keys.length - MAX_LOGIN_FLOWS_PER_PROVIDER + 1; if (excess <= 0) return; const reclaimable = keys.filter(key => { const state = loginState.get(key); return state?.done === true && !state.retainOutcome?.(); }); for (const key of reclaimable.slice(0, excess)) { clearManualCodeSlot(key); dropLoginFlow(key); } } /** A code-display flow the user never completes must stop accepting pastes. */ export const CODE_LOGIN_TTL_MS = 10 * 60_000; /** * Record a just-admitted flow under its id and return its paste deadline (code mode only). * Lives here rather than in `startLoginFlow` to keep `src/oauth/index.ts` under the size ratchet. */ export function recordStartedLoginFlow(provider: string, flowId: string, codeMode: boolean, retainOutcome?: () => boolean): number | undefined { clearManualCodeSlot(flowId); const expiresAt = codeMode ? Date.now() + CODE_LOGIN_TTL_MS : undefined; loginState.set(flowId, { done: false, provider, flowId, retainOutcome, ...(codeMode ? { mode: "code" as const, expiresAt } : {}) }); return expiresAt; } export class CodeLoginUnsupportedError extends Error { constructor(provider: string) { super(`${provider} has no code-display login`); this.name = "CodeLoginUnsupportedError"; } } /** * Map a login failure onto the code a code-mode caller receives. The error itself is never * forwarded: a provider body can quote the submitted code back, and this response is the one * surface a hosted caller renders to a user. * * Anthropic code exchanges and xAI device grants carry typed provider failures; other * providers retain the generic branches. * * This is the single source of truth for the machine-readable reason: the code-mode paste * response, `GET /api/oauth/status` and the headless CLI all read it, so a new terminal cause is * added here once rather than special-cased at each surface. */ export function classifyLoginCodeError(error: unknown): LoginCodeError { const message = error instanceof Error ? error.message : ""; if (message.startsWith("OAuth callback cancelled")) return "no_pending_login"; // A refused redirect is a definitive server answer, not a transport fault and not a bad code: // the request was never delivered anywhere it was allowed to go, and replaying it would be // refused identically. Checked before the status-less branches, which would otherwise read it // as a retriable network failure or as an invalid code. if (error instanceof XaiRedirectRefusedError) return "oauth_authentication_failed"; if (error instanceof XaiTokenRequestError) { if (error.status === 429 || (error.status !== undefined && error.status >= 500)) return "provider_unreachable"; if (error.oauthError === "expired_token" || error.oauthError === "invalid_grant") return "invalid_or_expired_code"; if (error.status === undefined) return "provider_unreachable"; return "oauth_authentication_failed"; } if (error instanceof AnthropicTokenError) { return error.httpStatus !== undefined && error.httpStatus >= 500 ? "provider_unreachable" : "invalid_or_expired_code"; } const name = error instanceof Error ? error.name : ""; if (name === "TimeoutError" || name === "AbortError") return "provider_unreachable"; // fetch() reports a dead network as a TypeError, but so does any bug in this code. Bun tags // the network kind with a string `code` (`ConnectionRefused`, `ENOTFOUND`, ...) and Node puts // one on `cause`; a plain programming TypeError carries neither, and must not be reported to // the user as "Anthropic is unreachable". if (error instanceof TypeError) { const code = (error as { code?: unknown }).code ?? (error as { cause?: { code?: unknown } }).cause?.code; if (typeof code === "string" && code !== "") return "provider_unreachable"; } return "invalid_or_expired_code"; } /** Awaiting a terminal outcome for one flow (code mode answers its POST from this). */ const loginSettleWaiters = new Map<string, Set<() => void>>(); function wakeLoginWaiters(flowKey: string): void { const waiters = loginSettleWaiters.get(flowKey); if (!waiters) return; loginSettleWaiters.delete(flowKey); for (const wake of waiters) wake(); } /** * Record a login's terminal outcome and wake anything awaiting it. Flow identity * (mode/flowId/expiresAt) is preserved so a settled flow still reports what it was. The hint is * dropped: `getLoginStatus` already hides it once done, and a settled flow has no next step. */ export function settleLoginFlow( flowKey: string, outcome: { error?: string; errorCode?: LoginCodeError; accountId?: string } = {}, ): void { const current = loginState.get(flowKey); // A flow already dropped (logout, reap) has nothing left to report; releasing its waiters is // still owed, and fabricating a row here would be a flow belonging to no provider. if (current) { loginState.set(flowKey, { ...current, done: true, hint: undefined, error: outcome.error, errorCode: outcome.errorCode, accountId: outcome.accountId, }); } wakeLoginWaiters(flowKey); } /** True when the named flow (or, without one, the provider's newest flow) is this provider's code flow. */ export function isCodeLoginFlow(provider: string, flowId?: string): boolean { const flowKey = flowId ?? latestLoginFlowKey(provider); return flowKey !== undefined && loginFlowProvider(flowKey) === provider && loginState.get(flowKey)?.mode === "code"; } /** The account a settled, successful flow persisted; undefined for any other flow or provider. */ export function loginFlowAccountId(provider: string, flowId: string): string | undefined { const state = loginState.get(flowId); if (!state?.done || state.error || loginFlowProvider(flowId) !== provider) return undefined; return state.accountId; } /** Drop one flow's state entirely; waiters are released rather than left hanging. */ export function dropLoginFlow(flowKey: string): void { loginState.delete(flowKey); wakeLoginWaiters(flowKey); } /** * Resolve true once the login is terminal, false if `timeoutMs` elapses first. `flowId` picks * one of several concurrent flows; without it the provider's newest flow is used. */ export function waitForLoginSettled(provider: string, timeoutMs: number, flowId?: string): Promise<boolean> { const flowKey = flowId ?? latestLoginFlowKey(provider); const current = flowKey === undefined ? undefined : loginState.get(flowKey); if (!current || current.done || loginFlowProvider(flowKey!) !== provider) return Promise.resolve(true); return new Promise<boolean>(resolve => { let waiters = loginSettleWaiters.get(flowKey!); if (!waiters) { waiters = new Set(); loginSettleWaiters.set(flowKey!, waiters); } let timer: ReturnType<typeof setTimeout>; const wake = (): void => { clearTimeout(timer); resolve(true); }; timer = setTimeout(() => { waiters.delete(wake); resolve(false); }, timeoutMs); waiters.add(wake); }); } /** * Forget every login flow for a provider (logout): it invalidates all of them, not just the * newest. Any code-mode POST awaiting one is released rather than left to time out. */ export function clearLoginState(provider: string): void { for (const flowKey of loginFlowKeys(provider)) { loginAbort.get(flowKey)?.controller.abort("cleared"); loginAbort.delete(flowKey); clearManualCodeSlot(flowKey); dropLoginFlow(flowKey); } } /** * Cancel one login. `flowId` names it exactly; without one the provider's newest in-flight flow * is cancelled, which is every single-flow caller (GUI, CLI) unchanged. A flow id belonging to a * different provider is refused rather than cancelled. Only the public OAuth cancellation * endpoint opts into failed-outcome dismissal; callers using this boolean as proof of an * aborted controller (Codex flow ownership) retain their original contract. */ export function cancelLoginFlow(provider: string, flowId?: string, options?: { dismissSettledFailure?: boolean }): boolean { const flowKey = flowId ?? latestLoginFlowKey(provider); if (flowKey === undefined) return false; const active = loginAbort.get(flowKey); const existing = loginState.get(flowKey); if ((active?.provider ?? loginFlowProvider(flowKey)) !== provider) return false; if (options?.dismissSettledFailure && !active && existing?.done && existing.error) { // A failed add-account attempt does not invalidate a previously signed-in account. Let // its owner dismiss the stale UI outcome without erasing credentials or another flow. clearManualCodeSlot(flowKey); dropLoginFlow(flowKey); return true; } if (!active && (!existing || existing.done)) return false; abandonLoginFlow(flowKey, { error: "Login cancelled", errorCode: "no_pending_login" }); return true; } /** Pending paste for a login in progress: either a waiter or a stashed early submission. */ export interface ManualCodeSlot { pendingInput?: string; resolve?: (value: string) => void; /** Registered by the callback flow so submits can validate state synchronously. */ expectedState?: string; /** Code-display flows are single-use: set once a paste is handed to the exchange. */ delivered?: boolean; } const loginManual = new Map<string, ManualCodeSlot>(); const OAUTH_PENDING_CODE_MAX_BYTES = 4 * 1024; let lastOAuthFlowReconciledGeneration = 0; export function reconcileOAuthFlowState(context: GenerationContext): number { if (context.generation <= lastOAuthFlowReconciledGeneration) return 0; let removed = 0; for (const [flowKey, state] of loginState) { const provider = state.provider ?? flowKey!; if (context.providerNames.has(provider) || !state.done || loginAbort.has(flowKey) || state.retainOutcome?.()) continue; if (loginState.delete(flowKey)) removed += 1; if (loginManual.delete(flowKey)) removed += 1; if (loginAbort.delete(flowKey)) removed += 1; } lastOAuthFlowReconciledGeneration = context.generation; return removed; } /** Test-only counterpart to `resetOAuthReauthStateForTests`, for the same leak. */ export function resetOAuthFlowReconcileStateForTests(): void { lastOAuthFlowReconciledGeneration = 0; } export function clearManualCodeSlot(flowKey: string): void { loginManual.delete(flowKey); } export function ensureManualCodeSlot(flowKey: string): ManualCodeSlot { let slot = loginManual.get(flowKey); if (!slot) { slot = {}; loginManual.set(flowKey, slot); } return slot; } /** Wait for a GUI/CLI paste of the OAuth redirect URL or code (or return a stashed early submit). */ export function waitForManualLoginCode(flowKey: string, signal: AbortSignal, expectedState?: string): Promise<string> { if (signal.aborted) { return Promise.reject(new Error(`OAuth callback cancelled: ${signal.reason}`)); } const slot = ensureManualCodeSlot(flowKey); if (expectedState !== undefined) slot.expectedState = expectedState; if (slot.pendingInput !== undefined) { const value = slot.pendingInput; slot.pendingInput = undefined; return Promise.resolve(value); } return new Promise<string>((resolve, reject) => { const onAbort = () => { if (slot.resolve === resolve) slot.resolve = undefined; reject(new Error(`OAuth callback cancelled: ${signal.reason}`)); }; signal.addEventListener("abort", onAbort, { once: true }); slot.resolve = (value: string) => { signal.removeEventListener("abort", onAbort); if (slot.resolve === resolve) slot.resolve = undefined; resolve(value); }; }); } /** * Feed a pasted redirect URL or authorization code into an in-progress GUI login. Provider-only, * so it feeds the provider's newest in-flight flow — see `latestLoginFlowKey`. * Returns ok:false when no login is waiting (or input is empty). Invalid pastes are accepted * here and re-prompted by the OAuth callback loop if they cannot be parsed / fail state checks. */ export function submitManualLoginCode(provider: string, input: string): { ok: true } | { ok: false; error: string } { const result = submitLoginCode(provider, input); // The machine-readable code is dropped here on purpose: this return shape is the // long-standing contract of the callback flow's paste route. Code mode calls // submitLoginCode directly because it must answer with the code. return result.ok ? { ok: true } : { ok: false, error: result.error }; } /** * Same validation as `submitManualLoginCode`, with the machine-readable reason attached, and * the id of the flow the paste was applied to so the caller can await THAT flow rather than * whichever one is newest by the time it looks. * * `expectedFlowId` pins the submission to one flow: a paste from a superseded attempt, or one * aimed at another concurrent login, is refused rather than fed to whatever is running now. */ export function submitLoginCode( provider: string, input: string, expectedFlowId?: string, ): { ok: true; flowId: string } | { ok: false; error: string; code: LoginCodeError } { const trimmed = input.trim(); if (!trimmed) return { ok: false, error: "empty code", code: "malformed_input" }; if (retainedUtf8Bytes(trimmed) > OAUTH_PENDING_CODE_MAX_BYTES) { return { ok: false, error: "code too large", code: "malformed_input" }; } // The flow id IS the key, so an id belonging to another provider's flow (or to no flow at // all) resolves to nothing here rather than reaching a login it does not own. const flowKey = expectedFlowId ?? latestLoginFlowKey(provider); const st = flowKey === undefined ? undefined : loginState.get(flowKey); if (!st || st.done || loginFlowProvider(flowKey!) !== provider) { return { ok: false, error: "no login in progress", code: "no_pending_login" }; } if (st.expiresAt !== undefined && Date.now() > st.expiresAt) { return { ok: false, error: "login expired", code: "no_pending_login" }; } const slot = ensureManualCodeSlot(flowKey!); // A code-display flow exchanges exactly one paste and then settles, success or not. A second // paste while that exchange runs would otherwise be stashed and answered with the first // paste's outcome, so it is refused instead. if (st.mode === "code" && slot.delivered) { return { ok: false, error: "login already received a code", code: "no_pending_login" }; } // Without the expected state a paste cannot be checked here, and stashing it would spend the // flow's single use on input the callback loop later throws away. The URL a caller needs to // obtain a code is published only after the state is registered, so this is only reachable // by racing the start. if (st.mode === "code" && slot.expectedState === undefined) { return { ok: false, error: "login is not ready for a code yet", code: "no_pending_login" }; } // Synchronous validation (validated request/ack): reject un-parseable input and // authorization responses (url/query kind) whose state is missing or mismatched // once the flow has registered its expected state. Raw codes stay in-session-PKCE // protected — but a raw paste carrying an explicit #state suffix is state-bearing // and checked too. Early posts (flow not yet waiting, no expectedState) are // stashed and re-validated by the callback loop. const parsed = parseCallbackInput(trimmed); // Command Code's manual fallback accepts a pasted JSON callback payload // (`{ apiKey, state, ... }`). Keep that opaque to the generic raw parser so // hashes in JSON strings do not become a fake state suffix; its provider parser validates state. const isCommandCodeJson = provider === "command-code" && trimmed.startsWith("{"); if (!parsed.code && !isCommandCodeJson) { return { ok: false, error: "no authorization code found in input", code: "malformed_input" }; } // A raw paste carrying an explicit code#state suffix is state-bearing too: it // must match the expected state rather than bypass validation. const stateBearing = !isCommandCodeJson && (parsed.kind !== "raw" || parsed.state !== undefined); if (stateBearing && slot.expectedState !== undefined) { if (parsed.state === undefined) { return { ok: false, error: "redirect URL is missing the state parameter", code: "state_mismatch" }; } if (parsed.state !== slot.expectedState) { return { ok: false, code: "state_mismatch", error: parsed.kind === "raw" ? "state mismatch — paste the bare code, or the correct code#state from THIS login attempt" : "state mismatch — paste the redirect URL from THIS login attempt", }; } } if (slot.resolve) { const resolve = slot.resolve; slot.resolve = undefined; resolve(trimmed); } else { // Race: GUI may POST before the flow reaches onManualCodeInput — stash for the waiter. slot.pendingInput = trimmed; } if (st.mode === "code") slot.delivered = true; return { ok: true, flowId: flowKey! }; }