tokentracker-cli 0.96.1 → 0.96.3

package/src/lib/codex-config.js

@@ -19,6 +19,10 @@ function buildEveryCodeNotifyCmd(notifyPath, options) {
   return [...buildCodexNotifyCmd(notifyPath, options), "--source=every-code"];
 }
 
+function buildAcodeNotifyCmd(notifyPath, options) {
+  return [...buildCodexNotifyCmd(notifyPath, options), "--source=acode"];
+}
+
 // Is this notify command one we wrote? Strict array equality is not a safe
 // test, because the command is not a stable constant across invocations:
 //   - argv[0] on Windows is an absolute `process.execPath` (#361). The desktop
@@ -172,6 +176,39 @@ async function readCodexNotify(codexConfigPath) {
   return readNotify(codexConfigPath);
 }
 
+async function upsertAcodeNotify({
+  acodeConfigPath,
+  notifyCmd,
+  notifyOriginalPath,
+  captureOriginal = true,
+  replaceOriginal = false,
+}) {
+  return upsertNotify({
+    configPath: acodeConfigPath,
+    notifyCmd,
+    notifyOriginalPath,
+    configLabel: "AStudio config",
+    captureOriginal,
+    replaceOriginal,
+  });
+}
+
+async function restoreAcodeNotify({ acodeConfigPath, notifyOriginalPath, notifyCmd }) {
+  return restoreNotify({
+    configPath: acodeConfigPath,
+    notifyOriginalPath,
+    expectedNotify: notifyCmd,
+  });
+}
+
+async function loadAcodeNotifyOriginal(notifyOriginalPath) {
+  return loadNotifyOriginal(notifyOriginalPath);
+}
+
+async function readAcodeNotify(acodeConfigPath) {
+  return readNotify(acodeConfigPath);
+}
+
 async function upsertEveryCodeNotify({
   codeConfigPath,
   notifyCmd,
@@ -536,6 +573,7 @@ function arraysEqual(a, b) {
 
 module.exports = {
   buildCodexNotifyCmd,
+  buildAcodeNotifyCmd,
   buildEveryCodeNotifyCmd,
   isManagedNotifyCmd,
   upsertNotify,
@@ -546,6 +584,10 @@ module.exports = {
   restoreCodexNotify,
   loadCodexNotifyOriginal,
   readCodexNotify,
+  upsertAcodeNotify,
+  restoreAcodeNotify,
+  loadAcodeNotifyOriginal,
+  readAcodeNotify,
   upsertEveryCodeNotify,
   restoreEveryCodeNotify,
   loadEveryCodeNotifyOriginal,

package/src/lib/codex-rollout-parser.js

@@ -36,8 +36,8 @@ const MAX_DISCOVERY_INVENTORIES = 32;
 const DISCOVERY_INVENTORIES = new Map();
 const ZONED_DAY_FORMATTERS = new Map();
 const CODEX_RESUME_INVALIDATED = "TOKENTRACKER_CODEX_RESUME_INVALIDATED";
-// See src/lib/pricing/index.js: no observed Codex request reaches this
-// threshold yet (context window 258400), so long_context_* stays at zero.
+// Match src/lib/pricing/index.js. Classify individual requests using raw
+// input (including cache), not the accumulated session or day totals.
 const OPENAI_LONG_CONTEXT_INPUT_THRESHOLD = 272_000;
 
 // ---------------------------------------------------------------------------

package/src/lib/commandcode-limits.js

@@ -0,0 +1,317 @@
+// CommandCode subscription usage limits.
+//
+// Data source (authoritative, mirrors the CLI's own `/usage` overlay in
+// command-code 1.49.1):
+//
+//   GET https://api.commandcode.ai/alpha/whoami?limits=1
+//   GET https://api.commandcode.ai/alpha/billing/credits[?orgId=...]
+//   GET https://api.commandcode.ai/alpha/billing/subscriptions[?orgId=...]
+//
+// with `Authorization: Bearer <apiKey>`. The credits payload carries
+// `windowLimits: { limited, fiveHour: { used, cap, resetAt }, weekly: {...} }`
+// (resetAt is epoch milliseconds) plus a `credits` balance object; the
+// subscription payload carries `{ data: { planId, status, ... } }`.
+//
+// Auth resolution mirrors the CLI: `COMMAND_CODE_API_KEY` wins, otherwise the
+// `apiKey` field of `~/.commandcode/auth.json` (prod; written 0600 by
+// `cmd login`, never edited by hand). No key -> `{ configured: false }` so the
+// Limits panel hides the section instead of erroring.
+//
+// The API exposes 5h + weekly rolling caps; extra pay-as-you-go credits
+// bypass the caps server-side, so the reported used/cap needs no adjustment.
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const COMMANDCODE_API_BASE_URL = "https://api.commandcode.ai";
+const COMMANDCODE_API_KEY_ENV = "COMMAND_CODE_API_KEY";
+const COMMANDCODE_AUTH_DIRNAME = ".commandcode";
+const COMMANDCODE_AUTH_FILENAME = "auth.json";
+
+// Request timeouts are enforced by the caller: usage-limits.js passes a
+// withFetchTimeout-wrapped fetchImpl (per-request AbortSignal timeout), so this
+// module takes no timeout of its own.
+
+// Rolling window lengths are plan-independent and documented
+// (https://commandcode.ai/docs/resources/usage-limits): 5h + 7d.
+const COMMANDCODE_SESSION_WINDOW_SECONDS = 5 * 60 * 60;
+const COMMANDCODE_WEEKLY_WINDOW_SECONDS = 7 * 24 * 60 * 60;
+
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+// Explicit `home`/env HOME only — never os.homedir() — so a synthetic test env
+// (no home, no HOME) discovers nothing and tests stay isolated from the
+// developer's real ~/.commandcode (cf. resolveOpencodeDataDir).
+function resolveCommandcodeHome({ home, env = process.env } = {}) {
+  if (isNonEmptyString(home)) return home.trim();
+  const envHome = env && typeof env === "object" ? env.HOME : null;
+  if (isNonEmptyString(envHome)) return envHome.trim();
+  return null;
+}
+
+function resolveCommandcodeAuthPath({ home, env = process.env } = {}) {
+  const dir = resolveCommandcodeHome({ home, env });
+  if (!dir) return null;
+  return path.join(dir, COMMANDCODE_AUTH_DIRNAME, COMMANDCODE_AUTH_FILENAME);
+}
+
+function readCommandcodeApiKey({ home, env = process.env } = {}) {
+  const fromEnv =
+    env && typeof env === "object" ? env[COMMANDCODE_API_KEY_ENV] : null;
+  if (isNonEmptyString(fromEnv)) return fromEnv.trim();
+  const authPath = resolveCommandcodeAuthPath({ home, env });
+  if (!authPath) return null;
+  let raw;
+  try {
+    raw = fs.readFileSync(authPath, "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  return isNonEmptyString(parsed?.apiKey) ? parsed.apiKey.trim() : null;
+}
+
+function normalizeResetAt(value) {
+  if (value === null || value === undefined || value === "") return null;
+  if (
+    typeof value === "number" ||
+    /^\d+(?:\.\d+)?$/.test(String(value).trim())
+  ) {
+    const raw = Number(value);
+    if (!Number.isFinite(raw) || raw <= 0) return null;
+    const milliseconds = raw > 10_000_000_000 ? raw : raw * 1000;
+    const date = new Date(milliseconds);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+  }
+  const timestamp = Date.parse(String(value));
+  return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : null;
+}
+
+function clampPercent(value) {
+  if (value === null || value === undefined || value === "") return null;
+  const n = Number(value);
+  if (!Number.isFinite(n)) return null;
+  if (n <= 0) return 0;
+  if (n >= 100) return 100;
+  return n;
+}
+
+function buildWindow({ usedPercent, resetAt, windowSeconds = null }) {
+  const pct = clampPercent(usedPercent);
+  if (pct === null) return null;
+  const window = {
+    used_percent: pct,
+    reset_at: typeof resetAt === "string" && resetAt ? resetAt : null,
+  };
+  if (Number.isFinite(windowSeconds) && windowSeconds > 0) {
+    window.limit_window_seconds = windowSeconds;
+  }
+  return window;
+}
+
+// Upstream window rows are `{ used, cap, resetAt }` (epoch ms). Tolerate the
+// snake_case spellings other providers use so a server rename stays a miss on
+// one window, not a crash.
+function normalizeCommandcodeWindow(raw, windowSeconds) {
+  if (!raw || typeof raw !== "object") return null;
+  // Missing or malformed usage is unknown, not an unused (0%) window.
+  const numeric = (value) => typeof value === "number"
+    || (typeof value === "string" && value.trim() !== "" && Number.isFinite(Number(value)));
+  if (!numeric(raw.used) || !numeric(raw.cap ?? raw.total ?? raw.limit)) return null;
+  const used = Number(raw.used);
+  const cap = Number(raw.cap ?? raw.total ?? raw.limit);
+  if (!Number.isFinite(used) || !Number.isFinite(cap) || cap <= 0 || used < 0)
+    return null;
+  return buildWindow({
+    usedPercent: (used / cap) * 100,
+    resetAt: normalizeResetAt(raw.resetAt ?? raw.reset_at ?? raw.reset),
+    windowSeconds,
+  });
+}
+
+// Plan tiers (longest prefix first, mirroring the CLI's own getPlanInfo
+// matching in command-code). Unknown ids -> null, so the Limits panel renders
+// the bare "Command Code" brand (cf. Kimi/Grok — a raw id like
+// `individual-pro-v1` reads as garbage).
+const COMMANDCODE_PLAN_TIERS = [
+  ["individual-pro-v1", "Pro"],
+  ["individual-provider", "Provider"],
+  ["individual-goat", "GOAT"],
+  ["individual-go", "Go"],
+  ["individual-pro", "Pro"],
+  ["individual-max", "Max"],
+  ["individual-ultra", "Ultra"],
+  ["teams-pro", "Teams Pro"],
+];
+
+function deriveCommandcodePlanLabel(rawPlanId) {
+  if (!isNonEmptyString(rawPlanId)) return null;
+  const normalized = rawPlanId.trim().toLowerCase().replace(/_/g, "-");
+  for (const [prefix, label] of COMMANDCODE_PLAN_TIERS) {
+    if (normalized.startsWith(prefix)) return label;
+  }
+  return null;
+}
+
+function normalizeCommandcodeWindowLimits(windowLimits) {
+  if (!windowLimits || typeof windowLimits !== "object") return null;
+  const fiveHour = normalizeCommandcodeWindow(
+    windowLimits.fiveHour ?? windowLimits.five_hour,
+    COMMANDCODE_SESSION_WINDOW_SECONDS,
+  );
+  const weekly = normalizeCommandcodeWindow(
+    windowLimits.weekly,
+    COMMANDCODE_WEEKLY_WINDOW_SECONDS,
+  );
+  if (!fiveHour && !weekly) return null;
+
+  return { fiveHour, weekly };
+}
+
+// The Bearer apiKey travels on every request, so the origin must be https.
+// Plain http is accepted for loopback only (local staging/dev servers).
+function resolveCommandcodeOrigin(baseUrl) {
+  const origin = String(baseUrl || COMMANDCODE_API_BASE_URL).replace(
+    /\/+$/,
+    "",
+  );
+  let parsed;
+  try {
+    parsed = new URL(origin);
+  } catch {
+    throw new Error("CommandCode API base URL is invalid.");
+  }
+  const loopback = /^(localhost|127\.\d+\.\d+\.\d+|\[::1\])$/i.test(
+    parsed.hostname,
+  );
+  if (parsed.protocol !== "https:" && !loopback) {
+    throw new Error(
+      "CommandCode API base URL must use https (http is loopback-only).",
+    );
+  }
+  return origin;
+}
+
+function commandcodeHeaders(apiKey) {
+  return {
+    Accept: "application/json",
+    Authorization: `Bearer ${apiKey}`,
+  };
+}
+
+async function fetchCommandcodeJson({ url, apiKey, fetchImpl, label }) {
+  let response;
+  try {
+    response = await fetchImpl(url, { headers: commandcodeHeaders(apiKey) });
+  } catch (error) {
+    throw new Error(
+      `CommandCode ${label} request failed: ${error?.message || "network error"}`,
+    );
+  }
+  if (response?.status === 401 || response?.status === 403) {
+    const error = new Error(
+      "CommandCode token expired — run `cmd login` (macOS/Linux) or `cmdc auth login` (Windows) to refresh.",
+    );
+    error.code = "AUTH_EXPIRED";
+    throw error;
+  }
+  if (!response?.ok) {
+    throw new Error(
+      `CommandCode ${label} request failed (HTTP ${response?.status ?? "?"}).`,
+    );
+  }
+  try {
+    return await response.json();
+  } catch {
+    throw new Error(`${label} response was not JSON.`);
+  }
+}
+
+function withOrgParam(route, orgId) {
+  if (orgId === null || orgId === undefined || String(orgId).trim() === "")
+    return route;
+  return `${route}?orgId=${encodeURIComponent(String(orgId).trim())}`;
+}
+
+// Returns `{ configured: false }` without credentials, or the normalized limits
+// object on success. Auth expiry throws with `code: "AUTH_EXPIRED"` and every
+// other transport/schema failure throws a readable Error — the aggregator in
+// usage-limits.js converts both into the panel row.
+async function fetchCommandcodeLimits({
+  home,
+  env = process.env,
+  fetchImpl = fetch,
+  baseUrl = COMMANDCODE_API_BASE_URL,
+} = {}) {
+  const apiKey = readCommandcodeApiKey({ home, env });
+  if (!apiKey) return { configured: false };
+
+  const origin = resolveCommandcodeOrigin(baseUrl);
+  const whoami = await fetchCommandcodeJson({
+    url: `${origin}/alpha/whoami?limits=1`,
+    apiKey,
+    fetchImpl,
+    label: "account lookup",
+  });
+  const orgId = whoami?.data?.org?.id ?? whoami?.org?.id ?? null;
+
+  const [creditsBody, subscriptionBody] = await Promise.all([
+    fetchCommandcodeJson({
+      url: `${origin}${withOrgParam("/alpha/billing/credits", orgId)}`,
+      apiKey,
+      fetchImpl,
+      label: "credits lookup",
+    }),
+    fetchCommandcodeJson({
+      url: `${origin}${withOrgParam("/alpha/billing/subscriptions", orgId)}`,
+      apiKey,
+      fetchImpl,
+      label: "subscription lookup",
+    }),
+  ]);
+
+  const windows = normalizeCommandcodeWindowLimits(creditsBody?.windowLimits);
+  if (!windows) {
+    throw new Error("CommandCode credits response is missing windowLimits.");
+  }
+  const subscription = subscriptionBody?.data ?? subscriptionBody ?? null;
+  const planId = isNonEmptyString(subscription?.planId)
+    ? subscription.planId.trim()
+    : null;
+
+  return {
+    configured: true,
+    error: null,
+    plan_label: deriveCommandcodePlanLabel(planId),
+    subscription_status: isNonEmptyString(subscription?.status)
+      ? subscription.status.trim()
+      : null,
+    primary_window: windows.fiveHour,
+    secondary_window: windows.weekly,
+    stale: false,
+    cached_at: new Date().toISOString(),
+  };
+}
+
+module.exports = {
+  COMMANDCODE_API_BASE_URL,
+  COMMANDCODE_API_KEY_ENV,
+  COMMANDCODE_SESSION_WINDOW_SECONDS,
+  COMMANDCODE_WEEKLY_WINDOW_SECONDS,
+  resolveCommandcodeHome,
+  resolveCommandcodeAuthPath,
+  readCommandcodeApiKey,
+  deriveCommandcodePlanLabel,
+  normalizeResetAt,
+  normalizeCommandcodeWindow,
+  normalizeCommandcodeWindowLimits,
+  resolveCommandcodeOrigin,
+  fetchCommandcodeLimits,
+};

package/src/lib/devin-limits.js

@@ -0,0 +1,249 @@
+// Devin subscription usage limits.
+//
+// Source: the official seat-management RPC the Devin web app calls,
+//   POST https://server.codeium.com/exa.seat_management_pb.SeatManagementService/GetPlanStatus
+// authenticated by `x-auth-token` — the session token the Devin CLI stores in
+// $XDG_DATA_HOME/devin/credentials.toml (~/.local/share/devin/ fallback).
+//
+// Two non-obvious contract points, both verified against the official
+// generated descriptor (docs/devin-limits.md):
+//   - the quota percent/reset fields are proto3 implicit scalars, so the
+//     server omits them at 0: absent percent + live reset = exhausted
+//     (100% used), both absent = no such window;
+//   - a non-default api_server_url is an unsupported configuration, never a
+//     different request destination — the token only ever goes to the fixed
+//     host above.
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const DEVIN_PLAN_STATUS_URL =
+  "https://server.codeium.com/exa.seat_management_pb.SeatManagementService/GetPlanStatus";
+const DEVIN_API_ORIGIN = "https://server.codeium.com";
+
+const DEVIN_DAILY_WINDOW_SECONDS = 24 * 60 * 60;
+const DEVIN_WEEKLY_WINDOW_SECONDS = 7 * 24 * 60 * 60;
+
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+// Minimal root-level TOML reader for the CLI-written credentials file: bare
+// `key = value` lines before the first `[section]`, nothing else.
+function parseDevinCredentialsToml(raw) {
+  const fields = {};
+  for (const line of String(raw).split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith("[")) break;
+    const match = /^([A-Za-z0-9_]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s#]+))\s*(?:#.*)?$/.exec(
+      trimmed,
+    );
+    if (!match) continue;
+    const [, key, doubleQuoted, singleQuoted, bare] = match;
+    fields[key] = doubleQuoted ?? singleQuoted ?? bare ?? "";
+  }
+  return fields;
+}
+
+// Returns { apiKey } or null when no sign-in exists (no home, or the file is
+// absent — ENOENT only). Any other read failure or a mangled file throws an
+// owned, actionable error with no path or filesystem details, so a broken
+// sign-in can never masquerade as "not configured".
+function readDevinCredentials({ home, env = process.env } = {}) {
+  const xdg = env && typeof env === "object" ? env.XDG_DATA_HOME : null;
+  const dir = isNonEmptyString(xdg)
+    ? xdg.trim()
+    : isNonEmptyString(home)
+      ? home.trim()
+      : isNonEmptyString(env?.HOME)
+        ? env.HOME.trim()
+        : null;
+  if (!dir) return null;
+  const base = isNonEmptyString(xdg)
+    ? path.join(dir, "devin", "credentials.toml")
+    : path.join(dir, ".local", "share", "devin", "credentials.toml");
+  let raw;
+  try {
+    raw = fs.readFileSync(base, "utf8");
+  } catch (error) {
+    if (error && error.code === "ENOENT") return null;
+    throw new Error(
+      "Could not read the Devin CLI credentials file — check its permissions or run `devin auth login` to sign in again.",
+    );
+  }
+  const fields = parseDevinCredentialsToml(raw);
+  const apiKey = isNonEmptyString(fields.windsurf_api_key)
+    ? fields.windsurf_api_key.trim()
+    : null;
+  if (!apiKey) {
+    throw new Error(
+      "Devin credentials file has no sign-in token — run `devin auth login`.",
+    );
+  }
+  const apiServerUrl = isNonEmptyString(fields.api_server_url)
+    ? fields.api_server_url.trim().replace(/\/+$/, "")
+    : null;
+  if (apiServerUrl && apiServerUrl !== DEVIN_API_ORIGIN) {
+    throw new Error(
+      "Devin credentials point at a custom api_server_url, which this quota provider does not support.",
+    );
+  }
+  return { apiKey };
+}
+
+function malformed(field) {
+  return new Error(`Devin quota response has a malformed ${field}.`);
+}
+
+// undefined → proto-default semantics handled by the caller; null/non-numeric
+// → malformed. Percentages are clamped defensively to 0..100.
+function normalizeRemainingPercent(value) {
+  if (value === undefined) return undefined;
+  if (typeof value !== "number" && typeof value !== "string") {
+    throw malformed("quota remaining percent");
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    throw malformed("quota remaining percent");
+  }
+  const n = Number(value);
+  if (!Number.isFinite(n)) throw malformed("quota remaining percent");
+  if (n <= 0) return 0;
+  if (n >= 100) return 100;
+  return n;
+}
+
+// int64 unix seconds (JSON string or number). undefined or proto-default 0 →
+// absent; null/non-numeric/non-positive → malformed. Returns epoch ms.
+function normalizeResetMs(value) {
+  if (value === undefined || value === 0 || value === "0") return null;
+  if (typeof value !== "number" && typeof value !== "string") {
+    throw malformed("quota reset timestamp");
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    throw malformed("quota reset timestamp");
+  }
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) throw malformed("quota reset timestamp");
+  const ms = n * 1000;
+  if (!Number.isFinite(new Date(ms).getTime())) {
+    throw malformed("quota reset timestamp");
+  }
+  return ms;
+}
+
+function normalizeWindow({ remainingPercent, resetUnix, hidden, windowSeconds }) {
+  if (hidden === true) return null;
+  const resetMs = normalizeResetMs(resetUnix);
+  const remaining = normalizeRemainingPercent(remainingPercent);
+  if (remaining === undefined && resetMs === null) return null;
+  return {
+    used_percent: remaining === undefined ? 100 : 100 - remaining,
+    reset_at: resetMs === null ? null : new Date(resetMs).toISOString(),
+    limit_window_seconds: windowSeconds,
+  };
+}
+
+function normalizePlanStatus(body) {
+  const planStatus =
+    body && typeof body === "object" ? body.planStatus : undefined;
+  if (!planStatus || typeof planStatus !== "object") {
+    throw new Error("Devin quota response is missing planStatus.");
+  }
+  const planInfo =
+    planStatus.planInfo && typeof planStatus.planInfo === "object"
+      ? planStatus.planInfo
+      : {};
+  const planLabel = isNonEmptyString(planInfo.planName)
+    ? planInfo.planName.trim()
+    : null;
+
+  // Legacy Windsurf billing fills ACU credit fields instead of the daily /
+  // weekly quota; those strategies have nothing renderable here.
+  const billingStrategy = planInfo.billingStrategy;
+  if (
+    billingStrategy !== undefined &&
+    billingStrategy !== "BILLING_STRATEGY_QUOTA"
+  ) {
+    return { plan_label: planLabel, primary_window: null, secondary_window: null };
+  }
+
+  return {
+    plan_label: planLabel,
+    primary_window: normalizeWindow({
+      remainingPercent: planStatus.dailyQuotaRemainingPercent,
+      resetUnix: planStatus.dailyQuotaResetAtUnix,
+      hidden: planInfo.hideDailyQuota === true,
+      windowSeconds: DEVIN_DAILY_WINDOW_SECONDS,
+    }),
+    secondary_window: normalizeWindow({
+      remainingPercent: planStatus.weeklyQuotaRemainingPercent,
+      resetUnix: planStatus.weeklyQuotaResetAtUnix,
+      hidden: planInfo.hideWeeklyQuota === true,
+      windowSeconds: DEVIN_WEEKLY_WINDOW_SECONDS,
+    }),
+  };
+}
+
+// `{ configured: false }` when the provider is not enabled or no Devin CLI
+// sign-in exists, otherwise the normalized windows. `enabled` is the user's
+// explicit provider selection forwarded from the local API — without it the
+// credentials file is never opened and no request is made. Throws owned
+// errors only — never raw upstream bodies, filesystem paths or token values.
+// `code: "AUTH_EXPIRED"` flags genuine auth failure for the aggregator's
+// auth_action_required path.
+async function fetchDevinLimits({ home, env = process.env, enabled = false, fetchImpl = fetch } = {}) {
+  if (enabled !== true) return { configured: false };
+  const credentials = readDevinCredentials({ home, env });
+  if (!credentials) return { configured: false };
+
+  let response;
+  try {
+    response = await fetchImpl(DEVIN_PLAN_STATUS_URL, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "Connect-Protocol-Version": "1",
+        "x-auth-token": credentials.apiKey,
+      },
+      body: "{}",
+      // The session token must never reach another origin.
+      redirect: "error",
+    });
+  } catch (error) {
+    throw new Error(
+      error && (error.name === "AbortError" || error.name === "TimeoutError")
+        ? "Devin quota request timed out."
+        : "Devin quota request failed.",
+    );
+  }
+  if (response?.status === 401 || response?.status === 403) {
+    const error = new Error(
+      "Devin sign-in expired or was rejected — run `devin auth login` to sign in again.",
+    );
+    error.code = "AUTH_EXPIRED";
+    throw error;
+  }
+  if (!response?.ok) {
+    throw new Error(
+      `Devin quota request was rejected (HTTP ${response?.status ?? "?"}).`,
+    );
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    throw new Error("Devin quota response was not JSON.");
+  }
+  const windows = normalizePlanStatus(body);
+  return {
+    configured: true,
+    error: null,
+    plan_label: windows.plan_label,
+    primary_window: windows.primary_window,
+    secondary_window: windows.secondary_window,
+  };
+}
+
+module.exports = { fetchDevinLimits };