UNPKG

@bitkyc08/opencodex

Version:

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

307 lines (289 loc) • 14.9 kB
/** Anthropic OAuth flow (Claude Pro/Max). Ported from jawcode oauth/anthropic.ts. */ import { OAuthCallbackFlow } from "./callback-server"; import { bindAnthropicIdentity, bindAnthropicOrganizationScope, normalizeAnthropicIdentity, normalizeAnthropicOrganizationUuid, resolveAnthropicAccountIdentity } from "./anthropic-identity"; import { generatePKCE } from "./pkce"; import type { LocalTokenImportMode, OAuthController, OAuthCredentials } from "./types"; import { outboundProxyConfigured, startupOutboundProxyConfigured } from "../lib/proxy-env"; import type { AnthropicInstanceId } from "../providers/anthropic-instance-id"; import { AnthropicLocalCliImportError } from "./store-anthropic-instance"; const CLIENT_ID = atob("OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl"); const AUTHORIZE_URL = "https://claude.ai/oauth/authorize"; const TOKEN_URL = "https://api.anthropic.com/v1/oauth/token"; const CALLBACK_PORT = 54545; const CALLBACK_PATH = "/callback"; /** Profile enrichment budget on token refresh; login paths keep the resolver's own deadline. */ const REFRESH_PROFILE_TIMEOUT_MS = 2_000; const SCOPES = "org:create_api_key user:profile user:inference"; /** * Provider-hosted code-display redirect: Anthropic renders `code#state` for the user to copy * instead of redirecting to a local port. This is what makes login possible from a container or * a hosted gateway, where no browser can reach this process. Same OAuth client as the callback * flow — only the redirect differs, so it must be the redirect_uri used for BOTH the authorize * request and the token exchange. */ export const ANTHROPIC_CODE_REDIRECT_URI = "https://platform.claude.com/oauth/code/callback"; /** A displayed code is copied by hand across devices; the 300s callback wait is too short. */ const CODE_MODE_TIMEOUT_MS = 10 * 60_000; // ── OAuth-request requirements applied by the anthropic adapter when authMode==="oauth" ── export const ANTHROPIC_OAUTH_BETA = "claude-code-20250219,oauth-2025-04-20"; export const CLAUDE_CODE_SYSTEM_INSTRUCTION = "You are a Claude agent, built on Anthropic's Claude Agent SDK."; const CLAUDE_TOOL_PREFIX = "custom_"; const ANTHROPIC_BUILTIN_TOOLS = new Set(["web_search", "code_execution", "text_editor", "computer"]); /** OAuth tokens reject arbitrary tool names; prefix custom tools (Anthropic builtins are exempt). */ export function applyClaudeToolPrefix(name: string): string { if (ANTHROPIC_BUILTIN_TOOLS.has(name.toLowerCase()) || name.toLowerCase().startsWith(CLAUDE_TOOL_PREFIX)) return name; return CLAUDE_TOOL_PREFIX + name; } /** Strip the custom_ prefix from a returned tool_use name so the caller (Codex) sees the original. */ export function stripClaudeToolPrefix(name: string): string { return name.startsWith(CLAUDE_TOOL_PREFIX) ? name.slice(CLAUDE_TOOL_PREFIX.length) : name; } interface AnthropicTokenResponse { access_token: string; refresh_token: string; expires_in: number; account?: { uuid?: string; email_address?: string }; organization?: { uuid?: string }; } export class AnthropicTokenError extends Error { constructor( message: string, readonly httpStatus: number | undefined, readonly oauthError: string | undefined, readonly requestNotSent = false, ) { super(message); this.name = "AnthropicTokenError"; } } /** * The TCP connect that would have carried the token request was refused, so no byte of it was * sent (#8577). Two transports can report that, and only in these exact shapes: * - Bun's native fetch (direct, or through an HTTP(S) proxy): `code: "ECONNREFUSED"` with `path` * naming this request's URL. A reachable proxy that cannot open the upstream tunnel reports * `ERR_PROXY_TUNNEL` instead, and a response that is lost later is a reset or timeout. * - The SOCKS5 transport (src/lib/socks5-fetch.ts), which only ever connects to the configured * proxy: node:net's `code: "ECONNREFUSED"` with `syscall: "connect"`. * Message text, another URL, or a refusal outside connect proves nothing and keeps the replay guard. */ function connectionRefusedBeforeSend(error: unknown, url: string): boolean { if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "ECONNREFUSED") return false; if ("path" in error) return error.path === url; return "syscall" in error && error.syscall === "connect"; } async function postJson(url: string, body: Record<string, string | number>): Promise<string> { const direct = !startupOutboundProxyConfigured && !outboundProxyConfigured(); const init: RequestInit & { protocol: "http1.1" } = { method: "POST", headers: { "Content-Type": "application/json", Accept: "application/json" }, body: JSON.stringify(body), signal: AbortSignal.timeout(30_000), // Pinned Bun 1.4.0: one HTTP/1.1 attempt, no keep-alive reuse or redirect following. // Only without an outbound proxy can token-host DNS failure prove no request was sent. redirect: "manual", keepalive: false, protocol: "http1.1", }; let response: Response; try { response = await fetch(url, init); } catch (error) { if (direct && typeof error === "object" && error !== null && "code" in error && error.code === "ENOTFOUND" && "syscall" in error && error.syscall === "getaddrinfo" && "hostname" in error && error.hostname === new URL(url).hostname) { throw new AnthropicTokenError("Anthropic OAuth DNS lookup failed before connection", undefined, undefined, true); } if (connectionRefusedBeforeSend(error, url)) { throw new AnthropicTokenError("Anthropic OAuth connection refused before the request was sent", undefined, undefined, true); } throw error; } if (response.status >= 300 && response.status < 400) { // A redirect can follow a completed POST and token rotation; it is not a rejection. await response.body?.cancel().catch(() => {}); throw new AnthropicTokenError(`Anthropic OAuth redirect HTTP ${response.status}: outcome unknown`, undefined, undefined); } const responseBody = await response.text(); if (!response.ok) { let oauthError: string | undefined; try { const parsed = JSON.parse(responseBody) as { error?: unknown }; if (typeof parsed.error === "string") oauthError = parsed.error; } catch { // Best-effort only: malformed error bodies remain structured by HTTP status. } throw new AnthropicTokenError( `Anthropic OAuth HTTP ${response.status}: ${responseBody}`, response.status, oauthError, ); } return responseBody; } function parseTokenResponse(responseBody: string): AnthropicTokenResponse { try { return JSON.parse(responseBody) as AnthropicTokenResponse; } catch { throw new Error(`Anthropic OAuth returned invalid JSON: ${responseBody.slice(0, 200)}`); } } function credsFrom(data: AnthropicTokenResponse, refreshFallback?: string): OAuthCredentials { const accountUuid = data.account?.uuid; const email = data.account?.email_address; // Guard against a missing/non-finite/negative expires_in (malformed upstream // response): a NaN expiry would never compare as expired, and a negative // duration would stamp an already-past expiry — both block refresh semantics. const expiresIn = typeof data.expires_in === "number" && Number.isFinite(data.expires_in) && data.expires_in >= 0 ? data.expires_in : 3600; // The computed timestamp itself must stay finite: Number.MAX_VALUE passes // Number.isFinite but overflows to Infinity once multiplied by 1000. const computedExpires = Date.now() + expiresIn * 1000 - 5 * 60 * 1000; const expires = Number.isFinite(computedExpires) ? computedExpires : Date.now() + 3600 * 1000 - 5 * 60 * 1000; return { refresh: data.refresh_token || refreshFallback || "", access: data.access_token, expires, anthropicIdentity: bindAnthropicIdentity(data.access_token, accountUuid, data.organization?.uuid), accountId: typeof accountUuid === "string" && accountUuid.length > 0 ? accountUuid : undefined, email: typeof email === "string" && email.length > 0 ? email : undefined, }; } async function withAccountProfile(data: AnthropicTokenResponse, signal?: AbortSignal, refreshToken?: string): Promise<OAuthCredentials> { const credential = credsFrom(data, refreshToken); const exchangeOrganization = normalizeAnthropicOrganizationUuid(data.organization?.uuid); const identity = normalizeAnthropicIdentity(credential.anthropicIdentity, credential.access); const exchangeScope = !identity ? bindAnthropicOrganizationScope(credential.access, exchangeOrganization) : undefined; const exchangeCredential = exchangeScope ? { ...credential, anthropicOrganizationScope: exchangeScope } : credential; const profile = await resolveAnthropicAccountIdentity(credential.access, signal); if (!profile) return exchangeCredential; const { plan, organizationName, ...profileIdentity } = profile; if (identity && identity.accountUuid !== profileIdentity.accountUuid) return credential; if (exchangeOrganization && exchangeOrganization !== profileIdentity.organizationUuid) { if (identity) return credential; if (profileIdentity.organizationUuid) { if (refreshToken === undefined) throw new Error("Anthropic OAuth returned conflicting organization information. Sign in again."); // Keep the rotated grant and the exchange scope, without making an account claim. return exchangeCredential; } return { ...credential, accountId: profileIdentity.accountUuid, anthropicIdentity: { ...profileIdentity, organizationUuid: exchangeOrganization } }; } return { ...credential, accountId: profileIdentity.accountUuid, anthropicIdentity: profileIdentity, plan: plan ?? null, organizationName: organizationName ?? null }; } export class AnthropicOAuthFlow extends OAuthCallbackFlow { /** * PKCE verifier for THIS flow. One `AnthropicOAuthFlow` is constructed per login and * `generateAuthUrl` runs once on it, so the verifier is already flow-scoped: a second * concurrent login builds a second instance and cannot reach this field. */ #verifier = ""; #codeMode: boolean; constructor(ctrl: OAuthController, opts?: { codeMode?: boolean }) { if (opts?.codeMode) { super(ctrl, { preferredPort: CALLBACK_PORT, callbackPath: CALLBACK_PATH, redirectUri: ANTHROPIC_CODE_REDIRECT_URI, skipCallbackServer: true, timeoutMs: CODE_MODE_TIMEOUT_MS, }); } else { super(ctrl, CALLBACK_PORT, CALLBACK_PATH); } this.#codeMode = opts?.codeMode === true; } async generateAuthUrl(state: string, redirectUri: string): Promise<{ url: string; instructions?: string }> { const pkce = await generatePKCE(); this.#verifier = pkce.verifier; const authParams = new URLSearchParams({ code: "true", client_id: CLIENT_ID, response_type: "code", redirect_uri: redirectUri, scope: SCOPES, code_challenge: pkce.challenge, code_challenge_method: "S256", state, }); return { url: `${AUTHORIZE_URL}?${authParams.toString()}`, instructions: this.#codeMode ? "Open this URL in any browser, approve access, then paste the code Anthropic displays (it looks like code#state)." : "Complete Claude 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> { let exchangeCode = code; let exchangeState = state; const hash = code.indexOf("#"); if (hash >= 0) { exchangeCode = code.slice(0, hash); const frag = code.slice(hash + 1); if (frag.length > 0) exchangeState = frag; } const responseBody = await postJson(TOKEN_URL, { grant_type: "authorization_code", client_id: CLIENT_ID, code: exchangeCode, state: exchangeState, redirect_uri: redirectUri, code_verifier: this.#verifier, }); return withAccountProfile(parseTokenResponse(responseBody), this.ctrl.signal); } } export async function loginAnthropic( ctrl: OAuthController, opts?: { importLocal?: LocalTokenImportMode; instance?: AnthropicInstanceId; codeMode?: boolean }, ): Promise<OAuthCredentials> { // A code-mode caller asked for a URL to show and a box to paste into. Importing a local // Claude Code token instead would complete WITHOUT ever firing onAuth, so the caller would // get no URL at all — a different outcome than the one its contract promises. const importLocal = opts?.codeMode ? "off" : opts?.importLocal ?? "off"; if (opts?.instance === "anthropic2" && importLocal !== "off") throw new AnthropicLocalCliImportError(); if (importLocal !== "off") { const { detectClaudeCodeTokenAsync } = await import("./local-token-detect"); const local = await detectClaudeCodeTokenAsync(); ctrl.signal?.throwIfAborted(); if (local) { ctrl.onProgress?.("Found Claude Code token, importing automatically"); if (local.expires >= Date.now() + 60_000) { const identity = await resolveAnthropicAccountIdentity(local.access, ctrl.signal); ctrl.signal?.throwIfAborted(); return { ...local, ...(identity ? { accountId: identity.accountUuid, anthropicIdentity: normalizeAnthropicIdentity(identity, local.access), plan: identity.plan ?? null, organizationName: identity.organizationName ?? null } : {}) }; } try { return { ...(await refreshAnthropicToken(local.refresh)), source: "local-cli" }; } catch (error) { if (importLocal === "only") { throw new Error(`Claude Code token expired and could not be refreshed: ${error instanceof Error ? error.message : String(error)}`); } } } else if (importLocal === "only") { throw new Error( process.platform === "darwin" ? "No Claude Code token found (Keychain or ~/.claude/.credentials.json). Run 'ocx login anthropic' for browser OAuth." : "No Claude Code token found (~/.claude/.credentials.json). Run 'ocx login anthropic' for browser OAuth.", ); } } return new AnthropicOAuthFlow(ctrl, { codeMode: opts?.codeMode === true }).login(); } export async function refreshAnthropicToken(refreshToken: string): Promise<OAuthCredentials> { const responseBody = await postJson(TOKEN_URL, { grant_type: "refresh_token", client_id: CLIENT_ID, refresh_token: refreshToken, }); // Refresh can sit on a request path, so the profile enrichment gets a short deadline. A // missed read leaves plan unobserved and the stored label survives through mergeOAuthPlan. return withAccountProfile(parseTokenResponse(responseBody), AbortSignal.timeout(REFRESH_PROFILE_TIMEOUT_MS), refreshToken); }