@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
134 lines (126 loc) • 6.2 kB
text/typescript
import { parseCallbackInput } from "./callback-server";
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.
*/
/** Human-facing continuation only: never retain credentials or provider response objects. */
export interface OAuthLoginHint {
url: string;
instructions?: string;
deviceCode?: string;
}
export const loginState = new Map<string, { error?: string; done: boolean; hint?: OAuthLoginHint }>();
export const loginAbort = new Map<string, { controller: AbortController; flowId?: string }>();
export const kiroLoginSettling = new Set<string>();
/** 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;
}
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 [provider, state] of loginState) {
if (context.providerNames.has(provider) || !state.done || loginAbort.has(provider)) continue;
if (loginState.delete(provider)) removed += 1;
if (loginManual.delete(provider)) removed += 1;
if (loginAbort.delete(provider)) removed += 1;
}
lastOAuthFlowReconciledGeneration = context.generation;
return removed;
}
export function clearManualCodeSlot(provider: string): void {
loginManual.delete(provider);
}
export function ensureManualCodeSlot(provider: string): ManualCodeSlot {
let slot = loginManual.get(provider);
if (!slot) {
slot = {};
loginManual.set(provider, 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(provider: string, signal: AbortSignal, expectedState?: string): Promise<string> {
if (signal.aborted) {
return Promise.reject(new Error(`OAuth callback cancelled: ${signal.reason}`));
}
const slot = ensureManualCodeSlot(provider);
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.
* 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 trimmed = input.trim();
if (!trimmed) return { ok: false, error: "empty code" };
if (retainedUtf8Bytes(trimmed) > OAUTH_PENDING_CODE_MAX_BYTES) return { ok: false, error: "code too large" };
const st = loginState.get(provider);
if (!st || st.done) return { ok: false, error: "no login in progress" };
const slot = ensureManualCodeSlot(provider);
// 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" };
// 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" };
if (parsed.state !== slot.expectedState) {
return {
ok: false,
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;
}
return { ok: true };
}