dsh-codex-oauth 0.2.8 → 0.3.0

package/lib/client.js

@@ -36,20 +36,55 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var import_react = __toESM(require("react"), 1);
-var STATUS = "/plugins/dsh-codex-oauth/auth/status";
-var LOGIN = "/plugins/dsh-codex-oauth/auth/login";
-var LOGOUT = "/plugins/dsh-codex-oauth/auth/logout";
+var BASE = "/plugins/dsh-codex-oauth/auth";
 var h = import_react.default.createElement;
 async function request(path, method = "GET") {
-  const response = await fetch(path, { method, credentials: "same-origin", headers: { accept: "application/json" } });
+  const response = await fetch(`${BASE}/${path}`, { method, credentials: "same-origin", headers: { accept: "application/json" } });
   const value = await response.json().catch(() => ({}));
-  if (!response.ok) throw new Error(value && typeof value === "object" && typeof value.error === "string" ? value.error : `HTTP ${response.status}`);
+  if (!response.ok) throw new Error(typeof value.error === "string" ? value.error : `HTTP ${response.status}`);
   return value;
 }
+function QuotaPanel({ quota }) {
+  if (!quota?.available) return h("div", { role: "status" }, "Quota unavailable. No current quota data is available.");
+  return h(
+    "div",
+    { style: { display: "flex", flexDirection: "column", gap: 12 } },
+    ...quota.buckets.map((bucket) => h(
+      "section",
+      { key: bucket.id },
+      h("strong", null, bucket.name ?? bucket.id),
+      ...bucket.windows.map((window2, index) => {
+        const remaining = Math.round(window2.remainingPercent);
+        const color = window2.stale ? "#888" : remaining <= 10 ? "#c44" : remaining <= 30 ? "#b88020" : "#38875c";
+        return h(
+          "div",
+          { key: index, style: { marginTop: 8 } },
+          h("div", null, `${window2.label}: ${remaining}% remaining${window2.stale ? " (stale)" : ""}`),
+          h(
+            "div",
+            {
+              role: "progressbar",
+              "aria-label": `${window2.label} quota remaining`,
+              "aria-valuemin": 0,
+              "aria-valuemax": 100,
+              "aria-valuenow": window2.remainingPercent,
+              style: { height: 7, background: "var(--dsw-alias-border-l2)", borderRadius: 4, marginTop: 4 }
+            },
+            h("div", { style: { width: `${window2.remainingPercent}%`, height: "100%", background: color, borderRadius: 4 } })
+          ),
+          h("small", null, window2.resetsAt ? `Reset: ${new Date(window2.resetsAt * 1e3).toLocaleString("en-US")}` : "Reset time unavailable"),
+          h("small", { style: { display: "block" } }, `Updated: ${new Date(window2.checkedAt).toLocaleString("en-US")}`)
+        );
+      })
+    )),
+    h("small", null, "Quota checks do not call a model.")
+  );
+}
 function CodexSettings() {
   const [state, setState] = (0, import_react.useState)({ status: "loading" });
   const [busy, setBusy] = (0, import_react.useState)(false);
-  const refresh = (0, import_react.useCallback)(() => request(STATUS).then(setState).catch((error) => setState({ status: "error", message: error.message })), []);
+  const [notice, setNotice] = (0, import_react.useState)("");
+  const refresh = (0, import_react.useCallback)(() => request("status").then(setState).catch((error) => setState({ status: "error", message: error.message })), []);
   (0, import_react.useEffect)(() => {
     refresh();
   }, [refresh]);
@@ -58,21 +93,22 @@ function CodexSettings() {
     const timer = setInterval(refresh, 1e3);
     return () => clearInterval(timer);
   }, [refresh, state.status]);
-  const signIn = async () => {
+  const signIn = async (newAccount = false) => {
     const popup = window.open("about:blank", "_blank");
     if (!popup) {
-      setState({ status: "error", message: "Please allow popups to sign in" });
+      setState({ ...state, status: "error", message: "Allow pop-ups to complete sign-in." });
       return;
     }
     popup.opener = null;
     setBusy(true);
-    setState({ status: "signing-in" });
+    setState({ ...state, status: "signing-in" });
+    setNotice("");
     try {
-      const challenge = await request(LOGIN, "POST");
+      const challenge = await request(`login${newAccount ? "?new_account=1" : ""}`, "POST");
       popup.location.replace(challenge.url);
     } catch (error) {
-      popup?.close();
-      setState({ status: "error", message: error.message });
+      popup.close();
+      setState({ ...state, status: "error", message: error.message });
     } finally {
       setBusy(false);
     }
@@ -80,28 +116,77 @@ function CodexSettings() {
   const signOut = async () => {
     setBusy(true);
     try {
-      await request(LOGOUT, "POST");
-      setState({ status: "signed-out" });
+      const result = await request("logout", "POST");
+      if (!result.remoteRevoked) setNotice("Signed out locally. Remote revocation was not confirmed; disconnect the app in ChatGPT usage settings.");
+      await refresh();
     } catch (error) {
-      setState({ status: "error", message: error.message });
+      setState({ ...state, status: "error", message: error.message });
     } finally {
       setBusy(false);
     }
   };
-  const signedIn = state.status === "signed-in";
-  const label = state.status === "signed-in" ? "\u5DF2\u767B\u5F55" : state.status === "signing-in" ? "\u7B49\u5F85\u6D4F\u89C8\u5668\u5B8C\u6210\u767B\u5F55\u2026" : state.status === "loading" ? "\u68C0\u67E5\u767B\u5F55\u72B6\u6001\u2026" : state.status === "error" ? "\u767B\u5F55\u5931\u8D25" : "\u672A\u767B\u5F55";
+  const selectAccount = async (clientId) => {
+    setBusy(true);
+    setNotice("");
+    try {
+      setState(await request(`account?client_id=${encodeURIComponent(clientId)}`, "POST"));
+    } catch (error) {
+      setState({ ...state, status: "error", message: error.message });
+    } finally {
+      setBusy(false);
+    }
+  };
+  const refreshModels = async () => {
+    setBusy(true);
+    try {
+      const { models } = await request("models", "POST");
+      setNotice(`Refreshed ${models.length} available models.`);
+    } catch (error) {
+      setNotice(error.message);
+    } finally {
+      setBusy(false);
+    }
+  };
+  const signedIn = state.authenticated && state.planUsage;
+  (0, import_react.useEffect)(() => {
+    if (!signedIn) return void 0;
+    const timer = setInterval(refresh, 3e4);
+    return () => clearInterval(timer);
+  }, [signedIn, refresh]);
+  const signingIn = state.status === "signing-in";
+  const label = signingIn ? "Waiting for browser sign-in\u2026" : signedIn ? `Signed in${state.label ? `: ${state.label}` : ""}` : state.status === "loading" ? "Checking sign-in status\u2026" : state.authenticated ? "Signed in; ChatGPT plan usage is not authorized" : "Signed out";
   return h(
     "section",
     { style: { display: "flex", flexDirection: "column", gap: 12, maxWidth: 640 } },
     h("h2", { style: { margin: 0 } }, "OpenAI Codex"),
-    h("p", { style: { margin: 0, color: "var(--dsw-alias-label-secondary)" } }, "\u4F7F\u7528 ChatGPT Plus/Pro \u7684 Codex \u8BA2\u9605\uFF0C\u65E0\u9700 OpenAI API Key\u3002"),
+    h("p", { style: { margin: 0 } }, "Use your ChatGPT plan without an OpenAI API key. Models are provided by the active account."),
     h(
       "div",
-      { style: { display: "flex", alignItems: "center", justifyContent: "space-between", padding: 16, border: "1px solid var(--dsw-alias-border-l2)", borderRadius: 10 } },
+      { style: { display: "flex", alignItems: "center", justifyContent: "space-between", gap: 12, padding: 16, border: "1px solid var(--dsw-alias-border-l2)", borderRadius: 10 } },
       h("span", null, label),
-      state.status === "loading" ? null : h("button", { type: "button", disabled: busy || state.status === "signing-in", onClick: signedIn ? signOut : signIn }, signedIn ? "\u9000\u51FA\u767B\u5F55" : "\u4F7F\u7528 ChatGPT \u767B\u5F55")
+      state.status === "loading" ? null : h("button", { type: "button", disabled: busy, onClick: signedIn || signingIn ? signOut : () => signIn() }, signedIn ? "Sign out" : signingIn ? "Cancel sign-in" : "Continue with ChatGPT")
     ),
-    state.status === "error" ? h("p", { style: { color: "var(--dsw-alias-state-error-primary)" } }, state.message) : null
+    state.accounts?.length ? h(
+      "div",
+      { style: { display: "flex", gap: 8 } },
+      h(
+        "select",
+        { "aria-label": "ChatGPT account", disabled: busy || signingIn, value: state.accounts.find((account) => account.active)?.clientId ?? "", onChange: (event) => selectAccount(event.target.value) },
+        ...state.accounts.map((account) => h("option", { key: account.clientId, value: account.clientId }, `${account.label}${account.authenticated ? "" : " (signed out)"}`))
+      ),
+      h("button", { type: "button", disabled: busy || signingIn, onClick: () => signIn(true) }, "Add account")
+    ) : null,
+    state.authenticated && !state.planUsage && !signingIn ? h("button", { type: "button", disabled: busy, onClick: signOut }, "Sign out") : null,
+    signedIn && !signingIn ? h(
+      "div",
+      { style: { display: "flex", alignItems: "center", gap: 12 } },
+      h("span", null, "Using ChatGPT plan"),
+      h("a", { href: "https://chatgpt.com/settings/usage", target: "_blank", rel: "noopener noreferrer" }, "Manage usage"),
+      h("button", { type: "button", disabled: busy, onClick: refreshModels }, "Refresh models")
+    ) : null,
+    signedIn ? h(QuotaPanel, { quota: state.quota }) : null,
+    state.status === "error" ? h("p", { style: { color: "var(--dsw-alias-state-error-primary)" } }, state.message) : null,
+    notice ? h("p", { role: "status" }, notice) : null
   );
 }
 var name = "dsh-codex-oauth-client";

package/lib/index.js

@@ -1,6 +1,7 @@
 import { createCodexAdapter } from "./adapter.js";
 import { CodexCredentialStore, OPENAI_CODEX_PROVIDER, authPath } from "./store.js";
 import { registerWebAuth } from "./web-auth.js";
+import { registerQuotaUi } from "./quota-ui.js";
 export { login, logout, status } from "./auth.js";
 
 export const name = "llm-codex-oauth";
@@ -10,9 +11,15 @@ export { OPENAI_CODEX_PROVIDER, CodexCredentialStore, authPath, createCodexAdapt
 
 export function apply(ctx) {
   const credentials = new CodexCredentialStore();
+  const adapter = createCodexAdapter(credentials, () => ctx.get?.("attachments"), {
+    mapHostPath: (path) => ctx.get?.("fs")?.processPathFromHostPath(path),
+    onModelsChanged: () => ctx.emit?.("llm/adapters-updated"),
+  });
   ctx.llm.registerAdapter(
     [OPENAI_CODEX_PROVIDER],
-    createCodexAdapter(credentials, () => ctx.get?.("attachments")),
+    adapter,
   );
-  registerWebAuth(ctx, credentials);
+  ctx.effect?.(() => () => adapter.dispose());
+  registerWebAuth(ctx, credentials, { adapter });
+  registerQuotaUi(ctx, adapter);
 }

package/lib/models.js

@@ -0,0 +1,53 @@
+import { LlmError } from "@deepseek-ai/dsh-llm";
+import { getCredential } from "./auth.js";
+import { OPENAI_CODEX_PROVIDER } from "./store.js";
+import { fetchJSON, OPENAI_API } from "./openai-http.js";
+
+const CACHE_TTL_MS = 5 * 60_000;
+function modelInfo(entry) {
+  if (typeof entry.slug !== "string" || !entry.slug) throw new LlmError("OpenAI returned an invalid model catalog entry", "INVALID_RESPONSE");
+  const modalities = Array.isArray(entry.input_modalities) ? entry.input_modalities.filter((value) => value === "text" || value === "image") : undefined;
+  const levels = Array.isArray(entry.supported_reasoning_levels) ? entry.supported_reasoning_levels.filter((level) => typeof level.effort === "string" && level.effort)
+    .map((level) => ({ id: level.effort, name: level.effort, ...(typeof level.description === "string" ? { description: level.description } : {}) })) : [];
+  return {
+    provider: OPENAI_CODEX_PROVIDER,
+    id: entry.slug,
+    name: typeof entry.display_name === "string" ? entry.display_name : entry.slug,
+    ...(typeof entry.description === "string" ? { description: entry.description } : {}),
+    ...(modalities ? { inputModalities: modalities } : {}),
+    ...(Number.isSafeInteger(entry.context_window) && entry.context_window > 0 ? { context: { contextWindow: entry.context_window } } : {}),
+    ...(levels.length ? { reasoning: {
+      efforts: levels,
+      ...(levels.some((level) => level.id === entry.default_reasoning_level) ? { defaultEffort: entry.default_reasoning_level } : {}),
+    } } : {}),
+  };
+}
+
+export class CodexModelCatalog {
+  #cached;
+  constructor(credentials, options = {}) { this.credentials = credentials; this.options = options; }
+  invalidate() { this.#cached = undefined; }
+  async read({ signal, refresh = false } = {}) {
+    const initial = await this.credentials.readDocument();
+    const selected = await this.credentials.read(OPENAI_CODEX_PROVIDER);
+    if (!selected?.scopes.includes("chatgpt.tokens.use.direct")) { this.invalidate(); return undefined; }
+    const credential = await getCredential(this.credentials, { ...this.options, signal, clientId: selected.clientId });
+    const authorized = await this.credentials.readDocument();
+    if (authorized?.activeClientId !== initial?.activeClientId || (authorized?.generation ?? 0) !== (initial?.generation ?? 0)) throw new LlmError("The selected ChatGPT account changed during model discovery", "AUTH");
+    const now = this.options.now?.() ?? Date.now();
+    const generation = initial?.generation ?? 0;
+    if (!refresh && this.#cached?.clientId === credential.clientId && this.#cached.generation === generation && this.#cached.expires > now) return structuredClone(this.#cached);
+    const response = await fetchJSON(`${OPENAI_API}/models`, { headers: { authorization: `Bearer ${credential.access}` }, signal }, this.options.fetch);
+    if (!Array.isArray(response.models)) throw new LlmError("OpenAI returned an invalid model catalog", "INVALID_RESPONSE");
+    const all = response.models.map((entry) => ({ info: modelInfo(entry), visible: entry.visibility === "list" }));
+    if (new Set(all.map((entry) => entry.info.id)).size !== all.length) throw new LlmError("OpenAI returned duplicate model catalog entries", "INVALID_RESPONSE");
+    const current = await this.credentials.readDocument();
+    if (current?.activeClientId !== initial?.activeClientId || current?.activeClientId !== credential.clientId || (current?.generation ?? 0) !== generation) throw new LlmError("The selected ChatGPT account changed during model discovery", "AUTH");
+    this.#cached = { clientId: credential.clientId, generation, expires: now + CACHE_TTL_MS, all };
+    return structuredClone(this.#cached);
+  }
+  async list(options) { return (await this.read(options))?.all.filter((entry) => entry.visible).map((entry) => entry.info) ?? []; }
+  async resolve(model, signal) {
+    return (await this.read({ signal }))?.all.find((entry) => entry.info.id === model)?.info ?? { provider: OPENAI_CODEX_PROVIDER, id: model, name: model };
+  }
+}

package/lib/openai-http.js

@@ -0,0 +1,64 @@
+import { LlmError, attributionHeaders, isContextWindowExceededError } from "@deepseek-ai/dsh-llm";
+import { safeMessage } from "./safe-message.js";
+
+export const OPENAI_API = "https://api.openai.com/v1";
+export const OPENAI_ISSUER = "https://auth.openai.com";
+
+function failureCode(code, status, message) {
+  if (code === "subscription_sharing_usage_limit_exceeded") return "ACCOUNT_QUOTA_EXCEEDED";
+  if (["subscription_sharing_usage_unavailable", "subscription_sharing_user_unavailable"].includes(code)) return "SERVER";
+  if (["subscription_sharing_invalid_user", "subscription_sharing_user_not_eligible", "chatpass_v2_scope_not_authorized", "chatpass_v2_invalid_authorization_context"].includes(code)) return "AUTH";
+  if (code === "subscription_sharing_unsupported_capability") return "INVALID_REQUEST";
+  if (code === "context_length_exceeded" || isContextWindowExceededError(message)) return "CONTEXT_WINDOW_EXCEEDED";
+  if (status === 401 || status === 403) return "AUTH";
+  if (status === 429) return "RATE_LIMIT";
+  if (status >= 500) return "SERVER";
+  return status >= 400 ? "INVALID_REQUEST" : "OPENAI_ERROR";
+}
+
+export function responseError(body, status, headers = new Headers(), secrets = []) {
+  const detail = body?.error;
+  const providerCode = typeof detail === "string" ? detail : detail?.code;
+  let message = detail?.message ?? body?.error_description ?? body?.detail ?? providerCode ?? `OpenAI request failed${status ? ` (HTTP ${status})` : ""}`;
+  if (typeof message !== "string") message = "OpenAI request failed";
+  for (const secret of secrets) if (secret) message = message.replaceAll(secret, "[redacted]");
+  const retryAfter = headers.get("retry-after");
+  const delay = retryAfter === null ? NaN : /^\d+(?:\.\d+)?$/.test(retryAfter) ? Number(retryAfter) * 1000 : Date.parse(retryAfter) - Date.now();
+  const error = new LlmError(safeMessage(message), failureCode(providerCode, status, message), {
+    ...(status ? { status } : {}),
+    ...(headers.get("x-request-id") ? { requestId: headers.get("x-request-id") } : {}),
+    ...(Number.isFinite(delay) && delay > 0 ? { providerRetryAfterMs: delay } : {}),
+  });
+  error.providerCode = providerCode;
+  error.param = detail?.param;
+  return error;
+}
+
+export async function readJSON(response) {
+  try { return await response.json(); }
+  catch { throw new LlmError(`OpenAI returned invalid JSON (HTTP ${response.status})`, "INVALID_RESPONSE", { status: response.status }); }
+}
+
+export async function openaiFetch(url, options = {}, fetcher = globalThis.fetch) {
+  const headers = new Headers(attributionHeaders());
+  for (const [name, value] of new Headers(options.headers)) headers.set(name, value);
+  try { return await fetcher(url, { ...options, headers, redirect: "error" }); }
+  catch (error) {
+    if (options.signal?.aborted) throw options.signal.reason;
+    throw new LlmError("Could not reach OpenAI", "TRANSPORT", { cause: error });
+  }
+}
+
+export async function fetchJSON(url, options = {}, fetcher) {
+  const signal = AbortSignal.any([...(options.signal ? [options.signal] : []), AbortSignal.timeout(15_000)]);
+  const response = await openaiFetch(url, { ...options, signal }, fetcher);
+  const body = await readJSON(response);
+  if (!response.ok) {
+    const form = options.body instanceof URLSearchParams ? options.body : undefined;
+    throw responseError(body, response.status, response.headers, [
+      new Headers(options.headers).get("authorization")?.replace(/^Bearer /, ""),
+      form?.get("code"), form?.get("code_verifier"), form?.get("refresh_token"), form?.get("token"),
+    ]);
+  }
+  return body;
+}

package/lib/quota-lookup.js

@@ -0,0 +1,114 @@
+import { createHash } from "node:crypto";
+import { lstat, readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { QuotaTracker } from "./quota.js";
+
+const USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const REFRESH_MS = 60_000;
+const FAILURE_BACKOFF_MS = 30_000;
+const empty = () => ({ available: false, buckets: [] });
+function claims(token) {
+  try { return JSON.parse(Buffer.from(token.split(".")[1], "base64url").toString()); }
+  catch { return {}; }
+}
+function email(token) {
+  const value = claims(token);
+  const address = value.email ?? value["https://api.openai.com/profile"]?.email;
+  return typeof address === "string" ? address.trim().toLowerCase() : undefined;
+}
+async function readLegacy(filename) {
+  for (const path of [dirname(filename), filename]) {
+    const info = await lstat(path);
+    if (info.isSymbolicLink() || (process.platform !== "win32" && info.mode & 0o077)) return;
+    if (path === filename && (!info.isFile() || info.size > 1_048_576)) return;
+  }
+  return JSON.parse(await readFile(filename, "utf8")).credential;
+}
+export function quotaUsage(body) {
+  const groups = [{ id: "codex", rate_limit: body?.rate_limit },
+    ...(Array.isArray(body?.additional_rate_limits) ? body.additional_rate_limits.map((value) => ({
+      id: value?.metered_feature ?? value?.limit_name, rate_limit: value?.rate_limit,
+    })) : [])];
+  return groups.flatMap((group) => {
+    if (typeof group.id !== "string" || !group.id || !group.rate_limit) return [];
+    const windows = {};
+    for (const slot of ["primary", "secondary"]) {
+      const value = group.rate_limit[`${slot}_window`];
+      if (!value) continue;
+      const usedPercent = value.used_percent;
+      if (typeof usedPercent !== "number" || !Number.isFinite(usedPercent) || usedPercent < 0 || usedPercent > 100) continue;
+      windows[slot] = { usedPercent, remainingPercent: 100 - usedPercent,
+        ...(Number.isSafeInteger(value.limit_window_seconds) && value.limit_window_seconds > 0 ? { windowMinutes: Math.ceil(value.limit_window_seconds / 60) } : {}),
+        ...(Number.isSafeInteger(value.reset_at) && value.reset_at > 0 && value.reset_at <= 8_640_000_000_000 ? { resetsAt: value.reset_at } : {}),
+      };
+    }
+    return Object.keys(windows).length ? [{ id: group.id.replace(/[\x00-\x1f\x7f]/g, "").slice(0, 80), windows }] : [];
+  });
+}
+
+// SIWC inference tokens do not authorize WHAM. Query with the plugin's retained
+// legacy Codex login only; never borrow Pi/Codex app credentials or refresh their
+// rotating tokens. Matching emails guard against unrelated accounts, but do not
+// prove identical workspaces or SIWC application limits (see README).
+export class CodexQuotaLookup {
+  #tracker = new QuotaTracker();
+  #key;
+  #pending;
+  #controller;
+  #nextCheck = 0;
+  #epoch = 0;
+  #disposed = false;
+  constructor(filename, options = {}) {
+    this.readCredential = options.readCredential ?? (() => readLegacy(join(dirname(filename), ".openai-codex-auth.json")));
+    this.fetch = options.fetch ?? globalThis.fetch;
+    this.now = options.now ?? Date.now;
+  }
+  reset() {
+    this.#epoch++;
+    this.#controller?.abort(); this.#controller = undefined;
+    this.#pending = undefined; this.#key = undefined; this.#nextCheck = 0;
+    this.#tracker.clear();
+  }
+  dispose() { this.#disposed = true; this.reset(); }
+  async snapshot(account, binding) {
+    if (this.#disposed) return empty();
+    const epoch = this.#epoch;
+    let credential;
+    try { credential = await this.readCredential(); } catch { this.reset(); return empty(); }
+    if (this.#disposed) return empty();
+    const address = email(account.idToken);
+    if (!credential?.access || !(credential.expires > this.now()) || !address || address !== email(credential.access)) {
+      this.reset(); return empty();
+    }
+    const key = createHash("sha256").update(JSON.stringify([binding.clientId, binding.generation, credential.accountId, credential.access, account.idToken])).digest("hex");
+    if (epoch !== this.#epoch && key !== this.#key) return empty();
+    if (key !== this.#key) { this.reset(); this.#key = key; this.#tracker.activate(binding); }
+    if (!this.#pending && this.now() >= this.#nextCheck) {
+      const controller = new AbortController();
+      this.#controller = controller;
+      const requestEpoch = this.#epoch;
+      const request = (async () => {
+        this.#nextCheck = this.now() + FAILURE_BACKOFF_MS;
+        try {
+          const response = await this.fetch(USAGE_URL, {
+            redirect: "error", signal: AbortSignal.any([controller.signal, AbortSignal.timeout(15_000)]),
+            headers: { authorization: `Bearer ${credential.access}`, ...(credential.accountId ? { "chatgpt-account-id": credential.accountId } : {}) },
+          });
+          if (!response.ok) { await response.body?.cancel(); return; }
+          const updates = quotaUsage(await response.json());
+          if (this.#disposed || requestEpoch !== this.#epoch || controller.signal.aborted) return;
+          // WHAM is a complete snapshot: null/missing windows must retire old data.
+          this.#tracker.clear(); this.#tracker.activate(binding);
+          this.#tracker.update(binding, updates, 0, this.now());
+          this.#nextCheck = this.now() + REFRESH_MS;
+        } catch { /* Quota failures never affect inference or disclose credentials. */ }
+      })();
+      this.#pending = request;
+      void request.finally(() => {
+        if (this.#pending === request) { this.#pending = undefined; this.#controller = undefined; }
+      });
+    }
+    await this.#pending;
+    return this.#disposed || this.#key !== key ? empty() : this.#tracker.snapshot(this.now());
+  }
+}

package/lib/quota-ui.js

@@ -0,0 +1,24 @@
+import { quotaSummary, quotaDetails } from "./quota.js";
+export function registerQuotaUi(ctx, adapter) {
+  ctx.inject(["commands"], (commands) => commands.effect(() => commands.commands.register({
+    name: "codex-usage", description: "Show Codex quota windows and reset times (no model request)",
+    handler: async ({ rawInput }) => rawInput.trim() ? { kind: "error", text: "Usage: /codex-usage" }
+      : { kind: "success", text: quotaDetails(await adapter.quotaSnapshot()) },
+  })));
+  ctx.inject(["tuiStatus"], (ui) => ui.effect(() => {
+    let clear, disposed = false, refreshing = false;
+    const refresh = async () => {
+      if (disposed || refreshing) return;
+      refreshing = true;
+      try {
+        const snapshot = await adapter.quotaSnapshot();
+        if (!disposed) { clear?.(); clear = ui.tuiStatus.set("dsh-codex-oauth:quota", quotaSummary(snapshot), ui); }
+      } catch { /* Status display must not prevent the TUI from starting. */ }
+      finally { refreshing = false; }
+    };
+    const unsubscribe = adapter.quotas.subscribe(refresh);
+    const timer = setInterval(refresh, 30_000); timer.unref?.();
+    void refresh();
+    return () => { disposed = true; clearInterval(timer); unsubscribe(); clear?.(); };
+  }));
+}

package/lib/quota.js

@@ -0,0 +1,111 @@
+const MAX_RESET_SECONDS = 8_640_000_000_000;
+const safeLabel = (value) => typeof value === "string" ? value.replace(/[\x00-\x1f\x7f]/g, "").slice(0, 80) : undefined;
+function windowValue(used, minutes, reset) {
+  if (used === null || used === undefined || (typeof used === "string" && !used.trim())) return undefined;
+  const usedPercent = Number(used);
+  if (!Number.isFinite(usedPercent) || usedPercent < 0 || usedPercent > 100) return undefined;
+  const windowMinutes = Number(minutes);
+  const resetsAt = Number(reset);
+  if (usedPercent === 0 && minutes !== null && minutes !== undefined && windowMinutes === 0 && !reset) return null;
+  return { usedPercent, remainingPercent: 100 - usedPercent,
+    ...(Number.isSafeInteger(windowMinutes) && windowMinutes > 0 ? { windowMinutes } : {}),
+    ...(Number.isSafeInteger(resetsAt) && resetsAt > 0 && resetsAt <= MAX_RESET_SECONDS ? { resetsAt } : {}),
+  };
+}
+export function quotaHeaders(headers) {
+  const buckets = [];
+  const prefixes = new Set();
+  for (const key of headers.keys()) {
+    const match = /^(x-codex(?:-[a-z0-9-]+)?)-(?:primary|secondary)-used-percent$/.exec(key);
+    if (match) prefixes.add(match[1]);
+  }
+  for (const prefix of prefixes) {
+    const bucket = { id: prefix.slice(2), name: safeLabel(headers.get(`${prefix}-limit-name`)), windows: {} };
+    for (const slot of ["primary", "secondary"]) {
+      const value = windowValue(headers.get(`${prefix}-${slot}-used-percent`), headers.get(`${prefix}-${slot}-window-minutes`), headers.get(`${prefix}-${slot}-reset-at`));
+      if (value !== undefined) bucket.windows[slot] = value;
+    }
+    if (Object.keys(bucket.windows).length) buckets.push(bucket);
+  }
+  return buckets;
+}
+export function quotaEvent(event) {
+  if (event?.type !== "codex.rate_limits" || !event.rate_limits || typeof event.rate_limits !== "object") return [];
+  const windows = {};
+  for (const slot of ["primary", "secondary"]) {
+    const source = event.rate_limits[slot];
+    if (source === null) windows[slot] = null;
+    else if (source && typeof source.used_percent === "number") {
+      const value = windowValue(source.used_percent, source.window_minutes, source.reset_at);
+      if (value !== undefined) windows[slot] = value;
+    }
+  }
+  if (!Object.keys(windows).length) return [];
+  const id = safeLabel(event.metered_limit_name ?? event.limit_name) || "codex";
+  return [{ id: id.replaceAll("_", "-"), windows }];
+}
+export class QuotaTracker {
+  #binding;
+  #buckets = new Map();
+  #listeners = new Set();
+  subscribe(listener) { this.#listeners.add(listener); return () => this.#listeners.delete(listener); }
+  #emit() { for (const listener of this.#listeners) { try { listener(); } catch { /* Quota display must not interrupt inference. */ } } }
+  matches(binding) { return !!this.#binding && this.#binding.clientId === binding.clientId && this.#binding.generation === binding.generation; }
+  activate(binding) {
+    if (this.matches(binding)) return;
+    this.#binding = binding; this.#buckets.clear(); this.#emit();
+  }
+  accountChanged(state) { if (!state.authenticated || state.clientId !== this.#binding?.clientId) this.clear(); }
+  clear() { this.#binding = undefined; this.#buckets.clear(); this.#emit(); }
+  update(binding, updates, startedAt, now = Date.now()) {
+    if (!this.matches(binding)) return;
+    let changed = false;
+    for (const update of updates) {
+      const bucket = this.#buckets.get(update.id) ?? { id: update.id, name: update.name, windows: {}, sequence: {} };
+      if (update.name) bucket.name = update.name;
+      for (const [slot, value] of Object.entries(update.windows)) {
+        if (startedAt < (bucket.sequence[slot] ?? -Infinity)) continue;
+        bucket.sequence[slot] = startedAt;
+        if (value === null) delete bucket.windows[slot];
+        else bucket.windows[slot] = { ...value, checkedAt: now, startedAt };
+        changed = true;
+      }
+      this.#buckets.set(update.id, bucket);
+    }
+    if (changed) this.#emit();
+  }
+  snapshot(now = Date.now()) {
+    const buckets = [...this.#buckets.values()].map((bucket) => ({ id: bucket.id, ...(bucket.name ? { name: bucket.name } : {}),
+      windows: Object.values(bucket.windows).map(({ startedAt, ...window }) => ({ ...window, label: windowLabel(window), stale: now - window.checkedAt > 300_000 || (window.resetsAt !== undefined && window.resetsAt * 1000 <= now) })),
+    })).filter((bucket) => bucket.windows.length);
+    return { available: buckets.length > 0, buckets };
+  }
+}
+export function windowLabel(window) {
+  if (window.windowMinutes === 300) return "5h";
+  if (window.windowMinutes === 10080) return "Weekly";
+  return window.windowMinutes ? `${window.windowMinutes}m` : "Quota";
+}
+function resetText(window, now) {
+  if (!window.resetsAt) return "reset time unavailable";
+  const minutes = Math.ceil((window.resetsAt * 1000 - now) / 60000);
+  if (minutes <= 0) return "awaiting update";
+  const hours = Math.floor(minutes / 60);
+  return hours >= 24 ? `resets in ${Math.floor(hours / 24)}d ${hours % 24}h` : hours ? `resets in ${hours}h ${minutes % 60}m` : `resets in ${minutes}m`;
+}
+export function quotaSummary(snapshot, now = Date.now()) {
+  const bucket = snapshot.buckets.find((value) => value.id === "codex") ?? snapshot.buckets[0];
+  if (!bucket) return "codex unavailable";
+  const windows = [...bucket.windows].sort((a, b) => (a.windowMinutes ?? Infinity) - (b.windowMinutes ?? Infinity));
+  return `codex ${windows.map((window) => `${Math.round(window.remainingPercent)}%${window.stale ? "*" : ""} ${compactReset(window, now)}`).join(" ")}`;
+}
+function compactReset(window, now) {
+  if (!window.resetsAt) return "?";
+  const total = Math.max(0, Math.ceil((window.resetsAt * 1000 - now) / 60000));
+  const days = Math.floor(total / 1440), hours = Math.floor(total % 1440 / 60), minutes = total % 60;
+  return `${days ? `${days}d` : ""}${hours ? `${hours}h` : ""}${minutes ? `${minutes}m` : ""}` || "0m";
+}
+export function quotaDetails(snapshot, now = Date.now()) {
+  if (!snapshot.available) return "Codex quota unavailable. No quota data is currently available for this account. This command does not call a model.\nManage usage: https://chatgpt.com/settings/usage";
+  return snapshot.buckets.map((bucket) => `${bucket.name ?? bucket.id}\n${bucket.windows.map((window) => `${window.label}: ${window.remainingPercent.toFixed(1)}% remaining${window.stale ? " (stale)" : ""}\n  ${resetText(window, now)}${window.resetsAt ? ` · ${new Date(window.resetsAt * 1000).toLocaleString("en-US")}` : ""}\n  Updated: ${new Date(window.checkedAt).toLocaleString("en-US")}`).join("\n")}`).join("\n\n");
+}