@bitkyc08/opencodex 2.41.0 → 2.42.0

package/src/generated/compatibility-version.json

@@ -10,7 +10,7 @@
     },
     {
       "path": "package.json",
-      "sha256": "47de57e8a70dd7d845a202d2863bcb8b0a27b4f842de035a18565f8dcf104ebf"
+      "sha256": "583fb118e7f8db57d275f6d81958a67042afa446eb6d78f218f588c8812d5272"
     },
     {
       "path": "scripts/model-metadata.source.json",
@@ -194,7 +194,7 @@
     },
     {
       "path": "src/adapters/cursor/protobuf-request.ts",
-      "sha256": "ce38936510a5999b47b207e540a434929b1fe18e4d255d9e25c788ec73846ab0"
+      "sha256": "3e2aa6f21bd9e6c4d4d78480bb1755424828fd41bc50361bb7696812cd25e62e"
     },
     {
       "path": "src/adapters/cursor/request-builder.ts",
@@ -266,7 +266,7 @@
     },
     {
       "path": "src/adapters/identity.ts",
-      "sha256": "ee5ecb8164e70da97e2e75495a3abc909abcf058e49609325d6b473c3634110f"
+      "sha256": "21a147b96b5c5d6741d1b793be71d8b73944649f84f0c4c351cd149d9bf9e562"
     },
     {
       "path": "src/adapters/image.ts",
@@ -342,7 +342,7 @@
     },
     {
       "path": "src/adapters/openai-responses.ts",
-      "sha256": "4a12d138aca9dd1e56ef6d11907aa69a143acd9e1534d991806d217dbe975890"
+      "sha256": "19e94674fedee992fd52ac88c33e9d1aaeaf5a310d296698ee92b4bbeaaa9819"
     },
     {
       "path": "src/adapters/registry.ts",
@@ -378,7 +378,7 @@
     },
     {
       "path": "src/bridge.ts",
-      "sha256": "a88d4ef081496d93610194cf1bd3c4befb68b088f91338edc709b795cdc55cae"
+      "sha256": "6dc37628f3651a8db77d528265b87ca6c61e9ede9e49808c55c6b6e721ec38dc"
     },
     {
       "path": "src/chat/inbound.ts",
@@ -470,7 +470,7 @@
     },
     {
       "path": "src/cli/account-auth.ts",
-      "sha256": "6144462a5dbd94a2da1942ac0266a633eb977601ba3f316044ab503af802672b"
+      "sha256": "afabb1f192fbb1be02fd60315deba1c6ed906a771cf6ec4374090166fea9e944"
     },
     {
       "path": "src/cli/account-catalog-refresh.ts",
@@ -478,7 +478,7 @@
     },
     {
       "path": "src/cli/account-extended.ts",
-      "sha256": "361ea2bea9f7864336df1c1886d76e02194efabb993f6c4c7565c5abf9ce0bed"
+      "sha256": "9308c5fc1ee6ea481749cc353288be347d78d2cf35b85839749b94813115020d"
     },
     {
       "path": "src/cli/account-main.ts",
@@ -506,7 +506,7 @@
     },
     {
       "path": "src/cli/capabilities.ts",
-      "sha256": "1605eaf4531ec5bbbfe1b56073760a1c8ab6b9260709d7600a87b95ae956ca7f"
+      "sha256": "acf94353c1ffcbce3badc1f144ab2423d12e0653c763edd6ccebea8d24d33c90"
     },
     {
       "path": "src/cli/catalog-prewarm.ts",
@@ -630,7 +630,7 @@
     },
     {
       "path": "src/cli/observe.ts",
-      "sha256": "4f9b8ce65ff93276837379e91481467ae09bbbce095c02df16048f8fe84f0d98"
+      "sha256": "7b46284dfcacaf9b902f5951bf622c17adff74cc4d59bf8b2c4dc6b605b5f6c1"
     },
     {
       "path": "src/cli/opencode.ts",
@@ -802,7 +802,7 @@
     },
     {
       "path": "src/codex/auth-api.ts",
-      "sha256": "68317d04dfcf132eca089e7657d8cd47f7d3e133bc15280448ad9f119a049a6d"
+      "sha256": "ede7eba228b9185e57f8d142aa27b7fef2255b6c6d253cd7bc79fd089824abee"
     },
     {
       "path": "src/codex/auth-collision.ts",
@@ -830,7 +830,7 @@
     },
     {
       "path": "src/codex/catalog.ts",
-      "sha256": "31ec258ffb16b1f7393480f0fe3454263a0b8f7b9a646d84acc35c4122b30d0a"
+      "sha256": "29907ddc709e5a287a732bcb3716211faa07eb4faf5873fe2bbc73b9d6c12142"
     },
     {
       "path": "src/codex/catalog/account-models.ts",
@@ -846,7 +846,7 @@
     },
     {
       "path": "src/codex/catalog/effort.ts",
-      "sha256": "b837a78528f944ece136efc155aee4ff819f44f57d1affc65db1b36f47048ba6"
+      "sha256": "ab599d14e7e2c8e84745e0481198b2ff7274772518225f67bcd849a866628c28"
     },
     {
       "path": "src/codex/catalog/filesystem-evidence.ts",
@@ -858,19 +858,19 @@
     },
     {
       "path": "src/codex/catalog/metadata.ts",
-      "sha256": "7931ecde8e90f661b2550e3961607d04fd88e042099d628fb04d40c0b988ddbf"
+      "sha256": "bfed4ab1d763c0349acc6814507d97039f13b7a8365465cc014eaab62bae51d0"
     },
     {
       "path": "src/codex/catalog/native-models.ts",
-      "sha256": "8e042ff9737e6dd233298a54ace305d8d07920b5e783387f94821bae9efb5c47"
+      "sha256": "24bc83bbe17d58783eb3d137d9072313340814ca0e2e48759a7fc20077e2265a"
     },
     {
       "path": "src/codex/catalog/parsing.ts",
-      "sha256": "8dbf8350b263c8364f87e9b92aea6ccb9a97672047f81dad4d154f0e877f3a1e"
+      "sha256": "517edd354acc48611a5968ca8e8c9085de4749dc1b05561db9ea504859b11c52"
     },
     {
       "path": "src/codex/catalog/provider-fetch.ts",
-      "sha256": "b2e70967445db892ada6ba0525a7718a885b6fe362a56e85a5fa79de67ddd288"
+      "sha256": "69ad89553d387a69795d56706adce0406218bc28a0b7ab584e4cf1c9285b5bf7"
     },
     {
       "path": "src/codex/catalog/sync.ts",
@@ -906,7 +906,7 @@
     },
     {
       "path": "src/codex/data/upstream-models.json",
-      "sha256": "d2758371028f5068b63e569c2aeacec9292f6e8a1d55b22e7f31e7c74dfff9a9"
+      "sha256": "3f83e796c1cbec028a47526a19eb9a1a314cf6444f2cbef10e6935ff3bc4398c"
     },
     {
       "path": "src/codex/desired-state.ts",
@@ -966,11 +966,11 @@
     },
     {
       "path": "src/codex/inject.ts",
-      "sha256": "2aae2e66977dc851b8c5b726c64d794f047214b16467849c2b5b9c5d6731fc39"
+      "sha256": "9bc9759d276c0eaf59d136bd98341994e676339e6399af894b5d8318d827183e"
     },
     {
       "path": "src/codex/injected-marker.ts",
-      "sha256": "5d99ec3ac06d598c839f0f4ec80a24f43a61ebb8e682cad4f80a2630ee71998e"
+      "sha256": "e5f2ad207839ef89ee03db9866bfc9b9ba82494f4cc4ca3331d7595094d1cbac"
     },
     {
       "path": "src/codex/integration-record.ts",
@@ -986,7 +986,7 @@
     },
     {
       "path": "src/codex/journal.ts",
-      "sha256": "81ebfc825f2bc7b5e04310e141dded6926e74031f7b46a60a3aff13514464d1a"
+      "sha256": "8985c66c13982144e83ab49802c0cf19b06e912aeed4c653eeca43607cba6241"
     },
     {
       "path": "src/codex/log-guard/inspect.ts",
@@ -2238,7 +2238,7 @@
     },
     {
       "path": "src/oauth/account-quota-rank.ts",
-      "sha256": "572463cce8798c9b2f12f046e8cd75094a9b8b3bc203ca9e76ea898b798fdda1"
+      "sha256": "7c458eb8c109548586dcfba64e0ce0c9939fe8e801917cb83393e50bf4e0116d"
     },
     {
       "path": "src/oauth/anthropic-routing.ts",
@@ -2252,9 +2252,13 @@
       "path": "src/oauth/callback-server.ts",
       "sha256": "3c481c4b26bcaaee246aff098be3fa402e1c0f813adf0f00a4122af92d8d5264"
     },
+    {
+      "path": "src/oauth/chatgpt-device.ts",
+      "sha256": "c3021b86c4c94b4b64bb0ee26d67e57cf0b155390a7a7a8d1ab56c8281c4ef8a"
+    },
     {
       "path": "src/oauth/chatgpt.ts",
-      "sha256": "83ee3e60409df8039c9497f61683c628d603a8a8c695e1f02f8e01c5f97b723c"
+      "sha256": "bbb17b33b4de58afd94086885d993906e96ed06652f1a41dee9a8081372f657e"
     },
     {
       "path": "src/oauth/command-code.ts",
@@ -2282,7 +2286,7 @@
     },
     {
       "path": "src/oauth/index.ts",
-      "sha256": "361a8f0a010b93cdb165eb0f083dd8f38b9754fae6f9efae54225db4fbbd87b7"
+      "sha256": "9e84daa06ac81db3da3e8af026add2ed59085ff367da15ba9a53123ccc4d0346"
     },
     {
       "path": "src/oauth/key-providers.ts",
@@ -2306,7 +2310,7 @@
     },
     {
       "path": "src/oauth/log.ts",
-      "sha256": "a6f0b95c49d68a1ddfa2421ce9f6652e6644c6a6e9f1f039d531f8792ad36d51"
+      "sha256": "bafd097b059bc2aaa81b1f0a50dad867ab32673218732ea592d7e84b5bc376d0"
     },
     {
       "path": "src/oauth/login-cli.ts",
@@ -2460,6 +2464,10 @@
       "path": "src/providers/model-rename-startup.ts",
       "sha256": "8a143284d736759bf63c8cb296c19e61dec9596dfc781d8dd87038778153f55f"
     },
+    {
+      "path": "src/providers/muse-subscription-usage.ts",
+      "sha256": "e4e7ee3aa1632122177d2552137e1a97faedd5686b58d304c56741fff78fd564"
+    },
     {
       "path": "src/providers/new-model-policy.ts",
       "sha256": "02c7c4000aa9a8bdd8264027fa4e07844f09c92eda516afec7c2270818ae1618"
@@ -2510,11 +2518,11 @@
     },
     {
       "path": "src/providers/quota.ts",
-      "sha256": "5699763f606b59af65e75800a2e3f90127719b9f0f49e8cf87e4be43e316cf30"
+      "sha256": "112799e24b19bb0ef3403ebe530f32ab462e581982c4dfd285f249907af2210b"
     },
     {
       "path": "src/providers/registry.ts",
-      "sha256": "089732b5710356083ffe63ba2fea49974f5e5284e0df64829660e606323749b9"
+      "sha256": "8fcf151ab118c70cea0e2a07de6f516bfcadbd5834cadb65063c803294152032"
     },
     {
       "path": "src/providers/request-pacing.ts",
@@ -2798,7 +2806,7 @@
     },
     {
       "path": "src/server/index.ts",
-      "sha256": "77a4c65499054cde948de592c27b8e522a12f16e06bdc472cb80e1a4978d1398"
+      "sha256": "6d920629f3dccac784e3f1bdf34068a39b64d17fe403efe696c241718613e82f"
     },
     {
       "path": "src/server/lifecycle.ts",
@@ -2806,7 +2814,7 @@
     },
     {
       "path": "src/server/live.ts",
-      "sha256": "ce0cd3ed3c36fec1490ab0121691c85563e2ea91226ea0084e2468db812f23b3"
+      "sha256": "6347a6dd273bb6d5d2c1ba9826497087edb59f0c61d4c10196ddfbd01f3b6205"
     },
     {
       "path": "src/server/local-management-read-client.ts",
@@ -2894,7 +2902,7 @@
     },
     {
       "path": "src/server/management/oauth-account-routes.ts",
-      "sha256": "21e092715e45e8552849d9d428d3cf54a076b6dd3dd73af02afca792bbb4eb4a"
+      "sha256": "7f63a560692d3fe3e7c4a9614819c44fe183f970a38c7120fe7bd3a345c6ae88"
     },
     {
       "path": "src/server/management/provider-capability-config.ts",
@@ -3094,11 +3102,11 @@
     },
     {
       "path": "src/server/responses/core.ts",
-      "sha256": "73233daa85faa14e355d11e0b9aaabda463d586e23d7c44f40373cddab8eb265"
+      "sha256": "73dc56d86793a3b7e738bb2ac0a7b60be003688df060d748aa7fd30ef7950674"
     },
     {
       "path": "src/server/responses/empty-completion-guard.ts",
-      "sha256": "d7489220a3cd6b3209b7f50454033511d57c42fb7c75141918a2b1e7692decd5"
+      "sha256": "069cdad33a1fd996d37541d13be189223dda4971e2e54b9bd65c76dda97102ce"
     },
     {
       "path": "src/server/responses/encrypted-payload.ts",
@@ -3290,7 +3298,7 @@
     },
     {
       "path": "src/types/request.ts",
-      "sha256": "8f108a629693e51287921f24e7a5d5c21f8240d77f6d87ccb30d394ab12d86b3"
+      "sha256": "30272ac9e6abf66754171d938b2a8f6be8b44d2f9f153380e22e7a786fd8f08e"
     },
     {
       "path": "src/types/tools.ts",

package/src/oauth/account-quota-rank.ts

@@ -10,7 +10,7 @@
  * categories answer the only question rotation asks — "which of these is most likely to
  * serve the retry" — and within the healthy group a simple headroom sort is enough.
  */
-import { getCachedProviderAccountQuota } from "../providers/quota";
+import { getCachedProviderAccountQuota, hasPassiveAccountQuota } from "../providers/quota";
 import { getKiroAccountExhaustion } from "../providers/kiro-usage";
 
 /** Lower sorts earlier. Unknown sits between measured-healthy and measured-empty. */
@@ -27,6 +27,24 @@ interface Ranked {
   index: number;
 }
 
+/**
+ * How old a PASSIVELY observed quota may be and still steer routing.
+ *
+ * A probed row is fresh by construction: it exists only because a probe wrote it, and
+ * `fetchAccountQuota` re-probes once `ACCOUNT_QUOTA_TTL_MS` has passed. So no caller has
+ * ever needed an explicit age check, and `getCachedProviderAccountQuota` does not apply
+ * one.
+ *
+ * A passive row breaks that invariant — nothing re-probes it, so it can be hours or days
+ * old. Routing on such a reading is worse than routing on none: the unranked ring at
+ * least rotates, while a stale ranking sends every first attempt to an account that may
+ * have been spent since. The bound is longer than the probe TTL (an hour-old reading of
+ * a five-hour window is still informative) and far shorter than the six-hour disk
+ * horizon, which exists to preserve a value for DISPLAY — where the age is shown to the
+ * user and no automatic decision rides on it.
+ */
+const PASSIVE_HEADROOM_MAX_AGE_MS = 60 * 60_000;
+
 /**
  * Remaining headroom across every window the provider reports.
  *
@@ -36,6 +54,9 @@ interface Ranked {
 function headroomOf(provider: string, accountId: string): number | null {
   const quota = getCachedProviderAccountQuota(provider, accountId);
   if (!quota) return null;
+  // Null, not a low rank: this must reproduce "no evidence" so a stale roster degrades to
+  // the unranked ring rather than to a differently wrong answer.
+  if (hasPassiveAccountQuota(provider) && Date.now() - quota.updatedAt > PASSIVE_HEADROOM_MAX_AGE_MS) return null;
   const percents = [
     quota.fiveHourPercent,
     quota.weeklyPercent,
@@ -56,6 +77,12 @@ export function rankAccountsByHeadroom(provider: string, ring: readonly string[]
   if (ring.length < 2) return [...ring];
 
   let sawEvidence = false;
+  // Same rule as hasHeadroomEvidence: a passive provider's partial roster must not rank
+  // at all. The failover path calls this directly (selectFailoverAccount), so the guard
+  // cannot live only in the pre-dispatch predicate.
+  if (hasPassiveAccountQuota(provider) && !ring.every(id => headroomOf(provider, id) !== null)) {
+    return [...ring];
+  }
   const ranked: Ranked[] = ring.map((id, index) => {
     // A provider-declared exhaustion verdict outranks the percentage: an account may sit at
     // 100% and still be servable when overage is enabled, and the verdict knows that.
@@ -84,6 +111,18 @@ export function rankAccountsByHeadroom(provider: string, ring: readonly string[]
  * can decline to act on a roster it knows nothing about.
  */
 export function hasHeadroomEvidence(provider: string, ids: readonly string[]): boolean {
+  // A PASSIVE provider needs evidence for EVERY candidate, not any one of them.
+  //
+  // A probe fills the whole roster in one pass (fetchProviderAccountQuotas), so "any"
+  // and "every" coincide there. An observation arrives one account at a time, so the
+  // normal passive state is "one measured, N unknown" -- and RANK_UNKNOWN (1) sorts
+  // AFTER RANK_HEALTHY (0), including behind a measured row sitting at 100% with zero
+  // headroom. Accepting partial evidence would therefore redirect the first attempt
+  // AWAY from an unmeasured account and TOWARD the one account known to be spent, which
+  // is the exact inversion of what ranking is for.
+  if (hasPassiveAccountQuota(provider)) {
+    return ids.length > 0 && ids.every(id => headroomOf(provider, id) !== null);
+  }
   return ids.some(id =>
     headroomOf(provider, id) !== null
     || (provider === "kiro" && getKiroAccountExhaustion(`${provider}\u0000${id}`) !== null));

package/src/oauth/chatgpt-device.ts

@@ -0,0 +1,187 @@
+import type { OAuthController, OAuthCredentials } from "./types";
+import { CHATGPT_CLIENT_ID, CHATGPT_TOKEN_URL, credsFromToken } from "./chatgpt";
+
+/**
+ * OpenAI deviceauth (device-code) grant for the ChatGPT/Codex provider.
+ *
+ * The callback flow in `./chatgpt` needs a browser and a listener on
+ * localhost:1455. A hub running headless in a container or over SSH has
+ * neither, which left "copy the long redirect URL out of the browser error
+ * page" as the only way to add an account there (#3366).
+ *
+ * This is the same grant Codex CLI uses. Three steps, and the middle one is
+ * where it differs from RFC 8628: the poll returns an authorization code plus
+ * a SERVER-generated PKCE verifier, which is then spent at the ordinary token
+ * endpoint. We never generate the verifier ourselves here.
+ */
+const USERCODE_URL = "https://auth.openai.com/api/accounts/deviceauth/usercode";
+const DEVICE_TOKEN_URL = "https://auth.openai.com/api/accounts/deviceauth/token";
+const DEVICE_REDIRECT_URI = "https://auth.openai.com/deviceauth/callback";
+
+/** Where the user types the short code. Fixed, and safe to show anywhere. */
+export const DEVICE_VERIFICATION_URL = "https://auth.openai.com/codex/device";
+
+/** The grant's own lifetime. Polling past this only produces a worse error message. */
+const DEVICE_FLOW_TTL_MS = 15 * 60 * 1000;
+const DEFAULT_POLL_INTERVAL_MS = 5_000;
+const MIN_POLL_INTERVAL_MS = 1_000;
+/**
+ * Above ~2^31 ms a timer overflows and fires immediately, which would turn a
+ * hostile or corrupt `interval` into a hot loop against an auth endpoint. The
+ * grant only lives 15 minutes, so anything longer is meaningless anyway.
+ */
+const MAX_POLL_INTERVAL_MS = DEVICE_FLOW_TTL_MS;
+
+/**
+ * Upstream sends `interval` as a number in some responses and a string in
+ * others. A string would make `setTimeout` treat it as 0 and turn the poll
+ * into a hot loop against an auth endpoint, so coerce and floor it.
+ */
+function normalizeIntervalMs(raw: unknown): number {
+  const seconds = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw) : NaN;
+  if (!Number.isFinite(seconds) || seconds <= 0) return DEFAULT_POLL_INTERVAL_MS;
+  const ms = Math.round(seconds * 1000);
+  return Math.min(MAX_POLL_INTERVAL_MS, Math.max(MIN_POLL_INTERVAL_MS, ms));
+}
+
+function nonEmptyString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+async function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  if (signal?.aborted) throw new Error("Login cancelled");
+  await new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = (): void => {
+      clearTimeout(timer);
+      reject(new Error("Login cancelled"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+/**
+ * Device-flow errors carry the HTTP status and nothing else.
+ *
+ * The callback flow's `safeErrorDescription` reflects the upstream body into
+ * the message, which is fine for an OAuth error envelope but not here: these
+ * endpoints can echo request material, and this message reaches CLI output,
+ * the GUI, and issue reports.
+ */
+function deviceError(stage: string, status: number): Error {
+  return new Error(`ChatGPT device authorization ${stage} failed: HTTP ${status}`);
+}
+
+interface DeviceUserCode {
+  deviceAuthId: string;
+  userCode: string;
+  intervalMs: number;
+}
+
+async function requestUserCode(signal?: AbortSignal): Promise<DeviceUserCode> {
+  const response = await fetch(USERCODE_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ client_id: CHATGPT_CLIENT_ID }),
+    signal,
+  });
+  if (!response.ok) throw deviceError("request", response.status);
+  const payload = (await response.json()) as Record<string, unknown>;
+  const deviceAuthId = nonEmptyString(payload.device_auth_id);
+  // Upstream accepts both spellings, so a response using the alias must not be
+  // rejected as malformed.
+  const userCode = nonEmptyString(payload.user_code) ?? nonEmptyString(payload.usercode);
+  if (!deviceAuthId || !userCode) {
+    throw new Error("ChatGPT device authorization response missing required fields");
+  }
+  return { deviceAuthId, userCode, intervalMs: normalizeIntervalMs(payload.interval) };
+}
+
+interface DeviceGrant {
+  authorizationCode: string;
+  codeVerifier: string;
+}
+
+/**
+ * Poll until the user finishes at the verification page.
+ *
+ * Pending is signalled by 403/404 rather than an `authorization_pending` body,
+ * so status is the whole protocol here: any other non-2xx is terminal, and
+ * treating it as pending would keep hammering a permanently failing endpoint.
+ */
+async function pollForGrant(
+  device: DeviceUserCode,
+  signal?: AbortSignal,
+): Promise<DeviceGrant> {
+  const deadline = Date.now() + DEVICE_FLOW_TTL_MS;
+  while (Date.now() < deadline) {
+    if (signal?.aborted) throw new Error("Login cancelled");
+    const response = await fetch(DEVICE_TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ device_auth_id: device.deviceAuthId, user_code: device.userCode }),
+      signal,
+    });
+    if (response.status === 403 || response.status === 404) {
+      // Cap the wait at the time actually left. Sleeping a full interval past
+      // the deadline is how a 15-minute grant turns into a 20-minute wait.
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) break;
+      await sleep(Math.min(device.intervalMs, remaining), signal);
+      continue;
+    }
+    if (!response.ok) throw deviceError("poll", response.status);
+    // The deadline is checked again here, not only at the top of the loop: a
+    // single poll can itself outlive the grant, and accepting a code that
+    // expired mid-flight just moves the failure to the token exchange.
+    if (Date.now() >= deadline) break;
+    const payload = (await response.json()) as Record<string, unknown>;
+    const authorizationCode = nonEmptyString(payload.authorization_code);
+    const codeVerifier = nonEmptyString(payload.code_verifier);
+    if (!authorizationCode || !codeVerifier) {
+      throw new Error("ChatGPT device authorization response missing required fields");
+    }
+    return { authorizationCode, codeVerifier };
+  }
+  throw new Error("ChatGPT device authorization expired");
+}
+
+async function exchangeGrant(grant: DeviceGrant, signal?: AbortSignal): Promise<OAuthCredentials> {
+  const response = await fetch(CHATGPT_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: CHATGPT_CLIENT_ID,
+      code: grant.authorizationCode,
+      code_verifier: grant.codeVerifier,
+      redirect_uri: DEVICE_REDIRECT_URI,
+    }).toString(),
+    signal,
+  });
+  if (!response.ok) throw deviceError("token exchange", response.status);
+  return credsFromToken((await response.json()) as Record<string, unknown>);
+}
+
+/**
+ * Run the device flow to completion.
+ *
+ * `deviceCode` in the `onAuth` payload is the HUMAN code, matching kimi, nous,
+ * and github-copilot. The opaque `device_auth_id` never leaves this module:
+ * every device-code surface renders `deviceCode` verbatim, and the management
+ * login route also uses its presence to decide a flow must not be handed to a
+ * local browser spawn.
+ */
+export async function loginChatGPTDevice(ctrl: OAuthController): Promise<OAuthCredentials> {
+  const device = await requestUserCode(ctrl.signal);
+  ctrl.onAuth?.({
+    url: DEVICE_VERIFICATION_URL,
+    instructions: `Enter code: ${device.userCode}`,
+    deviceCode: device.userCode,
+  });
+  const grant = await pollForGrant(device, ctrl.signal);
+  return exchangeGrant(grant, ctrl.signal);
+}

package/src/oauth/chatgpt.ts

@@ -5,6 +5,10 @@ import { generatePKCE } from "./pkce";
 const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
 const AUTH_URL = "https://auth.openai.com/oauth/authorize";
 const TOKEN_URL = "https://auth.openai.com/oauth/token";
+
+/** Shared with the deviceauth grant in `./chatgpt-device`: same public PKCE client. */
+export const CHATGPT_CLIENT_ID = CLIENT_ID;
+export const CHATGPT_TOKEN_URL = TOKEN_URL;
 const SCOPE = "openid profile email offline_access api.connectors.read api.connectors.invoke";
 const CALLBACK_PORT = 1455;
 const CALLBACK_PATH = "/auth/callback";
@@ -46,9 +50,17 @@ export function extractEmail(idToken?: string, accessToken?: string): string | u
   return undefined;
 }
 
-function credsFromToken(data: Record<string, unknown>): OAuthCredentials {
+export function credsFromToken(data: Record<string, unknown>): OAuthCredentials {
   const idToken = typeof data.id_token === "string" ? data.id_token : undefined;
-  const accessToken = data.access_token as string;
+  // This parses a response from an external boundary, so the access token is
+  // validated rather than cast. A 200 carrying no access_token would otherwise
+  // resolve a login as successful with an undefined credential, which then gets
+  // silently declined at persistence — a success message and no account.
+  const accessToken = typeof data.access_token === "string" && data.access_token.length > 0
+    ? data.access_token
+    : undefined;
+  if (!accessToken) throw new Error("ChatGPT token response missing access token");
+  const refreshToken = typeof data.refresh_token === "string" ? data.refresh_token : "";
   // ?? only guards null/undefined; NaN or a string expires_in would otherwise
   // produce a NaN expiry that never compares as expired, and a negative duration
   // would stamp an already-past expiry — both block refresh semantics.
@@ -62,7 +74,7 @@ function credsFromToken(data: Record<string, unknown>): OAuthCredentials {
   const expires = Number.isFinite(computedExpires) ? computedExpires : Date.now() + 3600 * 1000;
   return {
     access: accessToken,
-    refresh: (data.refresh_token as string) ?? "",
+    refresh: refreshToken,
     expires,
     accountId: extractAccountId(idToken, accessToken),
     email: extractEmail(idToken, accessToken),
@@ -135,7 +147,22 @@ function safeErrorDescription(resp: Response): Promise<string> {
   });
 }
 
-export async function loginChatGPT(ctrl: OAuthController, opts?: { forceLogin?: boolean }): Promise<OAuthCredentials> {
+/**
+ * How the user proves identity. `browser` runs the localhost:1455 callback flow;
+ * `device` runs the deviceauth grant, which needs no local browser or listener
+ * and is the only workable path on a headless or remote hub (#3366).
+ */
+export type ChatGPTLoginFlow = "browser" | "device";
+
+export async function loginChatGPT(
+  ctrl: OAuthController,
+  opts?: { forceLogin?: boolean; flow?: ChatGPTLoginFlow },
+): Promise<OAuthCredentials> {
+  if (opts?.flow === "device") {
+    // Imported lazily so the callback flow does not pay for a module it never uses.
+    const { loginChatGPTDevice } = await import("./chatgpt-device");
+    return loginChatGPTDevice(ctrl);
+  }
   const flow = new ChatGPTOAuthFlow(ctrl);
   if (opts?.forceLogin) flow.forceLogin = true;
   return flow.login();

package/src/oauth/index.ts

@@ -34,7 +34,7 @@ import { loginXai, refreshXaiToken, XAI_LOCAL_CLI_DETACH_WARNING, XaiTokenReques
 import { ANTHROPIC_OAUTH_BETA, AnthropicTokenError, loginAnthropic, refreshAnthropicToken } from "./anthropic";
 import { loginKimi, refreshKimiToken } from "./kimi";
 import { loginNous, NousTokenError, refreshNousToken, clearNousRefreshIntent, RefreshIntentIOError } from "./nous";
-import { loginChatGPT, refreshChatGPTToken } from "./chatgpt";
+import { loginChatGPT, refreshChatGPTToken, type ChatGPTLoginFlow } from "./chatgpt";
 import { loginAntigravity, refreshAntigravityToken } from "./google-antigravity";
 import { loginCursor, refreshCursorToken } from "./cursor";
 import { loginGithubCopilot, refreshGithubCopilotToken, validateCopilotApiBaseUrl } from "./github-copilot";
@@ -161,7 +161,17 @@ function verdictKey(p:string,a:string,c:OAuthCredentials){return `${p}\0${a}\0${
 function cached(p:string,a:string,c:OAuthCredentials,now:()=>number){const k=verdictKey(p,a,c),u=permanentRefreshFailures.get(k);if(u===undefined)return false;if(u<=now()){permanentRefreshFailures.delete(k);return false;}return true;}
 export function sweepExpiredXaiPermanentFailureVerdicts(now=Date.now()):number{let removed=0;for(const[key,until]of permanentRefreshFailures){if(until>now)continue;permanentRefreshFailures.delete(key);removed+=1;}return removed;}
 
-export interface LoginOpts { forceLogin?: boolean; /** When set, persist into this account slot and require matching identity. */ reauthAccountId?: string }
+export interface LoginOpts {
+  forceLogin?: boolean;
+  /** When set, persist into this account slot and require matching identity. */
+  reauthAccountId?: string;
+  /**
+   * ChatGPT only: `device` selects the deviceauth grant instead of the
+   * localhost:1455 callback flow, for hosts with no browser or no loopback
+   * listener (#3366). Ignored by every other provider.
+   */
+  flow?: ChatGPTLoginFlow;
+}
 
 export interface LoginFlowLifecycle {
   /** Runs after background credential/config persistence settles, before status becomes done. */
@@ -282,7 +292,7 @@ export const OAUTH_PROVIDERS: Record<string, OAuthProviderDef> = {
     defaultRefreshPolicy: "lazy-only",
   },
   chatgpt: {
-    login: loginChatGPT,
+    login: (ctrl, opts) => loginChatGPT(ctrl, { forceLogin: opts?.forceLogin, flow: opts?.flow }),
     refresh: (rt) => refreshChatGPTToken(rt),
     providerConfig: { adapter: "openai-responses", baseUrl: "https://chatgpt.com/backend-api/codex", authMode: "forward" as const },
     defaultModel: "gpt-5.4",

package/src/oauth/log.ts

@@ -23,6 +23,9 @@ const FORBIDDEN_NORMALIZED = new Set([
   "oauth_code",
   "code_verifier",
   "clientsecret",
+  // Device-flow polling handle. Not a token, but it is the bearer of an
+  // in-flight authorization and must not be logged.
+  "device_auth_id",
 ]);
 
 function isForbiddenFieldKey(key: string): boolean {