tokentracker-cli 0.5.21 → 0.5.24

package/src/lib/usage-limits.js

@@ -0,0 +1,1092 @@
+const cp = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+const http = require("node:http");
+const https = require("node:https");
+
+const { readClaudeCodeAccessToken, readCodexAccessToken } = require("./subscriptions");
+const {
+  isCursorInstalled,
+  extractCursorSessionToken,
+  fetchCursorUsageSummary,
+} = require("./cursor-config");
+
+// 2-minute in-memory cache
+let cache = { data: null, fetchedAt: 0 };
+const CACHE_TTL_MS = 2 * 60 * 1000;
+
+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 }) {
+  const pct = clampPercent(usedPercent);
+  if (pct === null) return null;
+  return {
+    used_percent: pct,
+    reset_at: typeof resetAt === "string" && resetAt ? resetAt : null,
+  };
+}
+
+function decodeJwtPayload(token) {
+  if (typeof token !== "string" || token.length === 0) return null;
+  const parts = token.split(".");
+  if (parts.length < 2) return null;
+  const payload = parts[1];
+  const padLen = (4 - (payload.length % 4)) % 4;
+  const padded = payload + "=".repeat(padLen);
+  const base64 = padded.replace(/-/g, "+").replace(/_/g, "/");
+  try {
+    return JSON.parse(Buffer.from(base64, "base64").toString("utf8"));
+  } catch (_error) {
+    return null;
+  }
+}
+
+async function fetchClaudeUsageLimits(accessToken, { fetchImpl = fetch } = {}) {
+  const res = await fetchImpl("https://api.anthropic.com/api/oauth/usage", {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "anthropic-beta": "oauth-2025-04-20",
+      Accept: "application/json",
+    },
+  });
+  if (res.status === 401) {
+    throw new Error("token_expired");
+  }
+  if (!res.ok) {
+    throw new Error(`Claude API returned ${res.status}`);
+  }
+  const body = await res.json();
+  return {
+    five_hour: body.five_hour ?? null,
+    seven_day: body.seven_day ?? null,
+    seven_day_opus: body.seven_day_opus ?? null,
+    extra_usage: body.extra_usage ?? null,
+  };
+}
+
+async function fetchCodexUsageLimits(accessToken, { fetchImpl = fetch } = {}) {
+  const res = await fetchImpl("https://chatgpt.com/backend-api/wham/usage", {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      Accept: "application/json",
+    },
+  });
+  if (!res.ok) {
+    throw new Error(`Codex API returned ${res.status}`);
+  }
+  const body = await res.json();
+  const rateLimit = body.rate_limit || {};
+  return {
+    primary_window: rateLimit.primary_window ?? null,
+    secondary_window: rateLimit.secondary_window ?? null,
+  };
+}
+
+function normalizeCursorUsageSummary(body) {
+  const plan = body?.individualUsage?.plan || null;
+  const billingCycleEnd = typeof body?.billingCycleEnd === "string" ? body.billingCycleEnd : null;
+  const autoPercent = clampPercent(plan?.autoPercentUsed);
+  const apiPercent = clampPercent(plan?.apiPercentUsed);
+
+  let planPercent = clampPercent(plan?.totalPercentUsed);
+  if (planPercent === null) {
+    const used = Number(plan?.used);
+    const limit = Number(plan?.limit);
+    if (Number.isFinite(used) && Number.isFinite(limit) && limit > 0) {
+      planPercent = clampPercent((used / limit) * 100);
+    } else if (autoPercent !== null && apiPercent !== null) {
+      planPercent = clampPercent((autoPercent + apiPercent) / 2);
+    } else if (autoPercent !== null) {
+      planPercent = autoPercent;
+    } else if (apiPercent !== null) {
+      planPercent = apiPercent;
+    }
+  }
+
+  return {
+    membership_type: typeof body?.membershipType === "string" ? body.membershipType : null,
+    primary_window: buildWindow({ usedPercent: planPercent, resetAt: billingCycleEnd }),
+    secondary_window: buildWindow({ usedPercent: autoPercent, resetAt: billingCycleEnd }),
+    tertiary_window: buildWindow({ usedPercent: apiPercent, resetAt: billingCycleEnd }),
+  };
+}
+
+async function fetchCursorLimits({ home, fetchImpl = fetch } = {}) {
+  if (!isCursorInstalled({ home })) {
+    return { configured: false };
+  }
+  const auth = extractCursorSessionToken({ home });
+  if (!auth?.cookie) {
+    return { configured: false };
+  }
+  try {
+    const body = await fetchCursorUsageSummary({ cookie: auth.cookie, fetchImpl });
+    return {
+      configured: true,
+      error: null,
+      ...normalizeCursorUsageSummary(body),
+    };
+  } catch (error) {
+    return {
+      configured: true,
+      error: error?.message || "Unknown error",
+    };
+  }
+}
+
+function resolveGeminiHome({ home, env } = {}) {
+  const explicit = typeof env?.GEMINI_HOME === "string" ? env.GEMINI_HOME.trim() : "";
+  return explicit ? path.resolve(explicit) : path.join(home, ".gemini");
+}
+
+function loadGeminiSettings({ home, env } = {}) {
+  const geminiHome = resolveGeminiHome({ home, env });
+  const settingsPath = path.join(geminiHome, "settings.json");
+  if (!fs.existsSync(settingsPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+  } catch (_error) {
+    return null;
+  }
+}
+
+function loadGeminiCredentials({ home, env } = {}) {
+  const geminiHome = resolveGeminiHome({ home, env });
+  const credsPath = path.join(geminiHome, "oauth_creds.json");
+  if (!fs.existsSync(credsPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(credsPath, "utf8"));
+  } catch (_error) {
+    return null;
+  }
+}
+
+function extractGeminiOauthClientCredentials({ commandRunner } = {}) {
+  const result = runCommand(commandRunner, "which", ["gemini"], { timeout: 2000 });
+  const geminiPath = typeof result?.stdout === "string" ? result.stdout.trim() : "";
+  if (!geminiPath) return null;
+
+  let realPath = geminiPath;
+  try {
+    const resolved = fs.readlinkSync(geminiPath);
+    realPath = path.isAbsolute(resolved)
+      ? resolved
+      : path.join(path.dirname(geminiPath), resolved);
+  } catch (_error) {}
+
+  const binDir = path.dirname(realPath);
+  const baseDir = path.dirname(binDir);
+  const candidates = [
+    path.join(baseDir, "libexec/lib/node_modules/@google/gemini-cli/node_modules/@google/gemini-cli-core/dist/src/code_assist/oauth2.js"),
+    path.join(baseDir, "lib/node_modules/@google/gemini-cli/node_modules/@google/gemini-cli-core/dist/src/code_assist/oauth2.js"),
+    path.join(baseDir, "share/gemini-cli/node_modules/@google/gemini-cli-core/dist/src/code_assist/oauth2.js"),
+    path.join(baseDir, "../gemini-cli-core/dist/src/code_assist/oauth2.js"),
+    path.join(baseDir, "node_modules/@google/gemini-cli-core/dist/src/code_assist/oauth2.js"),
+  ];
+
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) continue;
+    try {
+      const content = fs.readFileSync(candidate, "utf8");
+      const clientId = content.match(/OAUTH_CLIENT_ID\s*=\s*['"]([\w\-\.]+)['"]\s*;/)?.[1] || null;
+      const clientSecret = content.match(/OAUTH_CLIENT_SECRET\s*=\s*['"]([\w\-]+)['"]\s*;/)?.[1] || null;
+      if (clientId && clientSecret) {
+        return { clientId, clientSecret };
+      }
+    } catch (_error) {}
+  }
+  return null;
+}
+
+async function refreshGeminiAccessToken({
+  refreshToken,
+  home,
+  env,
+  fetchImpl = fetch,
+  commandRunner,
+}) {
+  const oauthClient = extractGeminiOauthClientCredentials({ commandRunner });
+  if (!oauthClient?.clientId || !oauthClient?.clientSecret) {
+    throw new Error("Gemini API error: Could not find Gemini CLI OAuth configuration");
+  }
+
+  const body = new URLSearchParams({
+    client_id: oauthClient.clientId,
+    client_secret: oauthClient.clientSecret,
+    refresh_token: refreshToken,
+    grant_type: "refresh_token",
+  });
+
+  const res = await fetchImpl("https://oauth2.googleapis.com/token", {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body,
+  });
+  if (!res.ok) {
+    throw new Error("Not logged in to Gemini. Run 'gemini' in Terminal to authenticate.");
+  }
+
+  const json = await res.json();
+  if (!json?.access_token) {
+    throw new Error("Could not parse Gemini usage: invalid token refresh response");
+  }
+
+  const geminiHome = resolveGeminiHome({ home, env });
+  const credsPath = path.join(geminiHome, "oauth_creds.json");
+  try {
+    const creds = loadGeminiCredentials({ home, env }) || {};
+    creds.access_token = json.access_token;
+    if (json.id_token) creds.id_token = json.id_token;
+    if (typeof json.expires_in === "number" && Number.isFinite(json.expires_in)) {
+      creds.expiry_date = Date.now() + json.expires_in * 1000;
+    }
+    fs.writeFileSync(credsPath, JSON.stringify(creds, null, 2));
+  } catch (_error) {}
+
+  return json.access_token;
+}
+
+async function loadGeminiCodeAssistStatus(accessToken, { fetchImpl = fetch } = {}) {
+  const res = await fetchImpl("https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ metadata: { ideType: "GEMINI_CLI", pluginType: "GEMINI" } }),
+  });
+  if (!res.ok) {
+    return { tier: null, projectId: null };
+  }
+  const json = await res.json();
+  const tier = typeof json?.currentTier?.id === "string" ? json.currentTier.id : null;
+  const rawProject = json?.cloudaicompanionProject;
+  const projectId =
+    typeof rawProject === "string"
+      ? rawProject.trim() || null
+      : typeof rawProject?.id === "string"
+        ? rawProject.id
+        : typeof rawProject?.projectId === "string"
+          ? rawProject.projectId
+          : null;
+  return { tier, projectId };
+}
+
+function normalizeGeminiModelBuckets(buckets) {
+  if (!Array.isArray(buckets)) return [];
+  const byModel = new Map();
+  for (const bucket of buckets) {
+    const modelId = typeof bucket?.modelId === "string" ? bucket.modelId : null;
+    const remainingFraction = Number(bucket?.remainingFraction);
+    if (!modelId || !Number.isFinite(remainingFraction)) continue;
+    const existing = byModel.get(modelId);
+    if (!existing || remainingFraction < existing.remainingFraction) {
+      byModel.set(modelId, {
+        model_id: modelId,
+        remainingFraction,
+        reset_at: parseAntigravityDate(bucket?.resetTime),
+      });
+    }
+  }
+  return Array.from(byModel.values()).sort((a, b) => a.model_id.localeCompare(b.model_id));
+}
+
+function isGeminiFlashLiteModel(id) {
+  return String(id || "").toLowerCase().includes("flash-lite");
+}
+
+function isGeminiFlashModel(id) {
+  const lower = String(id || "").toLowerCase();
+  return lower.includes("flash") && !isGeminiFlashLiteModel(lower);
+}
+
+function isGeminiProModel(id) {
+  return String(id || "").toLowerCase().includes("pro");
+}
+
+function normalizeGeminiQuotaResponse({ buckets, email, tier }) {
+  const models = normalizeGeminiModelBuckets(buckets);
+  if (!models.length) {
+    throw new Error("Could not parse Gemini usage: no quota buckets in response");
+  }
+
+  const pickLowest = (predicate) =>
+    models
+      .filter((model) => predicate(model.model_id))
+      .sort((a, b) => a.remainingFraction - b.remainingFraction)[0] || null;
+
+  const plan =
+    tier === "standard-tier"
+      ? "Paid"
+      : tier === "legacy-tier"
+        ? "Legacy"
+        : tier === "free-tier"
+          ? "Free"
+          : null;
+
+  const pro = pickLowest(isGeminiProModel);
+  const flash = pickLowest(isGeminiFlashModel);
+  const flashLite = pickLowest(isGeminiFlashLiteModel);
+  const fallback = !pro && !flash && !flashLite
+    ? [...models].sort((a, b) => a.remainingFraction - b.remainingFraction)[0]
+    : null;
+
+  const toWindow = (model) =>
+    model
+      ? buildWindow({
+          usedPercent: 100 - model.remainingFraction * 100,
+          resetAt: model.reset_at,
+        })
+      : null;
+
+  return {
+    account_email: email || null,
+    account_plan: plan,
+    primary_window: toWindow(pro || fallback),
+    secondary_window: toWindow(flash),
+    tertiary_window: toWindow(flashLite),
+  };
+}
+
+async function fetchGeminiLimits({ home, env, fetchImpl = fetch, commandRunner } = {}) {
+  const settings = loadGeminiSettings({ home, env });
+  const selectedType = settings?.security?.auth?.selectedType ?? null;
+  if (!settings && !loadGeminiCredentials({ home, env })) {
+    return { configured: false };
+  }
+  if (selectedType === "api-key") {
+    return { configured: true, error: "Gemini API key auth not supported. Use Google account (OAuth) instead." };
+  }
+  if (selectedType === "vertex-ai") {
+    return { configured: true, error: "Gemini Vertex AI auth not supported. Use Google account (OAuth) instead." };
+  }
+
+  const creds = loadGeminiCredentials({ home, env });
+  if (!creds?.access_token) {
+    return { configured: true, error: "Not logged in to Gemini. Run 'gemini' in Terminal to authenticate." };
+  }
+
+  try {
+    let accessToken = creds.access_token;
+    const expiry = Number(creds.expiry_date);
+    if (Number.isFinite(expiry) && expiry > 0 && expiry < Date.now() && creds.refresh_token) {
+      accessToken = await refreshGeminiAccessToken({
+        refreshToken: creds.refresh_token,
+        home,
+        env,
+        fetchImpl,
+        commandRunner,
+      });
+    }
+
+    const claims = decodeJwtPayload(creds.id_token);
+    const codeAssist = await loadGeminiCodeAssistStatus(accessToken, { fetchImpl });
+    const res = await fetchImpl("https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(codeAssist.projectId ? { project: codeAssist.projectId } : {}),
+    });
+    if (res.status === 401) {
+      throw new Error("Not logged in to Gemini. Run 'gemini' in Terminal to authenticate.");
+    }
+    if (!res.ok) {
+      throw new Error(`Gemini API error: HTTP ${res.status}`);
+    }
+    const json = await res.json();
+    return {
+      configured: true,
+      error: null,
+      ...normalizeGeminiQuotaResponse({
+        buckets: json?.buckets,
+        email: claims?.email || null,
+        tier: codeAssist.tier,
+      }),
+    };
+  } catch (error) {
+    return {
+      configured: true,
+      error: error?.message || "Unknown error",
+    };
+  }
+}
+
+function runCommand(commandRunner, command, args, options = {}) {
+  const runner = typeof commandRunner === "function" ? commandRunner : cp.spawnSync;
+  return runner(command, args, {
+    encoding: "utf8",
+    maxBuffer: 10 * 1024 * 1024,
+    ...options,
+  });
+}
+
+function isBinaryAvailable(binary, { commandRunner } = {}) {
+  const result = runCommand(commandRunner, "which", [binary], { timeout: 2000 });
+  return !result?.error && result?.status === 0;
+}
+
+function stripAnsi(text) {
+  return String(text || "").replace(/\x1B\[[0-9;?]*[A-Za-z]|\x1B\].*?\x07/g, "");
+}
+
+function extractFirstNumber(text) {
+  const match = String(text || "").match(/-?\d+(?:\.\d+)?/);
+  return match ? Number(match[0]) : null;
+}
+
+function parseMonthDayResetDate(dateStr, now = new Date()) {
+  if (typeof dateStr !== "string") return null;
+  const match = dateStr.match(/(\d{2})\/(\d{2})/);
+  if (!match) return null;
+  const month = Number(match[1]);
+  const day = Number(match[2]);
+  if (!Number.isFinite(month) || !Number.isFinite(day)) return null;
+  const currentYear = now.getUTCFullYear();
+
+  let candidate = new Date(Date.UTC(currentYear, month - 1, day, 0, 0, 0, 0));
+  if (candidate.getTime() <= now.getTime()) {
+    candidate = new Date(Date.UTC(currentYear + 1, month - 1, day, 0, 0, 0, 0));
+  }
+  return candidate.toISOString();
+}
+
+function isKiroUsageOutputComplete(output) {
+  const lowered = stripAnsi(output).toLowerCase();
+  return lowered.includes("covered in plan")
+    || lowered.includes("resets on")
+    || lowered.includes("bonus credits")
+    || lowered.includes("plan:")
+    || lowered.includes("managed by admin")
+    || lowered.includes("managed by organization");
+}
+
+function parseKiroUsageOutput(output, { now = new Date() } = {}) {
+  const stripped = stripAnsi(output).trim();
+  if (!stripped) {
+    throw new Error("Failed to parse Kiro usage: empty output");
+  }
+
+  const lowered = stripped.toLowerCase();
+  if (
+    lowered.includes("not logged in")
+    || lowered.includes("login required")
+    || lowered.includes("failed to initialize auth portal")
+    || lowered.includes("kiro-cli login")
+    || lowered.includes("oauth error")
+  ) {
+    throw new Error("Not logged in to Kiro. Run 'kiro-cli login' first.");
+  }
+  if (lowered.includes("could not retrieve usage information")) {
+    throw new Error("Failed to parse Kiro usage: Kiro CLI could not retrieve usage information.");
+  }
+
+  let planName = "Kiro";
+  const legacyPlan = stripped.match(/\|\s*(KIRO\s+\w+)/);
+  if (legacyPlan?.[1]) {
+    planName = legacyPlan[1].trim();
+  }
+  const modernPlan = stripped.match(/Plan:\s*(.+)/);
+  if (modernPlan?.[1]) {
+    planName = modernPlan[1].split("\n")[0].trim() || planName;
+  }
+
+  const resetMatch = stripped.match(/resets on (\d{2}\/\d{2})/i);
+  const primaryReset = resetMatch ? parseMonthDayResetDate(resetMatch[1], now) : null;
+
+  let creditsPercent = null;
+  const percentMatch = stripped.match(/█+\s*(\d+)%/);
+  if (percentMatch?.[1]) {
+    creditsPercent = clampPercent(Number(percentMatch[1]));
+  }
+
+  let creditsUsed = null;
+  let creditsTotal = null;
+  const coveredMatch = stripped.match(/\((\d+(?:\.\d+)?)\s+of\s+(\d+(?:\.\d+)?)\s+covered/i);
+  if (coveredMatch?.[1] && coveredMatch?.[2]) {
+    creditsUsed = Number(coveredMatch[1]);
+    creditsTotal = Number(coveredMatch[2]);
+  }
+  if (creditsPercent === null && creditsUsed !== null && creditsTotal && creditsTotal > 0) {
+    creditsPercent = clampPercent((creditsUsed / creditsTotal) * 100);
+  }
+
+  const managedPlan = lowered.includes("managed by admin") || lowered.includes("managed by organization");
+  if (creditsPercent === null && creditsUsed === null && managedPlan) {
+    return {
+      plan_name: planName,
+      primary_window: buildWindow({ usedPercent: 0, resetAt: null }),
+      secondary_window: null,
+    };
+  }
+  if (creditsPercent === null && creditsUsed === null) {
+    throw new Error("Failed to parse Kiro usage: usage output format may have changed.");
+  }
+
+  let bonusWindow = null;
+  const bonusMatch = stripped.match(/Bonus credits:[\s\S]*?(\d+(?:\.\d+)?)\/(\d+(?:\.\d+)?)/i);
+  const expiryMatch = stripped.match(/expires in (\d+) days?/i);
+  if (bonusMatch?.[1] && bonusMatch?.[2]) {
+    const bonusUsed = Number(bonusMatch[1]);
+    const bonusTotal = Number(bonusMatch[2]);
+    const bonusPct = bonusTotal > 0 ? clampPercent((bonusUsed / bonusTotal) * 100) : 0;
+    let bonusReset = null;
+    if (expiryMatch?.[1]) {
+      const days = Number(expiryMatch[1]);
+      if (Number.isFinite(days) && days >= 0) {
+        bonusReset = new Date(now.getTime() + days * 24 * 60 * 60 * 1000).toISOString();
+      }
+    }
+    bonusWindow = buildWindow({ usedPercent: bonusPct, resetAt: bonusReset });
+  }
+
+  return {
+    plan_name: planName,
+    primary_window: buildWindow({ usedPercent: creditsPercent, resetAt: primaryReset }),
+    secondary_window: bonusWindow,
+  };
+}
+
+function fetchKiroLimits({ commandRunner, now = new Date() } = {}) {
+  if (!isBinaryAvailable("kiro-cli", { commandRunner })) {
+    return { configured: false };
+  }
+
+  const result = runCommand(
+    commandRunner,
+    "kiro-cli",
+    ["chat", "--no-interactive", "/usage"],
+    {
+      timeout: 20_000,
+      env: { ...process.env, TERM: "xterm-256color" },
+    },
+  );
+
+  const stdout = typeof result?.stdout === "string" ? result.stdout : "";
+  const stderr = typeof result?.stderr === "string" ? result.stderr : "";
+  const output = stderr.trim() || stdout.trim();
+
+  try {
+    if (result?.error?.code === "ETIMEDOUT" && !isKiroUsageOutputComplete(output)) {
+      throw new Error("Kiro CLI timed out.");
+    }
+    if (!output && result?.status !== 0) {
+      throw new Error(`Kiro CLI failed with status ${result.status}.`);
+    }
+
+    return {
+      configured: true,
+      error: null,
+      ...parseKiroUsageOutput(output, { now }),
+    };
+  } catch (error) {
+    return {
+      configured: true,
+      error: error?.message || "Unknown error",
+    };
+  }
+}
+
+function parseProcessLine(line) {
+  const match = String(line || "")
+    .trim()
+    .match(/^(\d+)\s+(.*)$/);
+  if (!match) return null;
+  return {
+    pid: Number(match[1]),
+    command: match[2],
+  };
+}
+
+function isAntigravityCommandLine(command) {
+  const lower = String(command || "").toLowerCase();
+  return lower.includes("language_server_macos")
+    && (
+      (lower.includes("--app_data_dir") && lower.includes("antigravity"))
+      || lower.includes("/antigravity/")
+      || lower.includes("\\antigravity\\")
+    );
+}
+
+function extractCommandFlag(command, flag) {
+  const escaped = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = String(command || "").match(new RegExp(`${escaped}[=\\s]+([^\\s]+)`, "i"));
+  return match?.[1] || null;
+}
+
+function detectAntigravityProcess({ commandRunner } = {}) {
+  const result = runCommand(commandRunner, "/bin/ps", ["-ax", "-o", "pid=,command="], {
+    timeout: 4000,
+  });
+  const lines = String(result?.stdout || "").split("\n");
+
+  let sawProcess = false;
+  for (const line of lines) {
+    const parsed = parseProcessLine(line);
+    if (!parsed) continue;
+    if (!isAntigravityCommandLine(parsed.command)) continue;
+    sawProcess = true;
+    const csrfToken = extractCommandFlag(parsed.command, "--csrf_token");
+    if (!csrfToken) continue;
+    const extensionPort = extractFirstNumber(extractCommandFlag(parsed.command, "--extension_server_port"));
+    return {
+      configured: true,
+      pid: parsed.pid,
+      csrfToken,
+      extensionPort: Number.isFinite(extensionPort) ? extensionPort : null,
+    };
+  }
+
+  if (sawProcess) {
+    return { configured: true, error: "Antigravity CSRF token not found. Restart Antigravity and retry." };
+  }
+  return { configured: false };
+}
+
+function resolveLsofBinary() {
+  for (const candidate of ["/usr/sbin/lsof", "/usr/bin/lsof"]) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function parseListeningPorts(output) {
+  const matches = String(output || "").matchAll(/:(\d+)\s+\(LISTEN\)/g);
+  const ports = new Set();
+  for (const match of matches) {
+    const port = Number(match[1]);
+    if (Number.isFinite(port)) {
+      ports.add(port);
+    }
+  }
+  return Array.from(ports).sort((a, b) => a - b);
+}
+
+function listAntigravityPorts(pid, { commandRunner } = {}) {
+  const lsof = resolveLsofBinary();
+  if (!lsof) {
+    throw new Error("Antigravity port detection needs lsof. Install it, then retry.");
+  }
+  const result = runCommand(
+    commandRunner,
+    lsof,
+    ["-nP", "-iTCP", "-sTCP:LISTEN", "-a", "-p", String(pid)],
+    { timeout: 4000 },
+  );
+  const ports = parseListeningPorts(result?.stdout);
+  if (!ports.length) {
+    throw new Error("Antigravity is running but not exposing ports yet. Try again in a few seconds.");
+  }
+  return ports;
+}
+
+function antigravityDefaultBody() {
+  return {
+    metadata: {
+      ideName: "antigravity",
+      extensionName: "antigravity",
+      ideVersion: "unknown",
+      locale: "en",
+    },
+  };
+}
+
+function antigravityUnleashBody() {
+  return {
+    context: {
+      properties: {
+        devMode: "false",
+        extensionVersion: "unknown",
+        hasAnthropicModelAccess: "true",
+        ide: "antigravity",
+        ideVersion: "unknown",
+        installationId: "tokentracker",
+        language: "UNSPECIFIED",
+        os: "macos",
+        requestedModelId: "MODEL_UNSPECIFIED",
+      },
+    },
+  };
+}
+
+function requestLocalJson({
+  scheme,
+  port,
+  path,
+  body,
+  csrfToken,
+  timeoutMs = 8000,
+  requestFn,
+}) {
+  if (typeof requestFn === "function") {
+    return requestFn({ scheme, port, path, body, csrfToken, timeoutMs });
+  }
+
+  const client = scheme === "https" ? https : http;
+  return new Promise((resolve, reject) => {
+    const rawBody = JSON.stringify(body);
+    const req = client.request(
+      {
+        hostname: "127.0.0.1",
+        port,
+        path,
+        method: "POST",
+        rejectUnauthorized: false,
+        timeout: timeoutMs,
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(rawBody),
+          "Connect-Protocol-Version": "1",
+          "X-Codeium-Csrf-Token": csrfToken,
+        },
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          if (res.statusCode !== 200) {
+            reject(new Error(`HTTP ${res.statusCode}: ${data}`));
+            return;
+          }
+          try {
+            resolve(JSON.parse(data));
+          } catch (error) {
+            reject(new Error(`Invalid JSON response: ${error.message}`));
+          }
+        });
+      },
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy(new Error("timeout"));
+    });
+    req.write(rawBody);
+    req.end();
+  });
+}
+
+function antigravityCodeIsOk(code) {
+  if (code === null || code === undefined) return true;
+  if (typeof code === "number") return code === 0;
+  if (typeof code === "string") {
+    const lower = code.toLowerCase();
+    return lower === "ok" || lower === "success" || lower === "0";
+  }
+  return false;
+}
+
+function parseAntigravityDate(value) {
+  if (typeof value === "string" && value) {
+    const iso = Date.parse(value);
+    if (Number.isFinite(iso)) return new Date(iso).toISOString();
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) {
+      return new Date(numeric * 1000).toISOString();
+    }
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return new Date(value * 1000).toISOString();
+  }
+  return null;
+}
+
+function parseAntigravityModelConfigs(configs) {
+  if (!Array.isArray(configs)) return [];
+  return configs
+    .map((config) => {
+      const quota = config?.quotaInfo || null;
+      if (!quota) return null;
+      return {
+        label: typeof config?.label === "string" ? config.label : "",
+        model_id: typeof config?.modelOrAlias?.model === "string" ? config.modelOrAlias.model : "",
+        remaining_fraction:
+          typeof quota?.remainingFraction === "number" && Number.isFinite(quota.remainingFraction)
+            ? quota.remainingFraction
+            : null,
+        reset_at: parseAntigravityDate(quota?.resetTime),
+      };
+    })
+    .filter(Boolean);
+}
+
+function antigravityFamily(model) {
+  const text = `${model?.label || ""} ${model?.model_id || ""}`.toLowerCase();
+  if (text.includes("claude")) return "claude";
+  if (text.includes("gemini") && text.includes("pro")) return "gemini_pro";
+  if (text.includes("gemini") && text.includes("flash")) return "gemini_flash";
+  return "unknown";
+}
+
+function antigravityPriority(model) {
+  const text = `${model?.label || ""} ${model?.model_id || ""}`.toLowerCase();
+  if (text.includes("lite") || text.includes("autocomplete") || text.includes("tab_")) return null;
+  if (antigravityFamily(model) === "gemini_pro") {
+    return text.includes("pro-low") || (text.includes("pro") && text.includes("low")) ? 0 : 1;
+  }
+  return 0;
+}
+
+function chooseAntigravityModel(models, family) {
+  const candidates = models
+    .filter((model) => antigravityFamily(model) === family)
+    .map((model) => ({
+      model,
+      priority: antigravityPriority(model),
+      remaining:
+        typeof model.remaining_fraction === "number"
+          ? model.remaining_fraction
+          : Number.POSITIVE_INFINITY,
+    }))
+    .filter((entry) => entry.priority !== null);
+
+  if (!candidates.length) return null;
+  candidates.sort((a, b) => {
+    if (a.priority !== b.priority) return a.priority - b.priority;
+    return a.remaining - b.remaining;
+  });
+  return candidates[0].model;
+}
+
+function makeAntigravityWindow(model) {
+  if (!model) return null;
+  const remaining = typeof model.remaining_fraction === "number" ? model.remaining_fraction * 100 : 0;
+  return buildWindow({
+    usedPercent: 100 - remaining,
+    resetAt: model.reset_at,
+  });
+}
+
+function normalizeAntigravityResponse(body, { fallbackToConfigs = false } = {}) {
+  if (!antigravityCodeIsOk(body?.code)) {
+    throw new Error(`Antigravity API error: ${body?.code}`);
+  }
+
+  const userStatus = body?.userStatus || null;
+  const configs = fallbackToConfigs
+    ? body?.clientModelConfigs
+    : userStatus?.cascadeModelConfigData?.clientModelConfigs;
+  const models = parseAntigravityModelConfigs(configs);
+  if (!models.length) {
+    throw new Error("Could not parse Antigravity quota: no quota models available.");
+  }
+
+  const primary = chooseAntigravityModel(models, "claude");
+  const secondary = chooseAntigravityModel(models, "gemini_pro");
+  const tertiary = chooseAntigravityModel(models, "gemini_flash");
+  const fallback = !primary && !secondary && !tertiary
+    ? [...models].sort((a, b) => {
+        const aRemaining = typeof a.remaining_fraction === "number" ? a.remaining_fraction : Number.POSITIVE_INFINITY;
+        const bRemaining = typeof b.remaining_fraction === "number" ? b.remaining_fraction : Number.POSITIVE_INFINITY;
+        return aRemaining - bRemaining;
+      })[0]
+    : null;
+
+  return {
+    account_email: typeof userStatus?.email === "string" ? userStatus.email : null,
+    account_plan:
+      userStatus?.planStatus?.planInfo?.planDisplayName
+      || userStatus?.planStatus?.planInfo?.displayName
+      || userStatus?.planStatus?.planInfo?.productName
+      || userStatus?.planStatus?.planInfo?.planName
+      || userStatus?.planStatus?.planInfo?.planShortName
+      || null,
+    primary_window: makeAntigravityWindow(primary || fallback),
+    secondary_window: makeAntigravityWindow(secondary),
+    tertiary_window: makeAntigravityWindow(tertiary),
+  };
+}
+
+async function probeAntigravityPort(port, csrfToken, { timeoutMs, requestFn } = {}) {
+  try {
+    await requestLocalJson({
+      scheme: "https",
+      port,
+      path: "/exa.language_server_pb.LanguageServerService/GetUnleashData",
+      body: antigravityUnleashBody(),
+      csrfToken,
+      timeoutMs,
+      requestFn,
+    });
+    return true;
+  } catch (_error) {
+    return false;
+  }
+}
+
+async function fetchAntigravityLimits({ commandRunner, requestFn, timeoutMs = 8000 } = {}) {
+  const processInfo = detectAntigravityProcess({ commandRunner });
+  if (!processInfo.configured) {
+    return { configured: false };
+  }
+  if (processInfo.error) {
+    return { configured: true, error: processInfo.error };
+  }
+
+  try {
+    const ports = listAntigravityPorts(processInfo.pid, { commandRunner });
+    let workingPort = null;
+    for (const port of ports) {
+      if (await probeAntigravityPort(port, processInfo.csrfToken, { timeoutMs, requestFn })) {
+        workingPort = port;
+        break;
+      }
+    }
+    if (!workingPort) {
+      throw new Error("Antigravity port detection failed: no working API port found");
+    }
+
+    try {
+      const userStatus = await requestLocalJson({
+        scheme: "https",
+        port: workingPort,
+        path: "/exa.language_server_pb.LanguageServerService/GetUserStatus",
+        body: antigravityDefaultBody(),
+        csrfToken: processInfo.csrfToken,
+        timeoutMs,
+        requestFn,
+      });
+      return {
+        configured: true,
+        error: null,
+        ...normalizeAntigravityResponse(userStatus),
+      };
+    } catch (primaryError) {
+      const fallbackPort =
+        Number.isFinite(processInfo.extensionPort) && processInfo.extensionPort > 0
+          ? processInfo.extensionPort
+          : workingPort;
+      const modelConfigs = await requestLocalJson({
+        scheme: fallbackPort === workingPort ? "https" : "http",
+        port: fallbackPort,
+        path: "/exa.language_server_pb.LanguageServerService/GetCommandModelConfigs",
+        body: antigravityDefaultBody(),
+        csrfToken: processInfo.csrfToken,
+        timeoutMs,
+        requestFn,
+      });
+      return {
+        configured: true,
+        error: null,
+        ...normalizeAntigravityResponse(modelConfigs, { fallbackToConfigs: true }),
+      };
+    }
+  } catch (error) {
+    const message = error?.message === "timeout"
+      ? "Antigravity quota request timed out."
+      : error?.message || "Unknown error";
+    return {
+      configured: true,
+      error: message,
+    };
+  }
+}
+
+async function getUsageLimits({
+  home,
+  env,
+  platform,
+  securityRunner,
+  fetchImpl = fetch,
+  commandRunner,
+  requestFn,
+  now = new Date(),
+} = {}) {
+  const nowMs = Date.now();
+  if (cache.data && nowMs - cache.fetchedAt < CACHE_TTL_MS) {
+    return cache.data;
+  }
+
+  const [claudeToken, codexToken] = await Promise.all([
+    Promise.resolve().then(() => readClaudeCodeAccessToken({ platform, securityRunner })),
+    readCodexAccessToken({ home, env }),
+  ]);
+
+  const [claudeResult, codexResult, cursor, gemini, kiro, antigravity] = await Promise.all([
+    claudeToken
+      ? fetchClaudeUsageLimits(claudeToken, { fetchImpl }).then(
+          (value) => ({ status: "fulfilled", value }),
+          (reason) => ({ status: "rejected", reason }),
+        )
+      : Promise.resolve(null),
+    codexToken
+      ? fetchCodexUsageLimits(codexToken, { fetchImpl }).then(
+          (value) => ({ status: "fulfilled", value }),
+          (reason) => ({ status: "rejected", reason }),
+        )
+      : Promise.resolve(null),
+    fetchCursorLimits({ home, fetchImpl }),
+    fetchGeminiLimits({ home, env, fetchImpl, commandRunner }),
+    Promise.resolve().then(() => fetchKiroLimits({ commandRunner, now })),
+    fetchAntigravityLimits({ commandRunner, requestFn }),
+  ]);
+
+  let claude;
+  if (!claudeToken) {
+    claude = { configured: false };
+  } else if (!claudeResult || claudeResult.status === "rejected") {
+    claude = { configured: true, error: claudeResult?.reason?.message || "Unknown error" };
+  } else {
+    claude = {
+      configured: true,
+      error: null,
+      five_hour: claudeResult.value.five_hour,
+      seven_day: claudeResult.value.seven_day,
+      seven_day_opus: claudeResult.value.seven_day_opus,
+      extra_usage: claudeResult.value.extra_usage,
+    };
+  }
+
+  let codex;
+  if (!codexToken) {
+    codex = { configured: false };
+  } else if (!codexResult || codexResult.status === "rejected") {
+    codex = { configured: true, error: codexResult?.reason?.message || "Unknown error" };
+  } else {
+    codex = {
+      configured: true,
+      error: null,
+      primary_window: codexResult.value.primary_window,
+      secondary_window: codexResult.value.secondary_window,
+    };
+  }
+
+  const data = {
+    fetched_at: new Date(nowMs).toISOString(),
+    claude,
+    codex,
+    cursor,
+    gemini,
+    kiro,
+    antigravity,
+  };
+
+  cache = { data, fetchedAt: nowMs };
+  return data;
+}
+
+function resetUsageLimitsCache() {
+  cache = { data: null, fetchedAt: 0 };
+}
+
+module.exports = {
+  getUsageLimits,
+  resetUsageLimitsCache,
+  normalizeCursorUsageSummary,
+  normalizeGeminiQuotaResponse,
+  parseKiroUsageOutput,
+  normalizeAntigravityResponse,
+  parseListeningPorts,
+  detectAntigravityProcess,
+};