@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
158 lines (148 loc) • 9.23 kB
text/typescript
import { detectClaudeCodeTokenAsync, hasClaudeCredentialContinuity } from "./local-token-detect";
import { anthropicOrganization, normalizeAnthropicIdentity, resolveAnthropicAccountIdentity, type AnthropicIdentityResolver } from "./anthropic-identity";
import { anthropicSiblingSlots } from "./anthropic-login-slot";
import { credentialGeneration, type AuthStore } from "./store";
import { AnthropicCrossInstanceDuplicateError, assertNoCrossAnthropicRegistration } from "./store-anthropic-instance";
import { mergeOAuthOrganizationName, mergeOAuthPlan } from "./plan";
import { REFRESH_SKEW_MS } from "./refresh-policy";
import type { OAuthCredentials, ProviderAccount, ProviderAccountSet } from "./types";
import { ANTHROPIC_INSTANCE_IDS, type AnthropicInstanceId } from "../providers/anthropic-instance-id";
export type ClaudeCredentialObservation =
| { kind: "absent" }
| { kind: "unresolved" | "different"; diskGeneration: string }
| ClaudeCredentialAdoption;
type ClaudeCredentialAdoption = {
kind: "adopt";
credential: OAuthCredentials;
diskGeneration: string;
/** Shared-token continuity leaves this absent. A fully rotated grant may have an unknown old org. */
previousOrganization?: string | null;
};
export async function newerClaudeCredential(
stored: OAuthCredentials, now: number, signal?: AbortSignal,
resolveIdentity: AnthropicIdentityResolver = resolveAnthropicAccountIdentity,
): Promise<ClaudeCredentialObservation> {
return newerClaudeCredentialForInstance("anthropic", stored, now, signal, resolveIdentity);
}
export async function newerClaudeCredentialForInstance(
instance: AnthropicInstanceId, stored: OAuthCredentials, now: number, signal?: AbortSignal,
resolveIdentity: AnthropicIdentityResolver = resolveAnthropicAccountIdentity,
slot?: { accountId: string; accounts: readonly ProviderAccount[] },
): Promise<ClaudeCredentialObservation> {
if (instance === "anthropic2") return { kind: "absent" };
if (stored.source !== "local-cli") return { kind: "absent" };
const disk = await detectClaudeCodeTokenAsync();
if (!disk || !Number.isFinite(disk.expires) || disk.expires <= now + REFRESH_SKEW_MS
|| credentialGeneration(disk) === credentialGeneration(stored)) return { kind: "absent" };
const diskGeneration = credentialGeneration(disk);
const before = normalizeAnthropicIdentity(stored.anthropicIdentity, stored.access);
if (hasClaudeCredentialContinuity(stored, disk)) {
// The same bearer keeps its proof, and with it the organization its name labels.
const sameBearer = disk.access === stored.access;
const proof = { anthropicIdentity: sameBearer ? before : undefined,
anthropicOrganizationScope: sameBearer ? stored.anthropicOrganizationScope : undefined };
return { kind: "adopt", diskGeneration: credentialGeneration(disk), credential: {
...stored, ...disk, ...proof, plan: mergeOAuthPlan(disk, stored),
organizationName: mergeOAuthOrganizationName({ ...disk, ...proof }, stored),
} };
}
// Independent observations share a deadline through the caller signal; neither extends the other.
const [oldProof, newProof] = await Promise.all([
before ?? resolveIdentity(stored.access, signal), resolveIdentity(disk.access, signal),
]);
const oldIdentity = normalizeAnthropicIdentity(oldProof, stored.access);
const newIdentity = normalizeAnthropicIdentity(newProof, disk.access);
if (!oldIdentity || !newIdentity) return { kind: "unresolved", diskGeneration };
if (oldIdentity.accountUuid !== newIdentity.accountUuid) return { kind: "different", diskGeneration };
// The same person signed in to another organization holds a different grant and quota. A stored
// proof saved before organizations were recorded asks its own still-usable bearer once.
const storedOrganization = anthropicOrganization(stored);
if (!before && storedOrganization && oldIdentity.organizationUuid && storedOrganization !== oldIdentity.organizationUuid) {
return { kind: "unresolved", diskGeneration };
}
let oldOrganization = storedOrganization ?? oldIdentity.organizationUuid;
const newOrganization = newIdentity.organizationUuid;
if (!oldOrganization && before && newOrganization && stored.expires > now) {
const legacy = normalizeAnthropicIdentity(await resolveIdentity(stored.access, signal), stored.access);
if (legacy?.accountUuid === oldIdentity.accountUuid) oldOrganization = legacy.organizationUuid;
}
if (oldOrganization && newOrganization && oldOrganization !== newOrganization) {
return { kind: "different", diskGeneration };
}
if ((!oldOrganization || !newOrganization) && slot
&& anthropicSiblingSlots(slot.accounts, slot.accountId, newIdentity.accountUuid).length > 0) {
return { kind: "unresolved", diskGeneration };
}
return { kind: "adopt", diskGeneration, previousOrganization: oldOrganization ?? null, credential: {
...stored, ...disk, accountId: newIdentity.accountUuid, anthropicIdentity: newIdentity,
anthropicOrganizationScope: undefined, plan: newProof?.plan ?? null,
organizationName: newProof?.organizationName ?? null,
} };
}
/** Check the latest roster while adoption owns the auth-store writer lock. */
export function claudeAdoptionSlotCurrent(
store: AuthStore, instance: AnthropicInstanceId, accountId: string, adoption: ClaudeCredentialAdoption,
): boolean {
const credential = adoption.credential;
const identity = normalizeAnthropicIdentity(credential.anthropicIdentity, credential.access);
if (!identity) return true;
// A full rotation brings a new grant, so the other pool's registration rule applies to it too.
if (adoption.previousOrganization !== undefined) {
try { assertNoCrossAnthropicRegistration(store, instance, credential); }
catch (error) {
if (error instanceof AnthropicCrossInstanceDuplicateError) return false;
throw error;
}
}
const siblings = ANTHROPIC_INSTANCE_IDS.flatMap(pool =>
anthropicSiblingSlots(store[pool]?.accounts ?? [], pool === instance ? accountId : undefined, identity.accountUuid));
if (siblings.length === 0) return true;
const organization = identity.organizationUuid;
if (adoption.previousOrganization !== undefined && (!organization || organization !== adoption.previousOrganization)) return false;
return !organization || !siblings.some(row => anthropicOrganization(row.credential) === organization);
}
/**
* Fresh re-read of the Claude CLI credential for a write that depends on it. Adoption awaits it
* inside the serialized writer (afterPrePersistRead) so a rotation while the writer was queued is
* caught; the read is asynchronous (a Keychain lookup must never be killed, #8161), so the writer's
* synchronous ownership predicate only consumes its result. Fails closed: a missing, unreadable,
* near-expiry or different generation is not current.
*/
export async function claudeCredentialGenerationCurrent(diskGeneration: string, now: () => number = Date.now): Promise<boolean> {
const disk = await detectClaudeCodeTokenAsync();
return disk !== null && disk.expires > now() + REFRESH_SKEW_MS && credentialGeneration(disk) === diskGeneration;
}
/**
* Capture primitives before network awaits; check them again inside the serialized writer.
* `diskVerified` marks a write that depends on the CLI credential and carries the caller's
* {@link claudeCredentialGenerationCurrent} result: undefined for a write that does not depend on
* it, and false fails closed. Store-side generation and selection checks stay in the predicate.
*/
export function captureAnthropicCredentialOwner(set: ProviderAccountSet, accountId: string) {
return captureAnthropicCredentialOwnerForInstance("anthropic", set, accountId);
}
export function captureAnthropicCredentialOwnerForInstance(instance: AnthropicInstanceId, set: ProviderAccountSet, accountId: string) {
const row = set.accounts.find(account => account.id === accountId)!;
const loginId = row.loginId;
const generation = credentialGeneration(row.credential);
const metadata = identityMetadata(row.credential);
const needsReauth = row.needsReauth;
const selection = { id: set.activeAccountId, revision: set.selectionRevision };
return (store: AuthStore, diskVerified?: boolean, allowPaused = false): boolean => {
const current = store[instance];
const account = current?.accounts.find(candidate => candidate.id === accountId);
if (!account || (!allowPaused && account.paused) || account.loginId !== loginId
|| account.needsReauth !== needsReauth || credentialGeneration(account.credential) !== generation
|| identityMetadata(account.credential) !== metadata) return false;
if (diskVerified !== undefined) {
if (instance === "anthropic2") return false;
if (current?.activeAccountId !== selection.id || current?.selectionRevision !== selection.revision) return false;
if (!diskVerified) return false;
}
return true;
};
}
function identityMetadata(credential: OAuthCredentials): string {
return JSON.stringify([credential.source, credential.accountId, credential.email, credential.anthropicIdentity, credential.plan,
credential.organizationName, credential.anthropicOrganizationScope]);
}