UNPKG

@bitkyc08/opencodex

Version:

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

236 lines (217 loc) • 10.1 kB
/** * Claude auth presence detection. * * THREE values, not two. `unknown` means a source could not be READ (denied keychain, * permission error, corrupt JSON) — treating that as `absent` would silently flip a * subscriber into proxy mode, which is the failure this whole unit exists to prevent * (devlog/_plan/260726_claude_auth_auto/001 F1). The resolver maps unknown to the * historical default (subscription), never to proxy. * * IO is injectable so every source is testable without touching the real home * directory, keychain, or environment. */ import { existsSync, readFileSync } from "node:fs"; import { homedir } from "node:os"; import { join } from "node:path"; import { claudeKeychainReader } from "../oauth/claude-keychain-read"; export type AuthPresence = "present" | "absent" | "unknown"; export type AuthSourceId = | "claude-json-oauth" // S1: <config-dir>/../.claude.json oauthAccount | "claude-credentials-file" // S2: <config-dir>/.credentials.json | "macos-keychain" // S3: security find-generic-password (metadata only) | "exported-env"; // S5: ANTHROPIC_API_KEY / a USER's ANTHROPIC_AUTH_TOKEN // NOTE: there is deliberately no "opencodex anthropic OAuth" source. That is a // PROVIDER credential in opencodex's own store which the Claude CLI never consumes, // so it is not evidence the client can authenticate natively (audit 002 §5). /** * The one opencodex-owned dummy token. Exported so the CLI, the system-env writer and * the tests all compare against the same literal — a second copy is how the marker * feedback loop (002 §1) sneaks back in. */ export const PROXY_MARKER = "opencodex-proxy"; /** * The macOS Keychain source, resolved once at an asynchronous boundary and handed to * {@link defaultAuthDetectDeps}. Detection itself stays synchronous, but the lookup behind it must * not: a synchronous `security` child can only be bounded by killing it, and killing one that is * waiting on an unlock prompt crashes `securityd` and re-locks the keychain (#8161). The shared * reader runs it without ever signalling the child, under the same single slot and backoff as the * credential read, and answers `absent` on a non-darwin host. * * A manual `claudeCode.authMode` ("proxy" or "subscription") never consults detection, so the * probe is skipped there: a pinned user pays no wait and sees no unlock prompt for a discarded * answer. The keychain source then reads `unknown`, which is never `absent`. */ export function resolveClaudeKeychainPresence(authMode?: string): Promise<AuthPresence> { if (authMode === "proxy" || authMode === "subscription") { return Promise.resolve(process.platform === "darwin" ? "unknown" : "absent"); } return claudeKeychainReader.probe(); } export interface AuthSourceResult { source: AuthSourceId; presence: AuthPresence; /** One short, credential-free line. Never contains token material. */ detail?: string; } export interface AuthDetectDeps { /** Parsed ~/.claude.json; undefined when missing; throws on corrupt/unreadable. */ readClaudeJson(): Record<string, unknown> | undefined; /** Whether <config-dir>/.credentials.json exists; throws on read error. */ credentialsFileExists(): boolean; /** present/absent/unknown for the macOS keychain, already resolved; absent on non-Darwin. */ keychainProbe(): AuthPresence; /** * The environment to inspect for S5. Callers pass the SAME base env the launch will * use, so detection and the spawned process can never disagree. Injection is typed * to exclude this key (see `detectClaudeAuth` callers) so a test fake cannot * silently replace the binding. */ env(): NodeJS.ProcessEnv; /** * Token values opencodex itself put into the environment. `system-env.ts` exports the * configured admission key as `ANTHROPIC_AUTH_TOKEN`, so without this the detector * reads OUR OWN output back as proof the user can authenticate natively — the same * feedback loop the `PROXY_MARKER` guard closes, one variable over. */ ownTokens?: readonly string[]; } export interface AuthDetectResult { /** present if ANY source is present; unknown if none present but ANY unknown. */ presence: AuthPresence; /** The source that proved presence, when any — feeds the GUI reason badge. */ foundBy?: AuthSourceId; sources: AuthSourceResult[]; /** * True when the inspected env carries OUR OWN dummy marker. It must never count as * user auth, and a subscription resolution strips it before launch (002 §1). */ staleProxyMarker: boolean; } /** Claude Code config dir: `CLAUDE_CONFIG_DIR` override, else `~/.claude`. */ export function claudeConfigDir(env: NodeJS.ProcessEnv = process.env): string { const explicit = env.CLAUDE_CONFIG_DIR?.trim(); return explicit ? explicit : join(homeDir(env), ".claude"); } /** * `os.homedir()` reads the OS user database and ignores a reassigned `HOME`, which * makes an isolated-profile probe silently read the real user's files. Prefer the * environment the caller handed us; fall back to the OS value. */ function homeDir(env: NodeJS.ProcessEnv): string { const fromEnv = env.HOME?.trim() || env.USERPROFILE?.trim(); return fromEnv ? fromEnv : homedir(); } function detectClaudeJson(deps: AuthDetectDeps): AuthSourceResult { try { const parsed = deps.readClaudeJson(); if (parsed === undefined) return { source: "claude-json-oauth", presence: "absent" }; const account = parsed.oauthAccount; if (account && typeof account === "object" && !Array.isArray(account)) { const email = (account as Record<string, unknown>).emailAddress; if (typeof email === "string" && email.trim().length > 0) { // Never echo the address itself — the detail line is UI copy, not a credential. return { source: "claude-json-oauth", presence: "present", detail: "oauthAccount" }; } } return { source: "claude-json-oauth", presence: "absent" }; } catch { // Corrupt or unreadable is NOT absent (F1). return { source: "claude-json-oauth", presence: "unknown", detail: "unreadable" }; } } function detectCredentialsFile(deps: AuthDetectDeps): AuthSourceResult { try { return { source: "claude-credentials-file", presence: deps.credentialsFileExists() ? "present" : "absent", }; } catch { return { source: "claude-credentials-file", presence: "unknown", detail: "unreadable" }; } } function detectKeychain(deps: AuthDetectDeps): AuthSourceResult { try { return { source: "macos-keychain", presence: deps.keychainProbe() }; } catch { return { source: "macos-keychain", presence: "unknown", detail: "probe failed" }; } } function detectExportedEnv(deps: AuthDetectDeps): AuthSourceResult { try { const env = deps.env(); const isOwn = (value: string): boolean => value === PROXY_MARKER || (deps.ownTokens ?? []).includes(value); const apiKey = env.ANTHROPIC_API_KEY?.trim(); if (apiKey && !isOwn(apiKey)) { return { source: "exported-env", presence: "present", detail: "ANTHROPIC_API_KEY" }; } const token = env.ANTHROPIC_AUTH_TOKEN?.trim(); // Our own dummy is opencodex state, never user auth: counting it would make a // proxy-mode launch look authenticated on the NEXT launch (002 §1). The configured // admission key is opencodex state for exactly the same reason — the system-env // writer exports it into this very variable. if (token && !isOwn(token)) { return { source: "exported-env", presence: "present", detail: "ANTHROPIC_AUTH_TOKEN" }; } return { source: "exported-env", presence: "absent" }; } catch { return { source: "exported-env", presence: "unknown" }; } } export function detectClaudeAuth(deps: AuthDetectDeps): AuthDetectResult { const sources = [ detectClaudeJson(deps), detectCredentialsFile(deps), detectKeychain(deps), detectExportedEnv(deps), ]; let staleProxyMarker = false; try { staleProxyMarker = deps.env().ANTHROPIC_AUTH_TOKEN?.trim() === PROXY_MARKER; } catch { staleProxyMarker = false; } const present = sources.find(source => source.presence === "present"); if (present) return { presence: "present", foundBy: present.source, sources, staleProxyMarker }; if (sources.some(source => source.presence === "unknown")) { return { presence: "unknown", sources, staleProxyMarker }; } return { presence: "absent", sources, staleProxyMarker }; } /** * Real IO. The Keychain source is the caller's pre-resolved {@link resolveClaudeKeychainPresence} * result. A caller that did not resolve one gets `unknown` on macOS, which the resolver maps to * subscription; it is never read as `absent`. */ export function defaultAuthDetectDeps( env: NodeJS.ProcessEnv = process.env, ownTokens: readonly string[] = [], keychainPresence: AuthPresence = process.platform === "darwin" ? "unknown" : "absent", ): AuthDetectDeps { const configDir = claudeConfigDir(env); return { readClaudeJson() { // Sibling of the config dir when CLAUDE_CONFIG_DIR is set, else ~/.claude.json. const path = env.CLAUDE_CONFIG_DIR?.trim() ? join(configDir, "..", ".claude.json") : join(homeDir(env), ".claude.json"); if (!existsSync(path)) return undefined; // A parse failure propagates so the caller records `unknown`, not `absent`. return JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>; }, credentialsFileExists() { return existsSync(join(configDir, ".credentials.json")); }, keychainProbe: () => keychainPresence, env: () => env, ownTokens, }; } /** * The token values opencodex itself exports. Configured admission keys land in * `ANTHROPIC_AUTH_TOKEN` (see `system-env.ts`), so detection must not read them back * as user auth. */ export function ownAdmissionTokens(config: { apiKeys?: Array<{ key: string }> }): string[] { return (config.apiKeys ?? []).map(entry => entry.key).filter(key => key.length > 0); }