@bitkyc08/opencodex 2.6.17 → 2.6.18

package/src/codex-shim.ts

@@ -3,6 +3,7 @@ import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync,
 import { getConfigDir } from "./config";
 import { durableBunPath } from "./bun-runtime";
 import { serviceApiTokenFilePath } from "./service-secrets";
+import { windowsEnvIndirectBatchValue } from "./win-paths";
 
 const SHIM_MARKER = "opencodex codex autostart shim";
 let lastShimDiscoveryError: string | null = null;
@@ -96,8 +97,11 @@ function findWindowsCodexTargets(): ShimFileState[] | null {
 
     const cmd = join(dir, "codex.cmd");
     const ps1 = join(dir, "codex.ps1");
+    // npm also installs an extensionless `codex` sh launcher for Git-Bash/MSYS shells;
+    // leaving it unshimmed means Git-Bash users silently get no autostart.
+    const gitBashLauncher = join(dir, "codex");
     const targets: ShimFileState[] = [];
-    for (const path of [cmd, ps1]) {
+    for (const path of [cmd, ps1, gitBashLauncher]) {
       if (!existsSync(path) || isShim(path)) continue;
       try {
         if (!lstatSync(path).isDirectory()) {
@@ -119,9 +123,8 @@ function shQuote(value: string): string {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
 
-export function buildUnixCodexShim(realCodexPath: string, bunPath: string, cliPath: string): string {
+export function buildUnixCodexShim(realCodexPath: string, bunPath: string, cliPath: string, tokenFile = serviceApiTokenFilePath()): string {
   const internalCommands = CODEX_INTERNAL_COMMANDS.join("|");
-  const tokenFile = serviceApiTokenFilePath();
   return `#!/usr/bin/env sh
 # ${SHIM_MARKER}
 if [ -z "$OPENCODEX_API_AUTH_TOKEN" ] && [ -f ${shQuote(tokenFile)} ]; then
@@ -150,7 +153,12 @@ function windowsBatchValue(value: string): string {
 }
 
 function windowsBatchSet(name: string, value: string): string {
-  return `set "${name}=${windowsBatchValue(value)}"`;
+  // Paths are rewritten to %USERPROFILE%-style env indirection: cmd.exe parses .cmd
+  // files in the OEM codepage, so a literal non-ASCII profile prefix (Korean/Chinese
+  // usernames) written as UTF-8 turns to mojibake. The env token expands natively in
+  // the right codepage at parse time; no `chcp` here — this shim runs in the USER's
+  // console and must not leak a codepage change into it.
+  return `set "${name}=${windowsEnvIndirectBatchValue(value, windowsBatchValue)}"`;
 }
 
 export function buildWindowsCodexShim(realCodexPath: string, bunPath: string, cliPath: string): string {
@@ -214,13 +222,28 @@ function writeState(state: ShimState): void {
   writeFileSync(statePath(), JSON.stringify(state, null, 2) + "\n", "utf8");
 }
 
+/** Git-Bash accepts `C:/...` but not backslashed paths inside sh scripts. */
+function gitBashPath(path: string): string {
+  return path.replace(/\\/g, "/");
+}
+
 function writeShim(wrapperPath: string, realCodexPath: string): void {
   const { bun, cli } = cliEntry();
   if (process.platform === "win32") {
-    if (wrapperPath.toLowerCase().endsWith(".ps1")) {
-      writeFileSync(wrapperPath, buildWindowsPowerShellCodexShim(realCodexPath, bun, cli), "utf8");
-    } else {
+    const lower = wrapperPath.toLowerCase();
+    if (lower.endsWith(".ps1")) {
+      // UTF-8 BOM: Windows PowerShell 5.1 decodes BOM-less .ps1 files in the ANSI
+      // codepage, which mangles non-ASCII paths embedded in the shim.
+      writeFileSync(wrapperPath, `\uFEFF${buildWindowsPowerShellCodexShim(realCodexPath, bun, cli)}`, "utf8");
+    } else if (lower.endsWith(".cmd") || lower.endsWith(".bat")) {
       writeFileSync(wrapperPath, buildWindowsCodexShim(realCodexPath, bun, cli), "utf8");
+    } else {
+      // Extensionless Git-Bash sh launcher: sh shim with forward-slash paths.
+      writeFileSync(
+        wrapperPath,
+        buildUnixCodexShim(gitBashPath(realCodexPath), gitBashPath(bun), gitBashPath(cli), gitBashPath(serviceApiTokenFilePath())),
+        "utf8",
+      );
     }
   } else {
     writeFileSync(wrapperPath, buildUnixCodexShim(realCodexPath, bun, cli), "utf8");

package/src/codex-sync.ts

@@ -0,0 +1,70 @@
+import { injectCodexConfig } from "./codex-inject";
+import { refreshCodexModelCatalog } from "./codex-refresh";
+import { applyProxyEnv, loadConfig } from "./config";
+import type { OcxConfig } from "./types";
+
+export interface CodexSyncResult {
+  ok: boolean;
+  added: number;
+  catalogPath: string | null;
+  catalogExists: boolean;
+  cacheSynced: boolean;
+  message: string;
+  warning?: string;
+}
+
+interface CodexSyncDeps {
+  refreshCodexModelCatalog: typeof refreshCodexModelCatalog;
+  injectCodexConfig: typeof injectCodexConfig;
+}
+
+const defaultDeps: CodexSyncDeps = {
+  refreshCodexModelCatalog,
+  injectCodexConfig,
+};
+
+export async function syncModelsToCodex(
+  port?: number,
+  config: OcxConfig = loadConfig(),
+  log: Pick<Console, "log" | "error"> | null = console,
+  deps: CodexSyncDeps = defaultDeps,
+): Promise<CodexSyncResult> {
+  applyProxyEnv(config); // `ocx ensure`/`ocx sync` fetch provider models outside the server process
+  const p = port ?? config.port ?? 10100;
+  let added = 0;
+  let catalogPath: string | null = null;
+  let catalogPathForInjection: string | null | undefined;
+  let catalogExists = false;
+  let cacheSynced = false;
+  let warning: string | undefined;
+
+  try {
+    const cat = await deps.refreshCodexModelCatalog(config);
+    added = cat.added;
+    catalogExists = cat.catalogExists;
+    cacheSynced = cat.cacheSynced;
+    catalogPathForInjection = cat.catalogExists ? cat.path : null;
+    catalogPath = catalogPathForInjection;
+    if (cat.added > 0) {
+      log?.log(`   + ${cat.added} models appended to Codex catalog (${cat.path})`);
+    } else if (!cat.catalogExists) {
+      warning = "catalog sync skipped: no Codex catalog source found; keeping Codex's native catalog.";
+      log?.error(warning);
+    }
+  } catch (e) {
+    warning = `catalog sync skipped: ${e instanceof Error ? e.message : String(e)}`;
+    log?.error(warning);
+  }
+
+  const result = await deps.injectCodexConfig(p, config, { catalogPath: catalogPathForInjection });
+  log?.log(result.message);
+  return {
+    ok: result.success,
+    added,
+    catalogPath,
+    catalogExists,
+    cacheSynced,
+    message: result.message,
+    ...(warning ? { warning } : {}),
+  };
+}

package/src/config.ts

@@ -16,12 +16,23 @@ export function atomicWriteFile(path: string, content: string): void {
   renameSync(tmp, path);
 }
 
+/**
+ * Expand a leading `~` to the home directory in user-supplied paths
+ * (OPENCODEX_HOME/CODEX_HOME set from GUIs/service files where no shell expanded it).
+ * `~user` and `%VAR%`/`$VAR` forms pass through untouched — those belong to the shell.
+ */
+export function expandUserPath(raw: string): string {
+  if (raw === "~") return homedir();
+  if (raw.startsWith("~/") || raw.startsWith("~\\")) return join(homedir(), raw.slice(2));
+  return raw;
+}
+
 let resolvedConfigDirCache: { raw: string | undefined; path: string } | null = null;
 
 function resolveConfigDir(): string {
   const raw = process.env["OPENCODEX_HOME"]?.trim() || undefined;
   if (resolvedConfigDirCache && resolvedConfigDirCache.raw === raw) return resolvedConfigDirCache.path;
-  const path = raw ? resolve(raw) : join(homedir(), ".opencodex");
+  const path = raw ? resolve(expandUserPath(raw)) : join(homedir(), ".opencodex");
   resolvedConfigDirCache = { raw, path };
   return path;
 }
@@ -308,6 +319,30 @@ export function resolveEnvValue(value: string | undefined): string | undefined {
   return value;
 }
 
+/**
+ * Mirror `config.proxy` into HTTP(S)_PROXY env vars so Bun's native fetch routes every outbound
+ * provider call through the proxy — no per-callsite changes (verified: Bun honors these plus
+ * NO_PROXY). User-set env vars always win; localhost/127.0.0.1 are appended to NO_PROXY so the
+ * CLI's own health checks and running-proxy API calls stay direct. Call once per process entry
+ * that makes outbound provider requests (server start, catalog sync).
+ */
+export function applyProxyEnv(config: OcxConfig): void {
+  const proxy = resolveEnvValue(config.proxy);
+  if (!proxy) return;
+  if (!process.env.HTTP_PROXY?.trim() && !process.env.http_proxy?.trim()) process.env.HTTP_PROXY = proxy;
+  if (!process.env.HTTPS_PROXY?.trim() && !process.env.https_proxy?.trim()) process.env.HTTPS_PROXY = proxy;
+  const existing = process.env.NO_PROXY ?? process.env.no_proxy ?? "";
+  const entries = existing.split(",").map(s => s.trim()).filter(Boolean);
+  const seen = new Set(entries.map(e => e.toLowerCase()));
+  for (const host of ["localhost", "127.0.0.1", "::1", "[::1]"]) {
+    if (!seen.has(host)) {
+      entries.push(host);
+      seen.add(host);
+    }
+  }
+  process.env.NO_PROXY = entries.join(",");
+}
+
 export function writePid(pid: number): void {
   const dir = getConfigDir();
   if (!existsSync(dir)) {
@@ -392,7 +427,7 @@ function warnConfigRepaired(configPath: string, error: z.ZodError): void {
   console.error(`opencodex config at ${configPath}: repaired missing field(s) [${fields}] with defaults. Your providers and accounts are preserved.`);
 }
 
-function readPidFileValue(): number | null {
+export function readPidFileValue(): number | null {
   try {
     return parsePidFile(readFileSync(getPidPath(), "utf-8"));
   } catch {
@@ -407,6 +442,27 @@ export function removeRuntimePort(expectedPid?: number): void {
   } catch { /* ignore */ }
 }
 
+/**
+ * Snapshot-guarded stale-state purge: remove the pid/runtime files only when their content
+ * still matches what the caller saw BEFORE its liveness probe. A concurrent `ocx start` can
+ * write fresh records mid-probe; an unconditional purge would erase the new proxy's state.
+ */
+export function removePidIfValueIs(snapshot: number | null): void {
+  if (!existsSync(getPidPath())) return;
+  if (readPidFileValue() !== snapshot) return;
+  try {
+    unlinkSync(getPidPath());
+  } catch { /* ignore */ }
+}
+
+export function removeRuntimePortIfPidIs(snapshotPid: number | null): void {
+  const current = readRuntimePort();
+  if ((current?.pid ?? null) !== snapshotPid) return;
+  try {
+    unlinkSync(getRuntimePortPath());
+  } catch { /* ignore */ }
+}
+
 export function parsePidFile(raw: string): number | null {
   const trimmed = raw.trim();
   if (!/^\d+$/.test(trimmed)) return null;

package/src/doctor.ts

@@ -10,7 +10,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
-import { getConfigDir, getConfigPath } from "./config";
+import { expandUserPath, getConfigDir, getConfigPath } from "./config";
 import { readCodexTokens } from "./codex-auth-collision";
 
 const WHAM_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
@@ -20,7 +20,9 @@ export type PathRow = { label: string; path: string; exists: boolean };
 
 export function resolveCodexHomeDir(): string {
   const raw = process.env["CODEX_HOME"]?.trim();
-  return raw ? resolve(raw) : join(homedir(), ".codex");
+  // `~` parity with the hardened runtime paths (codex-paths.ts) — a literal "~/..." here
+  // would report every Codex file as missing while the runtime happily uses the real dir.
+  return raw ? resolve(expandUserPath(raw)) : join(homedir(), ".codex");
 }
 
 export function collectPaths(): PathRow[] {

package/src/index.ts

@@ -3,6 +3,7 @@ export { parseRequest } from "./responses/parser";
 export { bridgeToResponsesSSE, buildResponseJSON, formatErrorResponse } from "./bridge";
 export { createAnthropicAdapter } from "./adapters/anthropic";
 export { createAzureAdapter } from "./adapters/azure";
+export { createCursorAdapter } from "./adapters/cursor";
 export { createGoogleAdapter } from "./adapters/google";
 export { createOpenAIChatAdapter } from "./adapters/openai-chat";
 export { createResponsesPassthroughAdapter } from "./adapters/openai-responses";

package/src/model-cache.ts

@@ -19,6 +19,21 @@ interface CacheEntry {
 
 const cache = new Map<string, CacheEntry>();
 
+/** Cooldown after a failed live `/models` fetch, so a dead/unreachable provider doesn't re-pay
+ * the full fetch timeout on every catalog poll (issue #54: UI stalls behind corporate proxies). */
+export const MODELS_FETCH_FAILURE_COOLDOWN_MS = 30_000;
+
+const failureAt = new Map<string, number>();
+
+export function markModelsFetchFailure(provider: string, now = Date.now()): void {
+  failureAt.set(provider, now);
+}
+
+export function isModelsFetchCoolingDown(provider: string, cooldownMs = MODELS_FETCH_FAILURE_COOLDOWN_MS, now = Date.now()): boolean {
+  const at = failureAt.get(provider);
+  return at !== undefined && now - at < cooldownMs;
+}
+
 /** Fresh cached models for a provider, or null when absent/stale (caller should re-fetch). */
 export function getFreshCached(provider: string, ttlMs: number, now = Date.now()): CatalogModel[] | null {
   const entry = cache.get(provider);
@@ -37,6 +52,11 @@ export function setCached(provider: string, models: CatalogModel[], now = Date.n
 
 /** Drop one provider's cache (or all) so the next resolve forces a live re-fetch. */
 export function clearModelCache(provider?: string): void {
-  if (provider) cache.delete(provider);
-  else cache.clear();
+  if (provider) {
+    cache.delete(provider);
+    failureAt.delete(provider);
+  } else {
+    cache.clear();
+    failureAt.clear();
+  }
 }

package/src/oauth/callback-server.ts

@@ -8,6 +8,7 @@
  * Handles: port allocation (preferred → random fallback), callback server, CSRF state,
  * manual-input race, 300s timeout. Providers implement generateAuthUrl() + exchangeToken().
  */
+import { isAddrInUse } from "../ports";
 import type { OAuthController, OAuthCredentials } from "./types";
 
 const DEFAULT_TIMEOUT = 300_000;
@@ -36,6 +37,19 @@ function errorHtml(message: string): string {
 
 export type CallbackResult = { code: string; state: string };
 
+/**
+ * The redirect URI advertised to providers must stay `localhost` (it is what the OAuth
+ * apps have registered), but Windows commonly resolves `localhost` to `::1` first while
+ * we historically bound IPv4-only — the browser then hits refusal/timeouts/wrong server.
+ * When advertising `localhost` over an IPv4 loopback bind, also bind `::1` best-effort.
+ */
+export function loopbackBindHostnames(callbackHostname: string, bindHostname: string): string[] {
+  if (callbackHostname.trim().toLowerCase() === "localhost" && bindHostname === "127.0.0.1") {
+    return ["127.0.0.1", "::1"];
+  }
+  return [bindHostname];
+}
+
 export interface OAuthCallbackFlowOptions {
   preferredPort: number;
   callbackPath?: string;
@@ -96,7 +110,7 @@ export abstract class OAuthCallbackFlow {
   /** Execute the OAuth login flow. */
   async login(): Promise<OAuthCredentials> {
     const state = this.generateState();
-    const { server, redirectUri } = await this.#startCallbackServer(state);
+    const { servers, redirectUri } = await this.#startCallbackServer(state);
     try {
       const { url: authUrl, instructions } = await this.generateAuthUrl(state, redirectUri);
       this.ctrl.onAuth?.({ url: authUrl, instructions });
@@ -105,39 +119,53 @@ export abstract class OAuthCallbackFlow {
       this.ctrl.onProgress?.("Exchanging authorization code for tokens...");
       return await this.exchangeToken(code, state, redirectUri);
     } finally {
-      server.stop();
+      for (const server of servers) server.stop();
     }
   }
 
-  async #startCallbackServer(expectedState: string): Promise<{ server: BunServer; redirectUri: string }> {
+  async #startCallbackServer(expectedState: string): Promise<{ servers: BunServer[]; redirectUri: string }> {
     try {
-      const server = this.#createServer(this.preferredPort, expectedState);
+      const servers = this.#createServers(this.preferredPort, expectedState);
       if (this.redirectUri) {
-        return { server, redirectUri: this.redirectUri };
+        return { servers, redirectUri: this.redirectUri };
       }
       const redirectUri = `http://${this.callbackHostname}:${this.preferredPort}${this.callbackPath}`;
-      return { server, redirectUri };
+      return { servers, redirectUri };
     } catch {
       if (this.redirectUri) {
         throw new Error(
           `OAuth callback port ${this.preferredPort} unavailable; cannot fall back to a random port when redirectUri is set`,
         );
       }
-      const server = this.#createServer(0, expectedState);
-      const actualPort = server.port;
+      const servers = this.#createServers(0, expectedState);
+      const actualPort = servers[0].port;
       const redirectUri = `http://${this.callbackHostname}:${actualPort}${this.callbackPath}`;
       this.ctrl.onProgress?.(`Preferred port ${this.preferredPort} unavailable, using port ${actualPort}`);
-      return { server, redirectUri };
+      return { servers, redirectUri };
     }
   }
 
-  #createServer(port: number, expectedState: string): BunServer {
-    return Bun.serve({
-      hostname: this.callbackBindHostname,
-      port,
-      reusePort: false,
-      fetch: (req: Request) => this.#handleCallback(req, expectedState),
-    });
+  #createServers(port: number, expectedState: string): BunServer[] {
+    const fetch = (req: Request) => this.#handleCallback(req, expectedState);
+    const [primaryHost, ...extraHosts] = loopbackBindHostnames(this.callbackHostname, this.callbackBindHostname);
+    const primary = Bun.serve({ hostname: primaryHost, port, reusePort: false, fetch });
+    const servers = [primary];
+    for (const host of extraHosts) {
+      try {
+        servers.push(Bun.serve({ hostname: host, port: primary.port, reusePort: false, fetch }));
+      } catch (err) {
+        // extraHosts is only non-empty when we advertise ambiguous `localhost`. A foreign
+        // process HOLDING the IPv6 loopback port could then receive the browser's OAuth
+        // callback (localhost may resolve to ::1 first) — treat the whole port as unusable
+        // so the caller falls back to a fresh one. IPv6 merely unsupported/unavailable
+        // (EAFNOSUPPORT etc.) keeps the IPv4-only degradation.
+        if (isAddrInUse(err)) {
+          for (const server of servers) server.stop(true);
+          throw err;
+        }
+      }
+    }
+    return servers;
   }
 
   #handleCallback(req: Request, expectedState: string): Response {

package/src/oauth/cursor.ts

@@ -0,0 +1,188 @@
+/**
+ * Cursor OAuth — PKCE poll flow. Standalone: talks directly to cursor.com / api2.cursor.sh,
+ * with no dependency on a local Cursor IDE/CLI install or on jawcode. Ported from jawcode
+ * packages/ai/src/utils/oauth/cursor.ts and adapted to opencodex's OAuthController (see kimi.ts).
+ *
+ * Security: the login URL carries only the PKCE challenge (SHA-256 of the verifier); the verifier
+ * is sent only to /auth/poll. Tokens and the verifier are never logged — thrown errors and progress
+ * messages are status/string only.
+ */
+import { generatePKCE } from "./pkce";
+import type { OAuthController, OAuthCredentials } from "./types";
+
+const CURSOR_LOGIN_URL = "https://cursor.com/loginDeepControl";
+const CURSOR_POLL_URL = "https://api2.cursor.sh/auth/poll";
+const CURSOR_REFRESH_URL = "https://api2.cursor.sh/auth/exchange_user_api_key";
+
+const POLL_MAX_ATTEMPTS = 150;
+const POLL_BASE_DELAY_MS = 1000;
+const POLL_MAX_DELAY_MS = 10_000;
+const POLL_BACKOFF = 1.2;
+const EXPIRY_SKEW_MS = 5 * 60 * 1000;
+const FALLBACK_TTL_MS = 60 * 60 * 1000;
+
+const REFRESH_TIMEOUT_MS = 15_000;
+const REFRESH_ATTEMPTS = 3;
+const REFRESH_RETRY_BASE_MS = 300;
+
+export interface CursorAuthParams {
+  verifier: string;
+  challenge: string;
+  uuid: string;
+  loginUrl: string;
+}
+
+/** Generate PKCE params + the cursor.com deep-link login URL (challenge only — never the verifier). */
+export async function generateCursorAuthParams(): Promise<CursorAuthParams> {
+  const { verifier, challenge } = await generatePKCE();
+  const uuid = crypto.randomUUID();
+  const params = new URLSearchParams({ challenge, uuid, mode: "login", redirectTarget: "cli" });
+  return { verifier, challenge, uuid, loginUrl: `${CURSOR_LOGIN_URL}?${params.toString()}` };
+}
+
+/** Abort-aware delay (mirrors kimi.ts) — rejects if the controller signal aborts. */
+function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(new Error("Cursor login cancelled"));
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(new Error("Cursor login cancelled"));
+      },
+      { once: true },
+    );
+  });
+}
+
+/**
+ * Poll cursor.com for login completion. 404 = still pending (back off), 200 = tokens.
+ * `baseDelayMs` is injectable so tests can avoid the real 1s cadence; production uses the default.
+ */
+export async function pollCursorAuth(
+  uuid: string,
+  verifier: string,
+  signal?: AbortSignal,
+  baseDelayMs: number = POLL_BASE_DELAY_MS,
+): Promise<{ accessToken: string; refreshToken: string }> {
+  let delay = baseDelayMs;
+  let consecutiveErrors = 0;
+
+  for (let attempt = 0; attempt < POLL_MAX_ATTEMPTS; attempt++) {
+    await sleep(delay, signal);
+
+    try {
+      const url = `${CURSOR_POLL_URL}?uuid=${encodeURIComponent(uuid)}&verifier=${encodeURIComponent(verifier)}`;
+      const response = await fetch(url, { signal });
+
+      if (response.status === 404) {
+        consecutiveErrors = 0;
+        delay = Math.min(delay * POLL_BACKOFF, POLL_MAX_DELAY_MS);
+        continue;
+      }
+
+      if (response.ok) {
+        const data = (await response.json()) as { accessToken?: string; refreshToken?: string };
+        if (!data.accessToken || !data.refreshToken) {
+          throw new Error("Cursor auth response missing tokens");
+        }
+        return { accessToken: data.accessToken, refreshToken: data.refreshToken };
+      }
+
+      throw new Error(`Cursor auth poll failed: ${response.status}`);
+    } catch (err) {
+      if (signal?.aborted) throw err instanceof Error ? err : new Error("Cursor login cancelled");
+      consecutiveErrors++;
+      if (consecutiveErrors >= 3) {
+        throw new Error("Too many consecutive errors during Cursor auth polling");
+      }
+      delay = Math.min(delay * POLL_BACKOFF, POLL_MAX_DELAY_MS);
+    }
+  }
+
+  throw new Error("Cursor authentication polling timeout");
+}
+
+/** Run the standalone Cursor login: surface the URL via `onAuth`, then poll until approved. */
+export async function loginCursor(
+  ctrl: OAuthController,
+  pollBaseDelayMs: number = POLL_BASE_DELAY_MS,
+): Promise<OAuthCredentials> {
+  const { verifier, uuid, loginUrl } = await generateCursorAuthParams();
+  ctrl.onAuth?.({ url: loginUrl, instructions: "Approve the Cursor login in your browser, then return here." });
+  ctrl.onProgress?.("Waiting for Cursor login approval…");
+  const { accessToken, refreshToken } = await pollCursorAuth(uuid, verifier, ctrl.signal, pollBaseDelayMs);
+  return { access: accessToken, refresh: refreshToken, expires: getTokenExpiry(accessToken) };
+}
+
+function isRetryableRefreshStatus(status: number): boolean {
+  return status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+}
+
+function refreshRetryDelayMs(attempt: number): number {
+  const exp = REFRESH_RETRY_BASE_MS * 2 ** attempt;
+  return Math.floor(exp * (0.8 + Math.random() * 0.4));
+}
+
+function refreshTimeoutSignal(parent: AbortSignal | undefined): AbortSignal {
+  const timeout = AbortSignal.timeout(REFRESH_TIMEOUT_MS);
+  return parent ? AbortSignal.any([parent, timeout]) : timeout;
+}
+
+/**
+ * Exchange a refresh token for fresh credentials. Keeps the old refresh if the server omits one.
+ *
+ * Hardened with a per-attempt timeout and bounded retry on transient failures (network errors and
+ * 429/5xx). Non-retryable statuses (e.g. 401/403 from an expired refresh token) fail fast so the
+ * caller can surface a re-auth prompt. Errors never include the token value.
+ */
+export async function refreshCursorToken(refresh: string, signal?: AbortSignal): Promise<OAuthCredentials> {
+  let lastError: unknown;
+  for (let attempt = 0; attempt < REFRESH_ATTEMPTS; attempt++) {
+    if (signal?.aborted) throw signal.reason ?? new Error("Cursor token refresh aborted");
+    let response: Response;
+    try {
+      response = await fetch(CURSOR_REFRESH_URL, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${refresh}`, "Content-Type": "application/json" },
+        body: "{}",
+        signal: refreshTimeoutSignal(signal),
+      });
+    } catch (err) {
+      // Network/timeout error: retry unless the caller aborted or we are out of attempts.
+      if (signal?.aborted) throw err;
+      lastError = err;
+      if (attempt === REFRESH_ATTEMPTS - 1) break;
+      await new Promise(resolve => setTimeout(resolve, refreshRetryDelayMs(attempt)));
+      continue;
+    }
+    if (response.ok) {
+      const data = (await response.json()) as { accessToken?: string; refreshToken?: string };
+      if (!data.accessToken) throw new Error("Cursor refresh response missing access token");
+      return { access: data.accessToken, refresh: data.refreshToken || refresh, expires: getTokenExpiry(data.accessToken) };
+    }
+    if (!isRetryableRefreshStatus(response.status) || attempt === REFRESH_ATTEMPTS - 1) {
+      throw new Error(`Cursor token refresh failed: ${response.status}`);
+    }
+    lastError = new Error(`Cursor token refresh failed: ${response.status}`);
+    await response.body?.cancel().catch(() => {});
+    await new Promise(resolve => setTimeout(resolve, refreshRetryDelayMs(attempt)));
+  }
+  throw lastError instanceof Error ? lastError : new Error("Cursor token refresh failed");
+}
+
+/** Resolve a token's expiry (epoch ms) from its JWT `exp`, minus a 5-minute skew; ~1h fallback. */
+export function getTokenExpiry(token: string): number {
+  try {
+    const parts = token.split(".");
+    const payload = parts.length === 3 ? parts[1] : undefined;
+    if (payload) {
+      const decoded = JSON.parse(Buffer.from(payload, "base64url").toString("utf-8")) as { exp?: number };
+      if (typeof decoded.exp === "number") return decoded.exp * 1000 - EXPIRY_SKEW_MS;
+    }
+  } catch {
+    // fall through to the fixed fallback below
+  }
+  return Date.now() + FALLBACK_TTL_MS;
+}

package/src/oauth/index.ts

@@ -9,7 +9,9 @@ import { loginKimi, refreshKimiToken } from "./kimi";
 import { loginKiro, readKiroCliSqlite, refreshKiroToken } from "./kiro";
 import { loginChatGPT, refreshChatGPTToken } from "./chatgpt";
 import { loginAntigravity, refreshAntigravityToken } from "./google-antigravity";
+import { loginCursor, refreshCursorToken } from "./cursor";
 import { deriveOAuthDefaultModel, deriveOAuthProviderConfig } from "../providers/derive";
+import { effectiveGoogleMode } from "../providers/registry";
 
 const REFRESH_SKEW_MS = 60_000;
 const tokenRefreshes = new Map<string, Promise<string>>();
@@ -67,6 +69,12 @@ export const OAUTH_PROVIDERS: Record<string, OAuthProviderDef> = {
     providerConfig: oauthConfig("google-antigravity"),
     defaultModel: oauthDefaultModel("google-antigravity"),
   },
+  cursor: {
+    login: (ctrl) => loginCursor(ctrl),
+    refresh: refreshCursorToken,
+    providerConfig: oauthConfig("cursor"),
+    defaultModel: oauthDefaultModel("cursor"),
+  },
   chatgpt: {
     login: loginChatGPT,
     refresh: (rt) => refreshChatGPTToken(rt),
@@ -180,11 +188,21 @@ export async function resolveModelsAuthToken(name: string, prov: OcxProviderConf
  * Provider-correct `GET /models` request (URL + headers), so both model-listing paths fetch the
  * LIVE catalog correctly per adapter. Anthropic is the special case: its endpoint is `/v1/models`
  * (not `/models`), it needs `anthropic-version`, and it authenticates with `x-api-key` (key) or
- * `Authorization: Bearer` + the OAuth beta (oauth) — not a bare Bearer. Everyone else uses the
- * OpenAI-style `/models` + Bearer. Response shape is `{ data: [{ id, owned_by? }] }` for both.
+ * `Authorization: Bearer` + the OAuth beta (oauth) — not a bare Bearer. Google (ai-studio mode)
+ * is the other special case: `x-goog-api-key` + `/v1beta/models`, returning `{ models: [...] }`
+ * (parsed by the caller). Everyone else uses the OpenAI-style `/models` + Bearer with a
+ * `{ data: [{ id, owned_by? }] }` response.
  */
-export function buildModelsRequest(prov: OcxProviderConfig, apiKey: string | undefined): { url: string; headers: Record<string, string> } {
+export function buildModelsRequest(prov: OcxProviderConfig, apiKey: string | undefined, providerName = ""): { url: string; headers: Record<string, string> } {
   const headers: Record<string, string> = { ...(prov.headers ?? {}) };
+  if (effectiveGoogleMode(providerName, prov) === "ai-studio") {
+    // Generative Language API: API key goes in x-goog-api-key (never Authorization: Bearer),
+    // models live under /v1beta (v1 misses preview models), and pageSize maxes at 1000 —
+    // enough to list everything without a pageToken loop. Vertex/antigravity keep the
+    // generic branch (they fall back to their static model lists).
+    if (apiKey) headers["x-goog-api-key"] = apiKey;
+    return { url: `${prov.baseUrl}/v1beta/models?pageSize=1000`, headers };
+  }
   if (prov.adapter === "anthropic") {
     headers["anthropic-version"] = "2023-06-01";
     if (prov.authMode === "oauth") {
@@ -292,6 +310,14 @@ export function getLoginStatus(provider: string): { loggedIn: boolean; email?: s
   return { loggedIn: !!cred, email: maskEmail(cred?.email) ?? undefined, source: cred?.source, error: st?.error, done: st?.done ?? false };
 }
 
+/** Token-safe per-provider login state for the CLI `ocx status` logins section (no tokens, masked email). */
+export function oauthLoginSummary(): Array<{ provider: string; loggedIn: boolean; email?: string }> {
+  return listOAuthProviders().map(provider => {
+    const status = getLoginStatus(provider);
+    return { provider, loggedIn: status.loggedIn, ...(status.email ? { email: status.email } : {}) };
+  });
+}
+
 export function clearLoginState(provider: string): void {
   loginAbort.get(provider)?.abort("cleared");
   loginAbort.delete(provider);