@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
text/typescript
/**
* 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);
}