@yansigit/opencodex 2.32.0 → 2.33.0

package/src/oauth/antigravity-routing.ts

@@ -1,286 +1,210 @@
+import { createHash } from "node:crypto";
 import { getAccountSet } from "./store";
-import {
-  bindSessionAffinity,
-  buildSessionKeyFromParts,
-  clearAffinityState,
-  clearSessionAffinityForAccount,
-  getSessionAffinity,
-  normalizeAffinityComponent,
-  touchSessionAffinity,
-} from "../routing/account-pool";
-
-/**
- * Process-local Antigravity account health (cooldowns). Stored in an in-memory
- * `Map<string, AntigravityAccountHealth>` for the lifetime of this process only —
- * cooldowns reset on restart and are not shared across workers.
- */
-export type AntigravityCooldownReason = "rate_limited" | "quota_exhausted" | "geo_blocked";
-
-const POOL_KEY_ANTIGRAVITY = "google-antigravity";
-/** Short rate-limit stick-wait: retry the same account instead of hopping. Never wait on quota/geo. */
-export const ANTIGRAVITY_STICK_WAIT_MAX_MS = 5_000;
-
-const DEFAULT_RATE_LIMITED_COOLDOWN_MS = 5_000;
-const MAX_RATE_LIMITED_COOLDOWN_MS = 60_000;
-const DEFAULT_QUOTA_EXHAUSTED_COOLDOWN_MS = 24 * 60 * 60_000;
-const MAX_QUOTA_EXHAUSTED_COOLDOWN_MS = 7 * 24 * 60 * 60_000;
-const GEO_BLOCKED_COOLDOWN_MS = 24 * 60 * 60_000;
+import { sweepExpiredOnWrite } from "../lib/state-store-sweeper";
+
+const PROVIDER = "google-antigravity";
+const DEFAULT_COOLDOWN_MS = 60_000;
+const MAX_COOLDOWN_MS = 15 * 60_000;
+const MAX_SHORT_RETRY_MS = 5_000;
+const AFFINITY_IDLE_TTL_MS = 24 * 60 * 60_000;
+const MAX_AFFINITY_ENTRIES = 2_000;
+const MAX_AFFINITY_COMPONENT_LENGTH = 128;
+
+type CooldownSource = "retry-after" | "default" | "synthetic";
+export type AntigravityCooldownKind = "rate-limit" | "quota" | "geoblock";
+export type AntigravitySyntheticFailure = AntigravityCooldownKind;
+
+export interface AntigravityProviderError {
+  code?: string;
+  status?: number;
+  message?: string;
+}
 
-type AntigravityAccountHealth = {
+interface AccountHealth {
   cooldownUntil: number;
-  reason: AntigravityCooldownReason;
-};
-
-const accountHealth = new Map<string, AntigravityAccountHealth>();
-
-function positiveDurationOrDefault(
-  durationMs: number | undefined,
-  defaultMs: number,
-  maxMs?: number,
-): number {
-  if (typeof durationMs !== "number" || !Number.isFinite(durationMs) || durationMs <= 0) {
-    return defaultMs;
-  }
-  return maxMs === undefined ? durationMs : Math.min(durationMs, maxMs);
+  cooldownSource: CooldownSource;
+  cooldownKind: AntigravityCooldownKind;
 }
 
-function cooldownDurationMs(
-  reason: AntigravityCooldownReason,
-  retryAfterMs: number | undefined,
-): number {
-  switch (reason) {
-    case "rate_limited":
-      return positiveDurationOrDefault(
-        retryAfterMs,
-        DEFAULT_RATE_LIMITED_COOLDOWN_MS,
-        MAX_RATE_LIMITED_COOLDOWN_MS,
-      );
-    case "quota_exhausted":
-      return positiveDurationOrDefault(
-        retryAfterMs,
-        DEFAULT_QUOTA_EXHAUSTED_COOLDOWN_MS,
-        MAX_QUOTA_EXHAUSTED_COOLDOWN_MS,
-      );
-    case "geo_blocked":
-      return GEO_BLOCKED_COOLDOWN_MS;
-  }
+interface AffinityEntry {
+  accountId: string;
+  lastUsedAt: number;
 }
 
-export function recordAntigravityCooldown(
-  accountId: string,
-  reason: AntigravityCooldownReason,
-  retryAfterMs?: number,
-  now = Date.now(),
-): void {
-  const cooldownUntil = now + cooldownDurationMs(reason, retryAfterMs);
-  const current = accountHealth.get(accountId);
-  if (!current || current.cooldownUntil < cooldownUntil) {
-    accountHealth.set(accountId, { cooldownUntil, reason });
-  }
-}
+const accountHealth = new Map<string, AccountHealth>();
+const sessionAffinity = new Map<string, AffinityEntry>();
 
-export function getAntigravityAccountCooldown(
-  accountId: string,
-  now = Date.now(),
-): { cooldownUntil: number; reason: AntigravityCooldownReason } | undefined {
-  const health = accountHealth.get(accountId);
-  if (!health) return undefined;
-  if (health.cooldownUntil <= now) {
-    accountHealth.delete(accountId);
-    return undefined;
-  }
-  return { cooldownUntil: health.cooldownUntil, reason: health.reason };
+function trimmed(value: string | null | undefined): string {
+  return value?.trim() ?? "";
 }
 
-export function isAntigravityAccountInCooldown(accountId: string, now = Date.now()): boolean {
-  const health = accountHealth.get(accountId);
-  if (!health) return false;
-  if (health.cooldownUntil <= now) {
-    accountHealth.delete(accountId);
-    return false;
-  }
-  return true;
+function affinityKey(value: string | null | undefined): string {
+  const candidate = trimmed(value);
+  if (!candidate) return "";
+  return candidate.length <= MAX_AFFINITY_COMPONENT_LENGTH
+    ? candidate
+    : createHash("sha256").update(candidate).digest("hex");
 }
 
-export function nextAntigravityAccount(
-  accountIds: string[],
-  activeId: string | undefined,
-  now = Date.now(),
-): string | undefined {
-  if (accountIds.length === 0) return undefined;
-
-  const activeIndex = activeId === undefined ? -1 : accountIds.indexOf(activeId);
-  const startIndex = activeIndex < 0 ? 0 : activeIndex + 1;
-  for (let offset = 0; offset < accountIds.length; offset += 1) {
-    const accountId = accountIds[(startIndex + offset) % accountIds.length]!;
-    if (activeId !== undefined && accountId === activeId) continue;
-    if (!isAntigravityAccountInCooldown(accountId, now)) return accountId;
+function parseRetryAfterMs(value: string | null | undefined, now: number): number | undefined {
+  const text = value?.trim();
+  if (!text) return undefined;
+  if (/^\d+(?:\.\d+)?$/.test(text)) {
+    const seconds = Number(text);
+    if (Number.isFinite(seconds) && seconds >= 0) return Math.min(Math.ceil(seconds * 1000), MAX_COOLDOWN_MS);
   }
-  return undefined;
+  const timestamp = Date.parse(text);
+  if (!Number.isFinite(timestamp)) return undefined;
+  const delay = timestamp - now;
+  return delay > 0 ? Math.min(delay, MAX_COOLDOWN_MS) : undefined;
 }
 
-export function sweepExpiredAntigravityRoutingHealth(now = Date.now()): number {
-  let removed = 0;
-  for (const [accountId, health] of accountHealth) {
-    if (health.cooldownUntil > now) continue;
-    accountHealth.delete(accountId);
-    removed += 1;
-  }
-  return removed;
+export function antigravitySessionKeyFromParts(input: {
+  clientThreadId?: string | null;
+  sessionIdHeader?: string | null;
+  threadIdHeader?: string | null;
+  promptCacheKey?: string | null;
+}): string | null {
+  const preferred = [input.clientThreadId, input.sessionIdHeader, input.threadIdHeader, input.promptCacheKey]
+    .map(trimmed)
+    .find(Boolean);
+  if (!preferred) return null;
+  return affinityKey(preferred);
 }
 
-export function clearAntigravityAccountCooldown(accountId: string): void {
-  accountHealth.delete(accountId);
+function pruneExpiredAffinity(now: number): void {
+  for (const [key, entry] of sessionAffinity) {
+    if (now - entry.lastUsedAt > AFFINITY_IDLE_TTL_MS) sessionAffinity.delete(key);
+  }
+  if (sessionAffinity.size <= MAX_AFFINITY_ENTRIES) return;
+  const entries = [...sessionAffinity.entries()].sort((a, b) => a[1].lastUsedAt - b[1].lastUsedAt);
+  for (let i = 0; i < sessionAffinity.size - MAX_AFFINITY_ENTRIES; i += 1) {
+    sessionAffinity.delete(entries[i]![0]);
+  }
 }
 
-/** Test helper: reset process-local cooldown state between cases. */
-export function clearAntigravityRoutingHealthForTests(): void {
+export function clearAntigravityRoutingState(): void {
   accountHealth.clear();
+  sessionAffinity.clear();
 }
 
-export function isAntigravityRateLimitStickWait(accountId: string, now = Date.now()): boolean {
-  const health = getAntigravityAccountCooldown(accountId, now);
-  if (!health || health.reason !== "rate_limited") return false;
-  const remaining = health.cooldownUntil - now;
-  return remaining > 0 && remaining <= ANTIGRAVITY_STICK_WAIT_MAX_MS;
+export function antigravitySessionAffinitySizeForTests(): number {
+  return sessionAffinity.size;
 }
 
-/** Milliseconds to wait before retrying the same account on 429, or null when failover should run. */
-export function antigravity429StickWaitMs(accountId: string, now = Date.now()): number | null {
-  if (!isAntigravityRateLimitStickWait(accountId, now)) return null;
-  const health = getAntigravityAccountCooldown(accountId, now);
-  if (!health) return null;
-  const remaining = health.cooldownUntil - now;
-  return remaining > 0 ? remaining : null;
+export function bindAntigravitySessionAffinity(
+  sessionKey: string | null | undefined,
+  accountId: string,
+  now = Date.now(),
+): void {
+  const key = affinityKey(sessionKey);
+  const account = trimmed(accountId);
+  if (!key || !account) return;
+  sessionAffinity.set(key, { accountId: account, lastUsedAt: now });
+  pruneExpiredAffinity(now);
 }
 
-export function isAntigravityAccountEligible(accountId: string, now = Date.now()): boolean {
-  if (!isAntigravityAccountInCooldown(accountId, now)) return true;
-  return isAntigravityRateLimitStickWait(accountId, now);
+export function clearAntigravitySessionAffinityForAccount(accountId: string): void {
+  for (const [key, entry] of sessionAffinity) {
+    if (entry.accountId === accountId) sessionAffinity.delete(key);
+  }
 }
 
-export function getEligibleAntigravityAccounts(now = Date.now()): string[] {
-  const set = getAccountSet(POOL_KEY_ANTIGRAVITY);
-  if (!set) return [];
-  return set.accounts
-    .filter(account => isAntigravityAccountEligible(account.id, now))
-    .map(account => account.id);
+export function clearAntigravitySessionAffinity(): void {
+  sessionAffinity.clear();
 }
 
-export type AntigravityAccountSelectionReason =
-  | "affinity"
-  | "active"
-  | "failover"
-  | "none"
-  | "all-cooled";
-
-export interface AntigravityAccountSelection {
-  accountId: string | null;
-  reason: AntigravityAccountSelectionReason;
+/**
+ * Manual selection resets session affinity and clears any stale cooldown
+ * on the manually chosen account so requests immediately honor the user's choice.
+ */
+export function resetAntigravityRoutingForManualSelection(accountId: string): void {
+  sessionAffinity.clear();
+  clearAntigravityAccountCooldown(accountId);
 }
 
-function bindAntigravityAffinityIfPossible(
-  sessionKey: string | null | undefined,
-  accountId: string,
-  now: number,
-): void {
-  bindSessionAffinity(POOL_KEY_ANTIGRAVITY, sessionKey, accountId, now);
+/** Remove only the local routing state owned by one deleted Antigravity account. */
+export function clearAntigravityRoutingStateForAccount(accountId: string): void {
+  clearAntigravityAccountCooldown(accountId);
+  clearAntigravitySessionAffinityForAccount(accountId);
 }
 
-/**
- * Failover-only account pick: stick bound sessions, default new sessions to the store active
- * account, and hop only when the chosen account is cooled (except short rate-limit stick-wait).
- * Does not call setActiveAccount.
- */
-export function resolveAntigravityAccountForSession(
-  sessionKey: string | null | undefined,
+export function getAntigravityAccountHealthSnapshot(
+  accountId: string,
   now = Date.now(),
-): AntigravityAccountSelection {
-  const set = getAccountSet(POOL_KEY_ANTIGRAVITY);
-  if (!set || set.accounts.length === 0) return { accountId: null, reason: "none" };
-
-  const accountIds = set.accounts.map(account => account.id);
-  const activeId = set.activeAccountId;
-  const key = normalizeAffinityComponent(sessionKey);
-
-  if (key) {
-    const affined = getSessionAffinity(POOL_KEY_ANTIGRAVITY, key, now);
-    if (affined) {
-      if (isAntigravityAccountEligible(affined.accountId, now)) {
-        touchSessionAffinity(POOL_KEY_ANTIGRAVITY, key, now);
-        return { accountId: affined.accountId, reason: "affinity" };
-      }
-      const next = nextAntigravityAccount(accountIds, affined.accountId, now);
-      if (next) {
-        bindAntigravityAffinityIfPossible(sessionKey, next, now);
-        return { accountId: next, reason: "failover" };
-      }
-      clearSessionAffinityForAccount(POOL_KEY_ANTIGRAVITY, affined.accountId);
-      const anyCooled = accountIds.some(id => !isAntigravityAccountEligible(id, now));
-      return { accountId: null, reason: anyCooled ? "all-cooled" : "none" };
-    }
-  }
-
-  if (activeId && isAntigravityAccountEligible(activeId, now)) {
-    bindAntigravityAffinityIfPossible(sessionKey, activeId, now);
-    return { accountId: activeId, reason: "active" };
-  }
-
-  const next = nextAntigravityAccount(accountIds, activeId, now);
-  if (next) {
-    bindAntigravityAffinityIfPossible(sessionKey, next, now);
-    return { accountId: next, reason: "failover" };
+): { cooldownUntil: number; cooldownSource: CooldownSource; cooldownKind: AntigravityCooldownKind } | null {
+  const health = accountHealth.get(accountId);
+  if (!health) return null;
+  if (health.cooldownUntil <= now) {
+    accountHealth.delete(accountId);
+    return null;
   }
-
-  const anyCooled = accountIds.some(id => !isAntigravityAccountEligible(id, now));
-  return { accountId: null, reason: anyCooled ? "all-cooled" : "none" };
+  return { ...health };
 }
 
-export function bindAntigravitySessionAffinity(
-  sessionKey: string | null | undefined,
+export function recordAntigravityCooldown(
   accountId: string,
+  retryAfterHeader?: string | null,
   now = Date.now(),
-): void {
-  bindAntigravityAffinityIfPossible(sessionKey, accountId, now);
+  cooldownKind: AntigravityCooldownKind = "rate-limit",
+  source?: "default" | "retry-after" | "synthetic",
+): number {
+  const delay = parseRetryAfterMs(retryAfterHeader, now) ?? (cooldownKind === "geoblock" ? MAX_COOLDOWN_MS : DEFAULT_COOLDOWN_MS);
+  const targetUntil = now + delay;
+  const cooldownSource = source ?? (retryAfterHeader?.trim() ? "retry-after" : "default");
+  const existing = accountHealth.get(accountId);
+  if (existing && existing.cooldownUntil > now) {
+    const effectiveUntil = Math.max(existing.cooldownUntil, targetUntil);
+    const effectiveKind = (existing.cooldownKind === "geoblock" || cooldownKind === "geoblock")
+      ? "geoblock"
+      : (cooldownKind === "quota" || existing.cooldownKind === "quota")
+        ? "quota"
+        : "rate-limit";
+    const effectiveSource = (source === "synthetic" || existing.cooldownSource === "synthetic")
+      ? "synthetic"
+      : (retryAfterHeader?.trim() ? "retry-after" : existing.cooldownSource);
+    accountHealth.set(accountId, {
+      cooldownUntil: effectiveUntil,
+      cooldownSource: effectiveSource,
+      cooldownKind: effectiveKind,
+    });
+    sweepExpiredOnWrite(now);
+    return effectiveUntil;
+  }
+  accountHealth.set(accountId, {
+    cooldownUntil: targetUntil,
+    cooldownSource,
+    cooldownKind,
+  });
+  sweepExpiredOnWrite(now);
+  return targetUntil;
 }
 
-/**
- * Pick the next Antigravity account after a rate-limit 429. Cooldown is recorded upstream
- * (google-http). Does not promote the global active account.
- */
-export function rotateAntigravityAccountOn429(
-  failedAccountId: string,
-  sessionKey: string | null | undefined,
-  now = Date.now(),
-): string | null {
-  if (antigravity429StickWaitMs(failedAccountId, now) !== null) return null;
-
-  const set = getAccountSet(POOL_KEY_ANTIGRAVITY);
-  if (!set) return null;
-  const accountIds = set.accounts.map(account => account.id);
-
-  clearSessionAffinityForAccount(POOL_KEY_ANTIGRAVITY, failedAccountId);
-
-  const next = nextAntigravityAccount(accountIds, failedAccountId, now);
-  if (!next) return null;
+export function clearAntigravityAccountCooldown(accountId: string): boolean {
+  return accountHealth.delete(accountId);
+}
 
-  bindAntigravityAffinityIfPossible(sessionKey, next, now);
-  return next;
+export function isAntigravityAccountInCooldown(accountId: string, now = Date.now()): boolean {
+  return getAntigravityAccountHealthSnapshot(accountId, now) !== null;
 }
 
-/** Test / logout helper. */
-export function clearAntigravityAccountPoolState(): void {
-  clearAffinityState(POOL_KEY_ANTIGRAVITY);
+export function sweepExpiredAntigravityRoutingHealth(now = Date.now()): number {
+  let removed = 0;
+  for (const [accountId, health] of accountHealth) {
+    if (health.cooldownUntil <= now) {
+      accountHealth.delete(accountId);
+      removed += 1;
+    }
+  }
+  return removed;
 }
 
-export function antigravitySessionKeyFromParts(input: {
-  sessionIdHeader?: string | null;
-  threadIdHeader?: string | null;
-  promptCacheKey?: string | null;
-  clientThreadId?: string | null;
-  promptCacheKeyIsSharedCohort?: boolean;
-}): string | null {
-  return buildSessionKeyFromParts(input);
+export function retryableAntigravity429DelayMs(
+  retryAfterHeader: string | null | undefined,
+  now = Date.now(),
+): number | null {
+  const delay = parseRetryAfterMs(retryAfterHeader, now);
+  return delay !== undefined && delay <= MAX_SHORT_RETRY_MS ? delay : null;
 }
 
 export const ANTIGRAVITY_MISSING_PROJECT_MESSAGE =
@@ -314,3 +238,125 @@ export function bindAntigravityProject<T extends { project?: string }>(
   }
   return { ok: true, provider: { ...provider, project } };
 }
+
+export type AntigravityAccountSelectionReason =
+  | "affinity"
+  | "active"
+  | "active-cooled"
+  | "active-needs-reauth"
+  | "missing-affinity"
+  | "none";
+
+export interface AntigravityAccountSelection {
+  accountId: string | null;
+  reason: AntigravityAccountSelectionReason;
+  cooldownUntil?: number;
+  cooldownKind?: AntigravityCooldownKind;
+}
+
+export function resolveAntigravityAccountForSession(
+  sessionKey: string | null | undefined,
+  now = Date.now(),
+): AntigravityAccountSelection {
+  pruneExpiredAffinity(now);
+  const key = affinityKey(sessionKey);
+  const set = getAccountSet(PROVIDER);
+  if (!set || set.accounts.length === 0) return { accountId: null, reason: "none" };
+
+  if (key) {
+    const bound = sessionAffinity.get(key);
+    if (bound) {
+      const account = set.accounts.find(candidate => candidate.id === bound.accountId);
+      if (!account) {
+        sessionAffinity.delete(key);
+      } else {
+        bound.lastUsedAt = now;
+        if (account.needsReauth === true) return { accountId: account.id, reason: "active-needs-reauth" };
+        return { accountId: account.id, reason: "affinity", ...(getAntigravityAccountHealthSnapshot(account.id, now) ?? {}) };
+      }
+    }
+  }
+
+  const account = set.accounts.find(candidate => candidate.id === set.activeAccountId);
+  if (!account) return { accountId: null, reason: "none" };
+  if (account.needsReauth === true) return { accountId: account.id, reason: "active-needs-reauth" };
+  const health = getAntigravityAccountHealthSnapshot(account.id, now);
+  if (key) bindAntigravitySessionAffinity(key, account.id, now);
+  return {
+    accountId: account.id,
+    reason: health ? "active-cooled" : "active",
+    ...(health ?? {}),
+  };
+}
+
+const RATE_LIMIT_CODES = new Set(["RATE_LIMIT_EXCEEDED", "TOO_MANY_REQUESTS"]);
+const QUOTA_CODES = new Set(["QUOTA_EXCEEDED"]);
+const GEO_CODES = new Set(["LOCATION_NOT_SUPPORTED", "REGION_NOT_SUPPORTED", "GEO_BLOCKED"]);
+
+export function normalizeAntigravityProviderError(value: unknown): AntigravityProviderError | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record = value as Record<string, unknown>;
+  // Google JSON errors use `{ code: <HTTP number>, status: <enum string>, message }`.
+  // Keep accepting the internal `{ code: <enum>, status: <HTTP number> }` shape for
+  // existing callers and fixtures, but normalize both to one observer contract.
+  const numericCode = typeof record.code === "number" && Number.isInteger(record.code) ? record.code : undefined;
+  const numericStatus = typeof record.status === "number" && Number.isInteger(record.status) ? record.status : undefined;
+  const enumCode = typeof record.code === "string" ? record.code.trim().toUpperCase() : undefined;
+  const enumStatus = typeof record.status === "string" ? record.status.trim().toUpperCase() : undefined;
+  const code = enumStatus ?? enumCode;
+  const status = numericCode ?? numericStatus;
+  const message = typeof record.message === "string" ? record.message.trim().slice(0, 512) : undefined;
+  if (!code && status === undefined) return null;
+  return {
+    ...(code ? { code } : {}),
+    ...(status !== undefined ? { status } : {}),
+    ...(message ? { message } : {}),
+  };
+}
+
+export function classifyAntigravityProviderError(value: unknown): AntigravitySyntheticFailure | null {
+  const error = normalizeAntigravityProviderError(value);
+  if (!error) return null;
+  const message = error.message?.toLowerCase() ?? "";
+  if (QUOTA_CODES.has(error.code ?? "") || (error.code === "RESOURCE_EXHAUSTED" && /quota|resource[ _-]?exhausted/.test(message))) return "quota";
+  if (error.status === 429 || RATE_LIMIT_CODES.has(error.code ?? "") || (error.code === "RESOURCE_EXHAUSTED" && /rate[- ]limit|too many requests/.test(message))) {
+    return "rate-limit";
+  }
+  if (GEO_CODES.has(error.code ?? "") || (
+    (error.status === 403 || error.code === "PERMISSION_DENIED")
+    && /(?:location|country|region).{0,48}(?:not supported|unavailable|blocked|forbidden)|(?:not supported|unavailable|blocked|forbidden).{0,48}(?:location|country|region)/.test(message)
+  )) return "geoblock";
+  return null;
+}
+
+export function recordAntigravitySyntheticFailure(
+  accountId: string,
+  payload: unknown,
+  now = Date.now(),
+): AntigravitySyntheticFailure | null {
+  const failure = classifyAntigravityProviderError(payload);
+  if (!failure) return null;
+  const delay = failure === "geoblock" ? MAX_COOLDOWN_MS : DEFAULT_COOLDOWN_MS;
+  const targetUntil = now + delay;
+  const existing = accountHealth.get(accountId);
+  if (existing && existing.cooldownUntil > now) {
+    const effectiveUntil = Math.max(existing.cooldownUntil, targetUntil);
+    const effectiveKind = (existing.cooldownKind === "geoblock" || failure === "geoblock")
+      ? "geoblock"
+      : (failure === "quota" || existing.cooldownKind === "quota")
+        ? "quota"
+        : "rate-limit";
+    accountHealth.set(accountId, {
+      cooldownUntil: effectiveUntil,
+      cooldownSource: "synthetic",
+      cooldownKind: effectiveKind,
+    });
+    return failure;
+  }
+  accountHealth.set(accountId, {
+    cooldownUntil: targetUntil,
+    cooldownSource: "synthetic",
+    cooldownKind: failure,
+  });
+  return failure;
+}

package/src/oauth/callback-server.ts

@@ -276,10 +276,30 @@ export function parseCallbackInput(input: string): { kind: "url" | "query" | "ra
 
   try {
     const url = new URL(value);
+    // Also read the fragment. No provider configured here returns one — every
+    // OAuthCallbackFlow asks for response_type=code without response_mode, so
+    // the parameters land in the query — but a full URL whose parameters sit in
+    // the hash parses as a valid URL with no code, and reading only the query
+    // rejects it as "no authorization code found in input". This is the one
+    // place a fragment-returning provider would land, and the raw branch below
+    // already understands `code#state`.
+    //
+    // The query wins as a WHOLE when it carries the response, and the two
+    // fields are never mixed across collections. Reading `code` and `state`
+    // independently would accept `?state=<expected>#code=<other>` — one
+    // response assembled from two sources — which is exactly the confusion a
+    // state check exists to prevent. An authorization response arrives in one
+    // place; treat it that way.
+    //
+    // Only `code` and `state` are read — never a token. This repo does not
+    // implement the implicit grant and a paste field must not become the place
+    // it appears.
+    const fragment = new URLSearchParams(url.hash.replace(/^#/, ""));
+    const source = url.searchParams.has("code") ? url.searchParams : fragment;
     return {
       kind: "url",
-      code: url.searchParams.get("code") ?? undefined,
-      state: url.searchParams.get("state") ?? undefined,
+      code: source.get("code") ?? undefined,
+      state: source.get("state") ?? undefined,
     };
   } catch {
     // Not a URL - check for query string format

package/src/oauth/command-code.ts

@@ -1,7 +1,6 @@
 import type { OAuthController, OAuthCredentials } from "./types";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { isAddrInUse } from "../server/ports";
 import { parseCallbackInput } from "./callback-server";
 
 const COMMAND_CODE_STUDIO_URL = "https://commandcode.ai";
@@ -115,21 +114,11 @@ function createCallbackServer(state: string): {
       return Response.json({ success: false, error: message }, { status: 400, headers });
     }
   };
-  const create = (port: number): Array<ReturnType<typeof Bun.serve>> => {
-    // The advertised callback host is `127.0.0.1`; on Windows `localhost` commonly resolves to `::1`
-    // first, so also bind the IPv6 loopback best-effort (mirrors the shared OAuthCallbackFlow).
-    const servers = [Bun.serve({ hostname: "127.0.0.1", port, fetch })];
-    try {
-      servers.push(Bun.serve({ hostname: "::1", port: servers[0].port, fetch }));
-    } catch (error) {
-      if (isAddrInUse(error)) {
-        for (const server of servers) server.stop(true);
-        throw error;
-      }
-      // IPv6 unsupported (EAFNOSUPPORT etc.) degrades to the IPv4-only listener.
-    }
-    return servers;
-  };
+  const create = (port: number): Array<ReturnType<typeof Bun.serve>> => [
+    // The advertised callback host is explicitly IPv4, so an IPv6 listener is
+    // unnecessary and can conflict with this socket on dual-stack runtimes.
+    Bun.serve({ hostname: "127.0.0.1", port, fetch }),
+  ];
   try {
     return { servers: create(COMMAND_CODE_CALLBACK_PORT), callback };
   } catch {