when-does-my-quota-refresh 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,2329 @@
+#!/usr/bin/env node
+import {
+  OAuthClient,
+  SourceUnavailableError,
+  debug,
+  ensureDirs,
+  getActiveAccountTokens,
+  getAllAccountTokens,
+  getConfigDirPath,
+  getDataDirPath,
+  listAccounts,
+  loadConfig,
+  loginAccount,
+  removeAccount,
+  saveConfig,
+  setActiveAccount,
+  setVerbose
+} from "../chunk-YZVX5QIP.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join3, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// src/cli/commands/quota.ts
+import chalk3 from "chalk";
+import ora from "ora";
+
+// src/core/platform.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+function isWindows() {
+  return process.platform === "win32";
+}
+function isMacOS() {
+  return process.platform === "darwin";
+}
+function isLinux() {
+  return process.platform === "linux";
+}
+async function runCommand(cmd) {
+  try {
+    const { stdout } = await execAsync(cmd, { timeout: 1e4 });
+    return stdout;
+  } catch {
+    return "";
+  }
+}
+function formatCountdown(ms) {
+  if (ms <= 0) return "now";
+  const totalMinutes = Math.floor(ms / 6e4);
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  if (hours > 0) return `${hours}h ${minutes}m`;
+  return `${minutes}m`;
+}
+
+// src/sources/local/process-detector.ts
+var ANTIMATTER_MARKERS = [
+  "antigravity",
+  "language_server",
+  "language-server",
+  "antigravity-cli",
+  "antigravity_cli",
+  "agy"
+];
+var ANTIMATTER_PATH_MARKERS = [
+  "/antigravity/",
+  "Antigravity",
+  "antigravity.app",
+  "AntigravityStatusProbe",
+  "app_data_dir antigravity"
+];
+async function detectAntigravityProcesses() {
+  debug("process-detector", `Detecting on platform: ${process.platform}`);
+  let processes = [];
+  if (isMacOS()) {
+    processes = await detectOnMacOS();
+  } else if (isLinux()) {
+    processes = await detectOnLinux();
+  } else if (isWindows()) {
+    processes = await detectOnWindows();
+  }
+  debug("process-detector", `Found ${processes.length} process(es)`);
+  return processes;
+}
+async function detectOnMacOS() {
+  const output = await runCommand("ps -ax -o pid=,comm=,args=");
+  return parsePsOutput(output);
+}
+async function detectOnLinux() {
+  const output = await runCommand("ps -eo pid,comm,args --no-headers");
+  return parsePsOutput(output);
+}
+async function detectOnWindows() {
+  let output = await runCommand(
+    `wmic process where "name like '%language%' or commandline like '%antigravity%'" get ProcessId,Name,CommandLine /format:csv`
+  );
+  let processes = parseWmicOutput(output);
+  if (processes.length > 0) return processes;
+  output = await runCommand(
+    `powershell -Command "Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -match 'antigravity|language.server' } | Select-Object ProcessId,Name,CommandLine | Format-Table -AutoSize"`
+  );
+  processes = parsePowerShellOutput(output);
+  if (processes.length > 0) return processes;
+  debug("process-detector", "Windows: Falling back to port-based detection");
+  return [];
+}
+function parsePsOutput(output) {
+  const processes = [];
+  const lines = output.split("\n").filter(Boolean);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split(/\s+/);
+    const pid = parseInt(parts[0], 10);
+    if (isNaN(pid)) continue;
+    const rest = parts.slice(1).join(" ");
+    if (matchesAntigravity(rest)) {
+      processes.push({
+        pid,
+        name: parts[1] || "unknown",
+        commandLine: rest,
+        scope: classifyProcess(rest)
+      });
+    }
+  }
+  return processes;
+}
+function parseWmicOutput(output) {
+  const processes = [];
+  const lines = output.split("\n").filter(Boolean);
+  for (const line of lines) {
+    const parts = line.split(",").map((p) => p.trim().replace(/"/g, ""));
+    if (parts.length < 4) continue;
+    const pid = parseInt(parts[3], 10);
+    if (isNaN(pid)) continue;
+    const commandLine = parts[1] || "";
+    const name = parts[2] || "";
+    if (matchesAntigravity(commandLine) || matchesAntigravity(name)) {
+      processes.push({
+        pid,
+        name,
+        commandLine,
+        scope: classifyProcess(commandLine)
+      });
+    }
+  }
+  return processes;
+}
+function parsePowerShellOutput(output) {
+  const processes = [];
+  const lines = output.split("\n").filter(Boolean);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("---") || trimmed.startsWith("ProcessId")) continue;
+    const match = trimmed.match(/^\s*(\d+)\s+(\S+)\s+(.*)$/);
+    if (!match) continue;
+    const pid = parseInt(match[1], 10);
+    const name = match[2];
+    const commandLine = match[3];
+    if (matchesAntigravity(commandLine) || matchesAntigravity(name)) {
+      processes.push({
+        pid,
+        name,
+        commandLine,
+        scope: classifyProcess(commandLine)
+      });
+    }
+  }
+  return processes;
+}
+function matchesAntigravity(text) {
+  const lower = text.toLowerCase();
+  return ANTIMATTER_PATH_MARKERS.some(
+    (marker) => lower.includes(marker.toLowerCase())
+  ) || lower.includes("language") && lower.includes("server") && ANTIMATTER_MARKERS.some((m) => lower.includes(m));
+}
+function classifyProcess(commandLine) {
+  const lower = commandLine.toLowerCase();
+  if (lower.includes("antigravity-cli") || lower.includes("antigravity_cli") || lower.includes("agy")) {
+    return "cli";
+  }
+  if (lower.includes("antigravity ide") || lower.includes("antigravity-ide") || lower.includes("extensions/antigravity")) {
+    return "ide";
+  }
+  if (lower.includes("app_data_dir antigravity") || lower.includes("antigravity.app")) {
+    return "app";
+  }
+  return "unknown";
+}
+function extractFlags(commandLine) {
+  const flags = /* @__PURE__ */ new Map();
+  if (!commandLine) return flags;
+  const flagRegex = /--(\S+)\s+([^\s-][^\s]*)/g;
+  let match;
+  while ((match = flagRegex.exec(commandLine)) !== null) {
+    flags.set(match[1], match[2]);
+  }
+  return flags;
+}
+
+// src/sources/local/port-detective.ts
+async function discoverPorts(pid) {
+  debug("port-detective", `Discovering ports for PID ${pid} on ${process.platform}`);
+  if (isWindows()) {
+    return discoverPortsOnWindows(pid);
+  } else if (isMacOS()) {
+    return discoverPortsOnMacOS(pid);
+  } else {
+    return discoverPortsOnLinux(pid);
+  }
+}
+async function discoverPortsOnMacOS(pid) {
+  try {
+    const output = await runCommand(`lsof -nP -iTCP -sTCP:LISTEN -a -p ${pid}`);
+    const ports = [];
+    for (const line of output.split("\n")) {
+      const match = line.match(/:(\d+)\s+\(LISTEN\)/);
+      if (match) {
+        const port = parseInt(match[1], 10);
+        if (!isNaN(port) && !ports.includes(port)) {
+          ports.push(port);
+        }
+      }
+    }
+    debug("port-detective", `macOS ports: ${ports.join(", ")}`);
+    return ports;
+  } catch {
+    return [];
+  }
+}
+async function discoverPortsOnLinux(pid) {
+  try {
+    const output = await runCommand(`ss -tlnp | grep "pid=${pid},"`);
+    const ports = parseListenPorts(output);
+    if (ports.length > 0) {
+      debug("port-detective", `Linux ports (ss): ${ports.join(", ")}`);
+      return ports;
+    }
+  } catch {
+  }
+  try {
+    const output = await runCommand(`netstat -tlnp 2>/dev/null | grep "${pid}/"`);
+    const ports = parseListenPorts(output);
+    debug("port-detective", `Linux ports (netstat): ${ports.join(", ")}`);
+    return ports;
+  } catch {
+    return [];
+  }
+}
+async function discoverPortsOnWindows(pid) {
+  try {
+    const output = await runCommand("netstat -ano");
+    const ports = [];
+    for (const line of output.split("\n")) {
+      if (!line.includes("LISTENING")) continue;
+      const parts = line.trim().split(/\s+/);
+      const linePid = parseInt(parts[parts.length - 1], 10);
+      if (linePid === pid) {
+        const localAddr = parts[1];
+        const portMatch = localAddr.match(/:(\d+)$/);
+        if (portMatch) {
+          const port = parseInt(portMatch[1], 10);
+          if (!isNaN(port) && !ports.includes(port)) {
+            ports.push(port);
+          }
+        }
+      }
+    }
+    if (ports.length > 0) {
+      debug("port-detective", `Windows ports (netstat): ${ports.join(", ")}`);
+      return ports;
+    }
+  } catch {
+  }
+  try {
+    const output = await runCommand(
+      `powershell -Command "Get-NetTCPConnection -OwningProcess ${pid} -State Listen -ErrorAction SilentlyContinue | Select-Object LocalPort | Format-Table -AutoSize"`
+    );
+    const ports = [];
+    for (const line of output.split("\n")) {
+      const match = line.match(/^\s*(\d+)\s*$/);
+      if (match) {
+        const port = parseInt(match[1], 10);
+        if (!isNaN(port) && !ports.includes(port)) {
+          ports.push(port);
+        }
+      }
+    }
+    if (ports.length > 0) {
+      debug("port-detective", `Windows ports (PowerShell): ${ports.join(", ")}`);
+      return ports;
+    }
+  } catch {
+  }
+  debug("port-detective", "Windows: Could not find ports via system commands");
+  return [];
+}
+function parseListenPorts(output) {
+  const ports = [];
+  for (const line of output.split("\n")) {
+    const match = line.match(/:(\d+)\s/);
+    if (match) {
+      const port = parseInt(match[1], 10);
+      if (!isNaN(port) && !ports.includes(port)) {
+        ports.push(port);
+      }
+    }
+  }
+  return ports;
+}
+async function scanPortRange(startPort = 8e3, endPort = 9500) {
+  debug("port-detective", `Scanning port range ${startPort}-${endPort}`);
+  const foundPorts = [];
+  if (isWindows()) {
+    const output = await runCommand("netstat -ano");
+    for (const line of output.split("\n")) {
+      if (!line.includes("LISTENING")) continue;
+      const parts = line.trim().split(/\s+/);
+      const localAddr = parts[1];
+      const portMatch = localAddr.match(/:(\d+)$/);
+      if (portMatch) {
+        const port = parseInt(portMatch[1], 10);
+        if (port >= startPort && port <= endPort) {
+          foundPorts.push(port);
+        }
+      }
+    }
+  } else {
+    const cmd = isMacOS() ? `lsof -nP -iTCP -sTCP:LISTEN` : `ss -tlnp`;
+    const output = await runCommand(cmd);
+    for (const line of output.split("\n")) {
+      const match = line.match(/:(\d+)\s/);
+      if (match) {
+        const port = parseInt(match[1], 10);
+        if (port >= startPort && port <= endPort && !foundPorts.includes(port)) {
+          foundPorts.push(port);
+        }
+      }
+    }
+  }
+  debug("port-detective", `Found ${foundPorts.length} ports in range`);
+  return foundPorts;
+}
+
+// src/sources/local/connect-client.ts
+import https from "https";
+import http from "http";
+var ENDPOINTS = {
+  quotaSummary: "/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary",
+  userStatus: "/exa.language_server_pb.LanguageServerService/GetUserStatus",
+  modelConfigs: "/exa.language_server_pb.LanguageServerService/GetCommandModelConfigs",
+  unleash: "/exa.language_server_pb.LanguageServerService/GetUnleashData",
+  availableModels: "/exa.language_server_pb.LanguageServerService/GetAvailableModels"
+};
+var ConnectClient = class {
+  baseUrl;
+  csrfToken;
+  isHttps;
+  constructor(baseUrl, csrfToken) {
+    this.baseUrl = baseUrl;
+    this.csrfToken = csrfToken;
+    this.isHttps = baseUrl.startsWith("https://");
+    debug("connect-client", `Init: ${baseUrl}, hasToken: ${!!csrfToken}`);
+  }
+  /**
+   * Test if this server is reachable and speaks Connect protocol
+   */
+  async probe() {
+    try {
+      await this.request("POST", ENDPOINTS.unleash, {});
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Fetch quota summary (richest data: weekly + session buckets)
+   */
+  async fetchQuotaSummary() {
+    debug("connect-client", "Fetching RetrieveUserQuotaSummary");
+    try {
+      const response = await this.request("POST", ENDPOINTS.quotaSummary, {
+        metadata: {
+          ideName: "antigravity",
+          extensionName: "antigravity",
+          locale: "en"
+        }
+      });
+      if (response) {
+        return this.parseQuotaSummary(response);
+      }
+    } catch (err) {
+      debug("connect-client", `QuotaSummary failed: ${err}`);
+    }
+    return null;
+  }
+  /**
+   * Fetch user status (fallback for older servers)
+   */
+  async fetchUserStatus() {
+    debug("connect-client", "Fetching GetUserStatus");
+    try {
+      const response = await this.request("POST", ENDPOINTS.userStatus, {
+        metadata: {
+          ideName: "antigravity",
+          extensionName: "antigravity",
+          locale: "en"
+        }
+      });
+      if (response) {
+        return this.parseUserStatus(response);
+      }
+    } catch (err) {
+      debug("connect-client", `UserStatus failed: ${err}`);
+    }
+    return null;
+  }
+  /**
+   * Fetch model configs (last-resort fallback)
+   */
+  async fetchModelConfigs() {
+    debug("connect-client", "Fetching GetCascadeModelConfigData");
+    try {
+      return await this.request("POST", ENDPOINTS.modelConfigs, {
+        metadata: {
+          ideName: "antigravity",
+          extensionName: "antigravity",
+          locale: "en"
+        }
+      });
+    } catch (err) {
+      debug("connect-client", `ModelConfigs failed: ${err}`);
+      return null;
+    }
+  }
+  /**
+   * Make a Connect protocol HTTP(S) request
+   */
+  request(method, path, body) {
+    return new Promise((resolve, reject) => {
+      const url = new URL(path, this.baseUrl);
+      const headers = {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "Connect-Protocol-Version": "1"
+      };
+      if (this.csrfToken) {
+        headers["X-Codeium-Csrf-Token"] = this.csrfToken;
+      }
+      const options = {
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname,
+        method,
+        headers,
+        timeout: 5e3,
+        rejectUnauthorized: false
+      };
+      const protocol = this.isHttps ? https : http;
+      const req = protocol.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              resolve(JSON.parse(data));
+            } catch {
+              resolve(data);
+            }
+          } else if (res.statusCode === 404) {
+            reject(new Error(`404: ${path}`));
+          } else {
+            reject(new Error(`HTTP ${res.statusCode}: ${data.slice(0, 200)}`));
+          }
+        });
+      });
+      req.on("error", reject);
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Timeout"));
+      });
+      if (body) req.write(JSON.stringify(body));
+      req.end();
+    });
+  }
+  /**
+   * Parse RetrieveUserQuotaSummary response
+   */
+  parseQuotaSummary(response) {
+    const result = { groups: [], raw: response };
+    if (typeof response !== "object" || response === null) return result;
+    const data = response;
+    const userStatus = data.userStatus;
+    const groups = data.groups || userStatus?.groups;
+    if (Array.isArray(groups)) {
+      result.groups = groups.map((group) => {
+        const buckets = Array.isArray(group.buckets) ? group.buckets.map((b) => ({
+          bucketId: String(b.bucketId || ""),
+          displayName: String(b.displayName || ""),
+          description: String(b.description || ""),
+          remainingFraction: typeof b.remaining?.remainingFraction === "number" ? b.remaining.remainingFraction : typeof b.remainingFraction === "number" ? b.remainingFraction : 1,
+          resetTime: typeof b.resetTime === "string" ? b.resetTime : void 0
+        })) : [];
+        return {
+          displayName: String(group.displayName || ""),
+          buckets
+        };
+      });
+    }
+    debug("connect-client", `Parsed ${result.groups.length} groups from quota summary`);
+    return result;
+  }
+  /**
+   * Parse GetUserStatus response (legacy fallback)
+   */
+  parseUserStatus(response) {
+    const status = { raw: response };
+    if (typeof response !== "object" || response === null) return status;
+    const data = response;
+    const userStatus = data.userStatus || data;
+    if (typeof userStatus.email === "string") status.email = userStatus.email;
+    if (typeof userStatus.isAuthenticated === "boolean") status.isAuthenticated = userStatus.isAuthenticated;
+    if (typeof userStatus.planType === "string") status.planType = userStatus.planType;
+    const planStatus = userStatus.planStatus;
+    if (planStatus) {
+      const available = planStatus.availablePromptCredits;
+      const planInfo = planStatus.planInfo;
+      const monthly = planInfo?.monthlyPromptCredits;
+      if (typeof available === "number" && typeof monthly === "number") {
+        status.quota = {
+          promptCredits: {
+            used: monthly - available,
+            limit: monthly,
+            remaining: available
+          }
+        };
+      }
+    }
+    const cascadeData = userStatus.cascadeModelConfigData;
+    const clientModelConfigs = cascadeData?.clientModelConfigs;
+    if (Array.isArray(clientModelConfigs)) {
+      status.quota = status.quota || {};
+      status.quota.models = clientModelConfigs.map((m) => {
+        const modelOrAlias = m.modelOrAlias;
+        const modelId = typeof modelOrAlias?.model === "string" ? modelOrAlias.model : "unknown";
+        const quotaInfo = m.quotaInfo;
+        const remainingFraction = typeof quotaInfo?.remainingFraction === "number" ? quotaInfo.remainingFraction : void 0;
+        const resetTime = typeof quotaInfo?.resetTime === "string" ? quotaInfo.resetTime : void 0;
+        return {
+          modelId,
+          displayName: typeof m.label === "string" ? m.label : void 0,
+          label: typeof m.label === "string" ? m.label : void 0,
+          quota: {
+            remainingPercentage: remainingFraction,
+            resetTime,
+            timeUntilResetMs: resetTime ? new Date(resetTime).getTime() - Date.now() : void 0
+          },
+          isExhausted: remainingFraction === 0
+        };
+      });
+    }
+    return status;
+  }
+};
+
+// src/sources/local/parser.ts
+function parseQuotaSummary(summary, email) {
+  debug("parser", `Parsing quota summary: ${summary.groups.length} groups`);
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    method: "local",
+    email,
+    groups: summary.groups.map((g) => ({
+      displayName: g.displayName,
+      buckets: g.buckets.map((b) => ({
+        bucketId: b.bucketId,
+        displayName: b.displayName,
+        description: b.description,
+        remainingFraction: clampFraction(b.remainingFraction),
+        resetTime: b.resetTime,
+        timeUntilResetMs: b.resetTime ? Math.max(0, new Date(b.resetTime).getTime() - Date.now()) : void 0
+      }))
+    }))
+  };
+}
+function parseUserStatus(userStatus) {
+  debug("parser", "Parsing GetUserStatus fallback");
+  const snapshot = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    method: "local",
+    email: userStatus.email,
+    groups: []
+  };
+  if (userStatus.quota?.promptCredits) {
+    snapshot.promptCredits = parsePromptCredits(userStatus.quota.promptCredits);
+  }
+  if (userStatus.quota?.models) {
+    const geminiModels = [];
+    const claudeModels = [];
+    for (const model of userStatus.quota.models) {
+      const info = {
+        label: model.label || model.displayName || model.modelId,
+        modelId: model.modelId,
+        remainingPercentage: model.quota?.remainingPercentage,
+        isExhausted: model.isExhausted ?? model.quota?.remainingPercentage === 0,
+        resetTime: model.quota?.resetTime,
+        timeUntilResetMs: model.quota?.timeUntilResetMs,
+        isAutocompleteOnly: detectAutocomplete(model.modelId, model.label)
+      };
+      if (info.isAutocompleteOnly) continue;
+      if (isGeminiModel(model.modelId)) {
+        geminiModels.push(info);
+      } else {
+        claudeModels.push(info);
+      }
+    }
+    if (geminiModels.length > 0) {
+      snapshot.groups.push(createGroupFromModels("Gemini Models", geminiModels));
+    }
+    if (claudeModels.length > 0) {
+      snapshot.groups.push(createGroupFromModels("Claude + GPT Models", claudeModels));
+    }
+  }
+  return snapshot;
+}
+function parsePromptCredits(credits) {
+  if (!credits) return void 0;
+  const limit = credits.limit ?? 0;
+  const remaining = credits.remaining ?? limit;
+  const used = credits.used ?? limit - remaining;
+  if (limit === 0) return void 0;
+  return {
+    available: remaining,
+    monthly: limit,
+    usedPercentage: limit > 0 ? used / limit : 0,
+    remainingPercentage: limit > 0 ? remaining / limit : 1
+  };
+}
+function createGroupFromModels(displayName, models) {
+  const bestModel = models.reduce((best, m) => {
+    const remaining = m.remainingPercentage ?? 1;
+    const bestRemaining = best.remainingPercentage ?? 1;
+    return remaining < bestRemaining ? m : best;
+  }, models[0]);
+  const bucket = {
+    bucketId: "session",
+    displayName: "Session (5-hour)",
+    description: bestModel.resetTime ? `Resets at ${new Date(bestModel.resetTime).toLocaleTimeString()}` : "5-hour session window",
+    remainingFraction: bestModel.remainingPercentage ?? 1,
+    resetTime: bestModel.resetTime,
+    timeUntilResetMs: bestModel.timeUntilResetMs
+  };
+  return {
+    displayName,
+    buckets: [bucket]
+  };
+}
+function isGeminiModel(modelId) {
+  const lower = modelId.toLowerCase();
+  return lower.includes("gemini");
+}
+function detectAutocomplete(modelId, label) {
+  const text = `${modelId} ${label || ""}`.toLowerCase();
+  return text.includes("autocomplete") || text.includes("gemini-2.5") || text.includes("gemini 2.5");
+}
+function clampFraction(value) {
+  if (value === void 0 || value === null) return 1;
+  return Math.max(0, Math.min(1, value));
+}
+
+// src/sources/local/index.ts
+var LocalSource = class {
+  name = "local";
+  priority = 1;
+  async isAvailable() {
+    try {
+      const processes = await detectAntigravityProcesses();
+      return processes.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  async fetchQuota() {
+    debug("local", "Starting local fetch");
+    const processes = await detectAntigravityProcesses();
+    if (processes.length === 0) {
+      throw new SourceUnavailableError("local", "No Antigravity process found");
+    }
+    for (const proc of processes) {
+      debug("local", `Trying PID ${proc.pid} (${proc.scope})`);
+      const flags = extractFlags(proc.commandLine || "");
+      let ports = [];
+      const directPort = flags.get("extension_server_port");
+      if (directPort) {
+        const portNum = parseInt(directPort, 10);
+        if (!isNaN(portNum)) {
+          ports.push(portNum);
+          debug("local", `Found port from command line: ${portNum}`);
+        }
+      }
+      const discoveredPorts = await discoverPorts(proc.pid);
+      for (const p of discoveredPorts) {
+        if (!ports.includes(p)) ports.push(p);
+      }
+      const csrfToken = flags.get("csrf_token") || flags.get("extension_server_csrf_token");
+      for (const port of ports) {
+        const quota = await this.probePort(port, csrfToken);
+        if (quota) return quota;
+      }
+    }
+    debug("local", "Direct detection failed, scanning port range");
+    const scannedPorts = await scanPortRange(8e3, 9500);
+    for (const port of scannedPorts) {
+      const quota = await this.probePort(port);
+      if (quota) return quota;
+    }
+    throw new SourceUnavailableError("local", "Could not connect to any local server");
+  }
+  /**
+   * Probe a single port and try to fetch quota
+   */
+  async probePort(port, csrfToken) {
+    for (const scheme of ["https", "http"]) {
+      const baseUrl = `${scheme}://127.0.0.1:${port}`;
+      const client = new ConnectClient(baseUrl, csrfToken);
+      const reachable = await client.probe();
+      if (!reachable) continue;
+      debug("local", `Probing ${baseUrl}`);
+      const summary = await client.fetchQuotaSummary();
+      if (summary && summary.groups.length > 0) {
+        const email = (await client.fetchUserStatus())?.email;
+        debug("local", `Got quota summary from ${baseUrl}`);
+        return parseQuotaSummary(summary, email);
+      }
+      const userStatus = await client.fetchUserStatus();
+      if (userStatus) {
+        debug("local", `Got user status from ${baseUrl}`);
+        return parseUserStatus(userStatus);
+      }
+    }
+    return null;
+  }
+};
+
+// src/sources/cli/index.ts
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+var CliSource = class {
+  name = "cli";
+  priority = 2;
+  agyProcess = null;
+  async isAvailable() {
+    const path = await findAgyBinary();
+    return path !== null;
+  }
+  async fetchQuota() {
+    debug("cli", "Starting CLI source fetch");
+    const agyPath = await findAgyBinary();
+    if (!agyPath) {
+      throw new SourceUnavailableError("cli", "agy binary not found");
+    }
+    const existingQuota = await this.tryExistingAgy();
+    if (existingQuota) return existingQuota;
+    return await this.launchAndFetch(agyPath);
+  }
+  /**
+   * Check if there's already a running agy instance we can reuse
+   */
+  async tryExistingAgy() {
+    const cmd = isWindows() ? `wmic process where "commandline like '%agy%'" get ProcessId,CommandLine /format:csv` : "ps -ax -o pid=,args=";
+    const output = await runCommand(cmd);
+    const pids = output.split("\n").map((line) => {
+      const match = line.match(/^\s*(\d+)/);
+      return match ? parseInt(match[1], 10) : NaN;
+    }).filter((p) => !isNaN(p));
+    for (const pid of pids) {
+      const ports = await discoverPorts(pid);
+      for (const port of ports) {
+        const quota = await this.probePort(port);
+        if (quota) return quota;
+      }
+    }
+    return null;
+  }
+  /**
+   * Launch agy and wait for its server, then fetch quota
+   */
+  async launchAndFetch(agyPath) {
+    debug("cli", `Launching agy: ${agyPath}`);
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.agyProcess?.kill();
+        reject(new SourceUnavailableError("cli", "agy startup timed out"));
+      }, 15e3);
+      this.agyProcess = exec2(agyPath, { env: { ...process.env, NO_COLOR: "1" } });
+      const pollInterval = setInterval(async () => {
+        try {
+          if (!this.agyProcess?.pid) return;
+          const ports = await discoverPorts(this.agyProcess.pid);
+          for (const port of ports) {
+            const quota = await this.probePort(port);
+            if (quota) {
+              clearTimeout(timeout);
+              clearInterval(pollInterval);
+              this.agyProcess?.kill();
+              resolve(quota);
+              return;
+            }
+          }
+        } catch {
+        }
+      }, 1e3);
+      this.agyProcess.on("error", (err) => {
+        clearTimeout(timeout);
+        clearInterval(pollInterval);
+        reject(new SourceUnavailableError("cli", `agy failed: ${err.message}`));
+      });
+      this.agyProcess.on("exit", () => {
+        clearTimeout(timeout);
+        clearInterval(pollInterval);
+      });
+    });
+  }
+  /**
+   * Probe a port for quota data
+   */
+  async probePort(port) {
+    for (const scheme of ["https", "http"]) {
+      const baseUrl = `${scheme}://127.0.0.1:${port}`;
+      const client = new ConnectClient(baseUrl);
+      try {
+        const reachable = await client.probe();
+        if (!reachable) continue;
+        const summary = await client.fetchQuotaSummary();
+        if (summary && summary.groups.length > 0) {
+          const email = (await client.fetchUserStatus())?.email;
+          return parseQuotaSummary(summary, email);
+        }
+        const userStatus = await client.fetchUserStatus();
+        if (userStatus) return parseUserStatus(userStatus);
+      } catch {
+      }
+    }
+    return null;
+  }
+  destroy() {
+    this.agyProcess?.kill();
+    this.agyProcess = null;
+  }
+};
+async function findAgyBinary() {
+  if (process.env.ANTIGRAVITY_CLI_PATH) {
+    return process.env.ANTIGRAVITY_CLI_PATH;
+  }
+  try {
+    const cmd = isWindows() ? "where agy" : "which agy";
+    const output = await execAsync2(cmd);
+    const path = output.stdout.trim();
+    if (path) return path;
+  } catch {
+  }
+  const commonPaths = isWindows() ? [
+    `${process.env.LOCALAPPDATA || ""}/antigravity-cli/agy.exe`,
+    `${process.env.PROGRAMFILES || ""}/antigravity-cli/agy.exe`
+  ] : [
+    `${process.env.HOME}/.local/bin/agy`,
+    "/opt/homebrew/bin/agy",
+    "/usr/local/bin/agy"
+  ];
+  for (const p of commonPaths) {
+    if (!p) continue;
+    try {
+      await execAsync2(`test -x "${p}"`);
+      return p;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/sources/oauth/index.ts
+var OAuthSource = class {
+  name = "oauth";
+  priority = 3;
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async isAvailable() {
+    try {
+      await this.client.getAccessToken();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async fetchQuota() {
+    debug("oauth", "Fetching quota via Cloud Code API");
+    try {
+      const summaryRaw = await this.client.fetchQuotaSummary();
+      const summary = this.parseRemoteSummary(summaryRaw);
+      if (summary && summary.groups.length > 0) {
+        const statusRaw2 = await this.client.fetchUserStatus();
+        const email = this.extractEmail(statusRaw2);
+        debug("oauth", "Got quota summary via OAuth");
+        return parseQuotaSummary(summary, email);
+      }
+      const statusRaw = await this.client.fetchUserStatus();
+      const status = this.parseRemoteStatus(statusRaw);
+      if (status) {
+        debug("oauth", "Got user status via OAuth");
+        return parseUserStatus(status);
+      }
+    } catch (err) {
+      debug("oauth", `Fetch failed: ${err}`);
+    }
+    throw new SourceUnavailableError("oauth", "Could not fetch quota via Cloud Code API");
+  }
+  /**
+   * Parse remote summary response into QuotaSummaryResponse format
+   */
+  parseRemoteSummary(raw) {
+    if (typeof raw !== "object" || raw === null) return null;
+    const data = raw;
+    const groups = data.groups;
+    if (!Array.isArray(groups)) return null;
+    return {
+      groups: groups.map((g) => ({
+        displayName: String(g.displayName || ""),
+        buckets: Array.isArray(g.buckets) ? g.buckets.map((b) => ({
+          bucketId: String(b.bucketId || ""),
+          displayName: String(b.displayName || ""),
+          description: String(b.description || ""),
+          remainingFraction: typeof b.remaining?.remainingFraction === "number" ? b.remaining.remainingFraction : typeof b.remainingFraction === "number" ? b.remainingFraction : 1,
+          resetTime: typeof b.resetTime === "string" ? b.resetTime : void 0
+        })) : []
+      })),
+      raw
+    };
+  }
+  /**
+   * Parse remote user status response
+   */
+  parseRemoteStatus(raw) {
+    if (typeof raw !== "object" || raw === null) return null;
+    return { raw };
+  }
+  extractEmail(raw) {
+    if (typeof raw !== "object" || raw === null) return void 0;
+    const data = raw;
+    const userStatus = data.userStatus;
+    return userStatus?.email || data.email;
+  }
+};
+
+// src/sources/index.ts
+var SourceRegistry = class {
+  sources = [];
+  health = /* @__PURE__ */ new Map();
+  constructor() {
+    this.sources.push(new LocalSource());
+    this.sources.push(new CliSource());
+  }
+  /**
+   * Register an additional data source (e.g., OAuth)
+   */
+  addSource(source) {
+    const idx = this.sources.findIndex((s) => s.priority > source.priority);
+    if (idx === -1) {
+      this.sources.push(source);
+    } else {
+      this.sources.splice(idx, 0, source);
+    }
+    debug("registry", `Registered source: ${source.name} (priority ${source.priority})`);
+  }
+  /**
+   * Remove a source by name
+   */
+  removeSource(name) {
+    this.sources = this.sources.filter((s) => s.name !== name);
+  }
+  /**
+   * Fetch quota using the best available source
+   *
+   * @param preferredSource Force a specific source
+   */
+  async fetchQuota(preferredSource) {
+    if (preferredSource) {
+      const source = this.sources.find((s) => s.name === preferredSource);
+      if (!source) throw new Error(`Source "${preferredSource}" not registered`);
+      const snapshot = await source.fetchQuota();
+      this.health.set(preferredSource, { available: true, lastCheck: Date.now() });
+      return snapshot;
+    }
+    const errors = [];
+    for (const source of this.sources) {
+      debug("registry", `Trying source: ${source.name}`);
+      try {
+        const available = await source.isAvailable();
+        if (!available) {
+          debug("registry", `Source ${source.name} not available`);
+          this.health.set(source.name, { available: false, lastCheck: Date.now() });
+          continue;
+        }
+        const snapshot = await source.fetchQuota();
+        this.health.set(source.name, { available: true, lastCheck: Date.now() });
+        debug("registry", `Success with source: ${source.name}`);
+        return snapshot;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        errors.push(`${source.name}: ${msg}`);
+        this.health.set(source.name, { available: false, lastCheck: Date.now() });
+        debug("registry", `Source ${source.name} failed: ${msg}`);
+      }
+    }
+    throw new SourceUnavailableError("all", `No sources available:
+${errors.map((e) => `  \u2022 ${e}`).join("\n")}`);
+  }
+  /**
+   * Get health status of all sources
+   */
+  getHealth() {
+    return new Map(this.health);
+  }
+  /**
+   * Get registered source names
+   */
+  getSourceNames() {
+    return this.sources.map((s) => s.name);
+  }
+};
+
+// src/sdk/cache.ts
+var QuotaCache = class {
+  cache = /* @__PURE__ */ new Map();
+  ttlMs;
+  constructor(ttlMs = 5 * 60 * 1e3) {
+    this.ttlMs = ttlMs;
+  }
+  /**
+   * Get cached quota if available and not expired
+   */
+  get(email, source) {
+    const key = `${email}:${source}`;
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    const age = Date.now() - entry.cachedAt;
+    if (age > this.ttlMs) {
+      this.cache.delete(key);
+      debug("cache", `Expired entry for ${email} (age: ${Math.round(age / 1e3)}s)`);
+      return null;
+    }
+    debug("cache", `Cache hit for ${email} (age: ${Math.round(age / 1e3)}s)`);
+    return entry.snapshot;
+  }
+  /**
+   * Store a quota snapshot in cache
+   */
+  set(email, source, snapshot) {
+    const key = `${email}:${source}`;
+    this.cache.set(key, {
+      snapshot,
+      cachedAt: Date.now()
+    });
+    debug("cache", `Cached snapshot for ${email}`);
+  }
+  /**
+   * Check if a cached entry is still fresh
+   */
+  isFresh(email, source) {
+    const key = `${email}:${source}`;
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    return Date.now() - entry.cachedAt <= this.ttlMs;
+  }
+  /**
+   * Clear all cached entries
+   */
+  clear() {
+    this.cache.clear();
+    debug("cache", "Cleared all cache entries");
+  }
+  /**
+   * Get cache age in seconds for a key
+   */
+  getAgeMs(email, source) {
+    const key = `${email}:${source}`;
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    return Date.now() - entry.cachedAt;
+  }
+};
+
+// src/sdk/store.ts
+import Database from "better-sqlite3";
+import { join } from "path";
+var db = null;
+function getDb() {
+  if (db) return db;
+  ensureDirs();
+  const dbPath = join(getDataDirPath(), "history.db");
+  db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  initSchema(db);
+  debug("store", `Opened database at ${dbPath}`);
+  return db;
+}
+function initSchema(database) {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS quota_snapshots (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp TEXT NOT NULL,
+      email TEXT NOT NULL,
+      method TEXT NOT NULL,
+      gemini_weekly_remaining REAL,
+      gemini_session_remaining REAL,
+      claude_weekly_remaining REAL,
+      claude_session_remaining REAL,
+      raw_json TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_snapshots_email_ts
+      ON quota_snapshots(email, timestamp);
+  `);
+}
+function storeSnapshot(snapshot) {
+  const database = getDb();
+  let geminiWeekly = null;
+  let geminiSession = null;
+  let claudeWeekly = null;
+  let claudeSession = null;
+  for (const group of snapshot.groups) {
+    const lower = group.displayName.toLowerCase();
+    for (const bucket of group.buckets) {
+      const bucketLower = bucket.displayName.toLowerCase();
+      if (lower.includes("gemini")) {
+        if (bucketLower.includes("weekly") || bucketLower.includes("week")) {
+          geminiWeekly = bucket.remainingFraction;
+        } else {
+          geminiSession = bucket.remainingFraction;
+        }
+      } else if (lower.includes("claude") || lower.includes("gpt")) {
+        if (bucketLower.includes("weekly") || bucketLower.includes("week")) {
+          claudeWeekly = bucket.remainingFraction;
+        } else {
+          claudeSession = bucket.remainingFraction;
+        }
+      }
+    }
+  }
+  const stmt = database.prepare(`
+    INSERT INTO quota_snapshots
+      (timestamp, email, method, gemini_weekly_remaining, gemini_session_remaining,
+       claude_weekly_remaining, claude_session_remaining, raw_json)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  stmt.run(
+    snapshot.timestamp,
+    snapshot.email || "unknown",
+    snapshot.method,
+    geminiWeekly,
+    geminiSession,
+    claudeWeekly,
+    claudeSession,
+    JSON.stringify(snapshot)
+  );
+  debug("store", `Stored snapshot for ${snapshot.email}`);
+}
+function getHistory(email, options) {
+  const database = getDb();
+  const days = options?.days || 7;
+  const limit = options?.limit || 1e3;
+  const since = new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString();
+  const stmt = database.prepare(`
+    SELECT timestamp, email, gemini_weekly_remaining, gemini_session_remaining,
+           claude_weekly_remaining, claude_session_remaining
+    FROM quota_snapshots
+    WHERE email = ? AND timestamp >= ?
+    ORDER BY timestamp DESC
+    LIMIT ?
+  `);
+  const rows = stmt.all(email, since, limit);
+  return rows.map((row) => ({
+    timestamp: String(row.timestamp),
+    email: String(row.email),
+    geminiWeeklyRemaining: row.gemini_weekly_remaining,
+    geminiSessionRemaining: row.gemini_session_remaining,
+    claudeWeeklyRemaining: row.claude_weekly_remaining,
+    claudeSessionRemaining: row.claude_session_remaining
+  }));
+}
+function getDailySummary(email, days = 7) {
+  const database = getDb();
+  const since = new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString();
+  const stmt = database.prepare(`
+    SELECT
+      date(timestamp) as date,
+      AVG(gemini_weekly_remaining) as gemini_weekly_avg,
+      AVG(gemini_session_remaining) as gemini_session_avg,
+      AVG(claude_weekly_remaining) as claude_weekly_avg,
+      AVG(claude_session_remaining) as claude_session_avg,
+      COUNT(*) as count
+    FROM quota_snapshots
+    WHERE email = ? AND timestamp >= ?
+    GROUP BY date(timestamp)
+    ORDER BY date(timestamp) ASC
+  `);
+  const rows = stmt.all(email, since);
+  return rows.map((row) => ({
+    date: String(row.date),
+    geminiWeeklyAvg: row.gemini_weekly_avg,
+    geminiSessionAvg: row.gemini_session_avg,
+    claudeWeeklyAvg: row.claude_weekly_avg,
+    claudeSessionAvg: row.claude_session_avg,
+    count: Number(row.count)
+  }));
+}
+function closeStore() {
+  if (db) {
+    db.close();
+    db = null;
+    debug("store", "Database closed");
+  }
+}
+
+// src/sdk/quota.ts
+var QuotaClient = class {
+  registry;
+  cache;
+  verbose;
+  constructor(options) {
+    this.verbose = options?.verbose || false;
+    setVerbose(this.verbose);
+    const config = loadConfig();
+    this.registry = new SourceRegistry();
+    this.cache = new QuotaCache(options?.cacheTtlMs || config.cacheTtlMs);
+    this.registerOAuthSources();
+  }
+  /**
+   * Fetch quota for the active account (or all accounts)
+   */
+  async fetchQuota(options) {
+    if (options?.allAccounts) {
+      return this.fetchAllAccounts(options);
+    }
+    if (!options?.refresh) {
+    }
+    const snapshot = await this.registry.fetchQuota(options?.source);
+    if (snapshot.email) {
+      this.cache.set(snapshot.email, snapshot.method, snapshot);
+      storeSnapshot(snapshot);
+    }
+    return snapshot;
+  }
+  /**
+   * Fetch quota for all stored accounts
+   */
+  async fetchAllAccounts(options) {
+    const tokens = getAllAccountTokens();
+    const snapshots = [];
+    try {
+      const snapshot = await this.registry.fetchQuota(options?.source);
+      snapshots.push(snapshot);
+    } catch (err) {
+      debug("quota", `Active account fetch failed: ${err}`);
+    }
+    for (const token of tokens) {
+      if (!token.email) continue;
+      if (snapshots.some((s) => s.email === token.email)) continue;
+      try {
+        const client = new OAuthClient(token);
+        const source = new OAuthSource(client);
+        const snapshot = await source.fetchQuota();
+        snapshots.push(snapshot);
+      } catch (err) {
+        debug("quota", `Failed to fetch for ${token.email}: ${err}`);
+      }
+    }
+    return snapshots;
+  }
+  /**
+   * Get the full dashboard data for all accounts
+   */
+  async getFullDashboard() {
+    const snapshots = await this.fetchAllAccounts();
+    const history = {};
+    const dailySummary = {};
+    for (const snapshot of snapshots) {
+      if (!snapshot.email) continue;
+      history[snapshot.email] = getHistory(snapshot.email, { days: 1, limit: 50 });
+      dailySummary[snapshot.email] = getDailySummary(snapshot.email, 7);
+    }
+    return { snapshots, history, dailySummary };
+  }
+  /**
+   * Get usage history for an account
+   */
+  getHistory(email, days) {
+    return getHistory(email, { days });
+  }
+  /**
+   * Get daily summary for an account
+   */
+  getDailySummary(email, days) {
+    return getDailySummary(email, days);
+  }
+  /**
+   * Register OAuth sources for all stored accounts
+   */
+  registerOAuthSources() {
+    const tokens = getAllAccountTokens();
+    for (const token of tokens) {
+      if (!token.accessToken) continue;
+      try {
+        const client = new OAuthClient(token);
+        const source = new OAuthSource(client);
+        this.registry.addSource(source);
+        debug("quota", `Registered OAuth source for ${token.email}`);
+      } catch (err) {
+        debug("quota", `Failed to register OAuth for ${token.email}: ${err}`);
+      }
+    }
+  }
+  /**
+   * Get the source registry (for doctor/status checks)
+   */
+  getRegistry() {
+    return this.registry;
+  }
+};
+
+// src/cli/render/quota-table.ts
+import chalk from "chalk";
+var BAR_WIDTH = 30;
+function renderQuotaCompact(snapshot) {
+  const lines = [];
+  const email = snapshot.email || "unknown";
+  const method = snapshot.method === "local" ? "\u{1F7E2}" : snapshot.method === "oauth" ? "\u{1F535}" : "\u{1F7E1}";
+  lines.push(`${method} ${chalk.bold(email)}`);
+  lines.push("");
+  if (snapshot.groups.length === 0) {
+    lines.push(chalk.dim("  No quota data available"));
+    return lines.join("\n");
+  }
+  for (const group of snapshot.groups) {
+    lines.push(chalk.bold(`  ${group.displayName}`));
+    for (const bucket of group.buckets) {
+      lines.push(renderBucketLine(bucket));
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+function renderBucketLine(bucket) {
+  const pct = Math.round(bucket.remainingFraction * 100);
+  const bar = renderProgressBar(bucket.remainingFraction);
+  const resetText = bucket.timeUntilResetMs ? chalk.dim(`resets ${formatCountdown(bucket.timeUntilResetMs)}`) : "";
+  return `    ${bar} ${colorPct(pct)}  ${resetText}`;
+}
+function renderProgressBar(fraction, width = BAR_WIDTH) {
+  const filled = Math.round(fraction * width);
+  const empty = width - filled;
+  const barChar = "\u2588";
+  const emptyChar = "\u2591";
+  const color = getQuotaColor(fraction);
+  const filledStr = color(Array(filled).fill(barChar).join(""));
+  const emptyStr = chalk.dim(Array(empty).fill(emptyChar).join(""));
+  return `[${filledStr}${emptyStr}]`;
+}
+function colorPct(pct) {
+  if (pct >= 70) return chalk.green(`${pct}%`);
+  if (pct >= 30) return chalk.yellow(`${pct}%`);
+  return chalk.red.bold(`${pct}%`);
+}
+function getQuotaColor(fraction) {
+  if (fraction >= 0.7) return chalk.green;
+  if (fraction >= 0.3) return chalk.yellow;
+  return chalk.red;
+}
+
+// src/cli/render/compare-table.ts
+import Table from "cli-table3";
+import chalk2 from "chalk";
+function renderComparisonTable(snapshots) {
+  if (snapshots.length === 0) {
+    return chalk2.dim("  No accounts to compare");
+  }
+  const table = new Table({
+    head: ["Account", "Gemini 5h", "Gemini Week", "Claude 5h", "Claude Week"],
+    style: { head: ["cyan", "cyan", "cyan", "cyan", "cyan"] },
+    colWidths: [25, 16, 16, 16, 16]
+  });
+  for (const snapshot of snapshots) {
+    const email = snapshot.email || "unknown";
+    const vals = extractValues(snapshot);
+    table.push([
+      chalk2.bold(email),
+      formatCell(vals.geminiSession, vals.geminiSessionReset),
+      formatCell(vals.geminiWeekly, vals.geminiWeeklyReset),
+      formatCell(vals.claudeSession, vals.claudeSessionReset),
+      formatCell(vals.claudeWeekly, vals.claudeWeeklyReset)
+    ]);
+  }
+  return table.toString();
+}
+function extractValues(snapshot) {
+  let geminiSession = null;
+  let geminiSessionReset;
+  let geminiWeekly = null;
+  let geminiWeeklyReset;
+  let claudeSession = null;
+  let claudeSessionReset;
+  let claudeWeekly = null;
+  let claudeWeeklyReset;
+  for (const group of snapshot.groups) {
+    const lower = group.displayName.toLowerCase();
+    for (const bucket of group.buckets) {
+      const bLower = bucket.displayName.toLowerCase();
+      const isWeekly = bLower.includes("weekly") || bLower.includes("week");
+      if (lower.includes("gemini")) {
+        if (isWeekly) {
+          geminiWeekly = bucket.remainingFraction;
+          geminiWeeklyReset = bucket.timeUntilResetMs;
+        } else {
+          geminiSession = bucket.remainingFraction;
+          geminiSessionReset = bucket.timeUntilResetMs;
+        }
+      } else if (lower.includes("claude") || lower.includes("gpt")) {
+        if (isWeekly) {
+          claudeWeekly = bucket.remainingFraction;
+          claudeWeeklyReset = bucket.timeUntilResetMs;
+        } else {
+          claudeSession = bucket.remainingFraction;
+          claudeSessionReset = bucket.timeUntilResetMs;
+        }
+      }
+    }
+  }
+  return {
+    geminiSession,
+    geminiSessionReset,
+    geminiWeekly,
+    geminiWeeklyReset,
+    claudeSession,
+    claudeSessionReset,
+    claudeWeekly,
+    claudeWeeklyReset
+  };
+}
+function formatCell(fraction, resetMs) {
+  if (fraction === null) return chalk2.dim("\u2014");
+  const pct = Math.round(fraction * 100);
+  const reset = resetMs ? chalk2.dim(` ${formatCountdown(resetMs)}`) : "";
+  if (pct >= 70) return chalk2.green(`${pct}%`) + reset;
+  if (pct >= 30) return chalk2.yellow(`${pct}%`) + reset;
+  return chalk2.red.bold(`${pct}%`) + reset;
+}
+
+// src/cli/commands/quota.ts
+function registerQuotaCommand(program2) {
+  program2.command("quota").description("Display current quota (default command)").option("-a, --all", "Fetch all accounts side-by-side").option("-r, --refresh", "Force fresh fetch (bypass cache)").option("-m, --method <method>", "Force data source: local, cli, oauth").option("--json", "Output JSON").action(async (opts) => {
+    const spinner = ora("Fetching quota...").start();
+    try {
+      const client = new QuotaClient({ verbose: opts.verbose });
+      if (opts.all) {
+        const snapshots = await client.fetchQuota({ allAccounts: true, source: opts.method, refresh: opts.refresh });
+        spinner.stop();
+        if (opts.json) {
+          console.log(JSON.stringify(snapshots, null, 2));
+        } else {
+          console.log(renderComparisonTable(Array.isArray(snapshots) ? snapshots : [snapshots]));
+        }
+      } else {
+        const snapshot = await client.fetchQuota({ source: opts.method, refresh: opts.refresh });
+        spinner.stop();
+        if (opts.json) {
+          console.log(JSON.stringify(snapshot, null, 2));
+        } else {
+          console.log(renderQuotaCompact(snapshot));
+        }
+      }
+    } catch (err) {
+      spinner.fail(chalk3.red(`Failed to fetch quota: ${err.message}`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/full.ts
+import chalk5 from "chalk";
+import ora2 from "ora";
+
+// src/cli/render/full-dashboard.ts
+import chalk4 from "chalk";
+import boxen from "boxen";
+var SPARKLINE_WIDTH = 24;
+function renderFullDashboard(snapshots, history) {
+  const now = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+  const parts = [];
+  parts.push(chalk4.bold.cyan(`  when-does-my-quota-refresh \u2014 Full Dashboard`) + chalk4.dim(`  ${now}`));
+  parts.push("");
+  if (snapshots.length === 0) {
+    parts.push(chalk4.dim("  No accounts configured. Run `aq accounts add` to get started."));
+    return boxen(parts.join("\n"), {
+      padding: 1,
+      margin: 0,
+      borderStyle: "round",
+      title: "aq",
+      titleAlignment: "center"
+    });
+  }
+  for (let i = 0; i < snapshots.length; i++) {
+    const snapshot = snapshots[i];
+    parts.push(renderAccountSection(snapshot, history[snapshot.email || ""]));
+    if (i < snapshots.length - 1) {
+      parts.push(chalk4.dim("  \u2500".repeat(24)));
+    }
+  }
+  parts.push("");
+  parts.push(chalk4.dim(`  Source: ${snapshots[0]?.method || "unknown"}`));
+  return boxen(parts.join("\n"), {
+    padding: { top: 1, bottom: 1, left: 2, right: 2 },
+    margin: 0,
+    borderStyle: "round",
+    title: "aq",
+    titleAlignment: "center"
+  });
+}
+function renderAccountSection(snapshot, accountHistory) {
+  const lines = [];
+  const email = snapshot.email || "unknown";
+  const method = snapshot.method === "local" ? chalk4.green("\u25CF") : snapshot.method === "oauth" ? chalk4.blue("\u25CF") : chalk4.yellow("\u25CF");
+  lines.push(`${method} ${chalk4.bold(email)}`);
+  if (snapshot.groups.length === 0) {
+    lines.push(chalk4.dim("    No quota data available"));
+    return lines.join("\n");
+  }
+  for (const group of snapshot.groups) {
+    lines.push("");
+    lines.push(chalk4.underline(`  ${group.displayName}`));
+    for (const bucket of group.buckets) {
+      const pct = Math.round(bucket.remainingFraction * 100);
+      const bar = renderProgressBar(bucket.remainingFraction, 28);
+      const resetText = bucket.timeUntilResetMs ? chalk4.dim(`resets ${formatCountdown(bucket.timeUntilResetMs)}`) : "";
+      const colorFn = getQuotaColor(bucket.remainingFraction);
+      const label = bucket.displayName.length > 12 ? bucket.displayName.slice(0, 12) : bucket.displayName.padEnd(12);
+      lines.push(`    ${chalk4.dim(label)} ${bar} ${colorFn(pct.toString().padStart(3))}%  ${resetText}`);
+    }
+  }
+  if (accountHistory && accountHistory.length > 0) {
+    lines.push("");
+    lines.push(`    ${chalk4.dim("\u{1F4C8} Recent")} ${renderSparkline(accountHistory)}`);
+  }
+  return lines.join("\n");
+}
+function renderSparkline(records) {
+  const values = records.slice(-SPARKLINE_WIDTH).map((r) => {
+    const vals = [r.geminiSessionRemaining, r.claudeSessionRemaining].filter((v) => v !== null);
+    return vals.length > 0 ? Math.max(...vals) : 0;
+  });
+  if (values.length === 0) return chalk4.dim("no data");
+  const blocks = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+  return values.map((v) => {
+    const idx = Math.min(Math.round(v * (blocks.length - 1)), blocks.length - 1);
+    const colorFn = getQuotaColor(v);
+    return colorFn(blocks[idx]);
+  }).join("");
+}
+function renderFullDashboardJson(snapshots, history) {
+  return JSON.stringify({
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    accounts: snapshots.map((s) => ({
+      email: s.email,
+      method: s.method,
+      groups: s.groups,
+      promptCredits: s.promptCredits,
+      recentHistory: history[s.email || ""]?.slice(0, 10) || []
+    }))
+  }, null, 2);
+}
+
+// src/cli/commands/full.ts
+async function executeFullDashboard(opts) {
+  const spinner = ora2("Loading full dashboard...").start();
+  try {
+    const client = new QuotaClient({ verbose: opts.verbose });
+    if (opts.watch) {
+      spinner.stop();
+      await runWatchMode(client, opts);
+      return;
+    }
+    const { snapshots, history } = await client.getFullDashboard();
+    spinner.stop();
+    if (opts.json) {
+      console.log(renderFullDashboardJson(snapshots, opts.noHistory ? {} : history));
+    } else {
+      console.log(renderFullDashboard(snapshots, opts.noHistory ? {} : history));
+    }
+  } catch (err) {
+    spinner.fail(chalk5.red(`Failed: ${err.message}`));
+    process.exit(1);
+  }
+}
+async function runWatchMode(client, opts) {
+  const REFRESH_MS = 3e4;
+  const refresh = async () => {
+    try {
+      const { snapshots, history } = await client.getFullDashboard();
+      process.stdout.write("\x1B[2J\x1B[0f");
+      if (opts.json) {
+        console.log(renderFullDashboardJson(snapshots, opts.noHistory ? {} : history));
+      } else {
+        console.log(renderFullDashboard(snapshots, opts.noHistory ? {} : history));
+      }
+      console.log(chalk5.dim(`
+  Auto-refreshing every ${REFRESH_MS / 1e3}s \u2014 Press Ctrl+C to exit`));
+    } catch (err) {
+      console.error(chalk5.red(`Refresh error: ${err.message}`));
+    }
+  };
+  await refresh();
+  setInterval(refresh, REFRESH_MS);
+  await new Promise(() => {
+  });
+}
+
+// src/cli/commands/accounts.ts
+import inquirer from "inquirer";
+import chalk6 from "chalk";
+import Table2 from "cli-table3";
+function registerAccountsCommand(program2) {
+  const accounts = program2.command("accounts").description("Manage Google accounts");
+  accounts.command("list").description("List all managed accounts").action(() => {
+    const accounts2 = listAccounts();
+    if (accounts2.length === 0) {
+      console.log(chalk6.dim("  No accounts configured. Run `aq accounts add` to get started."));
+      return;
+    }
+    const table = new Table2({
+      head: ["Email", "Status", "Added"],
+      style: { head: ["cyan"] }
+    });
+    for (const acct of accounts2) {
+      table.push([
+        acct.email,
+        acct.isActive ? chalk6.green("\u25CF Active") : chalk6.dim("\u25CB Inactive"),
+        new Date(acct.addedAt).toLocaleDateString()
+      ]);
+    }
+    console.log(table.toString());
+  });
+  accounts.command("add").description("Login a new Google account").option("--manual", "Manual login for headless/SSH (get URL instead of browser)").action(async (opts) => {
+    try {
+      if (opts.manual) {
+        const { getManualLoginUrl: getManualLoginUrl2, completeManualLogin: completeManualLogin2 } = await import("../auth-S43EEJYA.js");
+        const url = getManualLoginUrl2();
+        console.log(chalk6.bold("\nOpen this URL in your browser:\n"));
+        console.log(chalk6.cyan(url));
+        console.log(chalk6.dim("\nPaste the authorization code here:"));
+        const { code } = await inquirer.prompt([{
+          type: "input",
+          name: "code",
+          message: "Authorization code:"
+        }]);
+        const email = await completeManualLogin2(code);
+        console.log(chalk6.green(`
+\u2713 Logged in as ${email}`));
+      } else {
+        const email = await loginAccount();
+        console.log(chalk6.green(`
+\u2713 Logged in as ${email}`));
+      }
+    } catch (err) {
+      console.error(chalk6.red(`
+\u2717 Login failed: ${err.message}`));
+      process.exit(1);
+    }
+  });
+  accounts.command("switch <email>").description("Set the active account").action((email) => {
+    if (setActiveAccount(email)) {
+      console.log(chalk6.green(`\u2713 Switched to ${email}`));
+    } else {
+      console.error(chalk6.red(`\u2717 Account "${email}" not found`));
+      process.exit(1);
+    }
+  });
+  accounts.command("remove <email>").description("Remove an account").action(async (email) => {
+    const { confirm } = await inquirer.prompt([{
+      type: "confirm",
+      name: "confirm",
+      message: `Remove account ${email}?`,
+      default: false
+    }]);
+    if (confirm) {
+      if (removeAccount(email)) {
+        console.log(chalk6.green(`\u2713 Removed ${email}`));
+      } else {
+        console.error(chalk6.red(`\u2717 Account "${email}" not found`));
+      }
+    }
+  });
+}
+
+// src/cli/commands/history.ts
+import chalk8 from "chalk";
+
+// src/cli/render/history-chart.ts
+import chalk7 from "chalk";
+var CHART_HEIGHT = 10;
+var CHART_WIDTH = 40;
+function renderHistoryChart(records, label = "Gemini Session") {
+  if (records.length === 0) {
+    return chalk7.dim("  No history data available");
+  }
+  const sorted = [...records].sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+  const values = sorted.map((r) => {
+    if (label.toLowerCase().includes("gemini")) {
+      if (label.toLowerCase().includes("weekly")) return r.geminiWeeklyRemaining;
+      return r.geminiSessionRemaining;
+    } else {
+      if (label.toLowerCase().includes("weekly")) return r.claudeWeeklyRemaining;
+      return r.claudeSessionRemaining;
+    }
+  }).filter((v) => v !== null);
+  if (values.length === 0) {
+    return chalk7.dim(`  No ${label} data available`);
+  }
+  const lines = [];
+  lines.push(chalk7.bold(`  \u{1F4CA} ${label} \u2014 Last ${values.length} readings`));
+  lines.push("");
+  const sampled = downsample(values, CHART_WIDTH);
+  for (let row = CHART_HEIGHT; row >= 0; row--) {
+    const threshold = row / CHART_HEIGHT;
+    const isAxis = row === 0;
+    let line = isAxis ? chalk7.dim("  0% ") : chalk7.dim("     ");
+    for (const val of sampled) {
+      if (val >= threshold) {
+        line += getQuotaColor(val)("\u2588");
+      } else {
+        line += chalk7.dim("\xB7");
+      }
+    }
+    if (row === CHART_HEIGHT) line += chalk7.dim(" 100%");
+    lines.push(line);
+  }
+  if (sorted.length >= 2) {
+    const first = new Date(sorted[0].timestamp);
+    const last = new Date(sorted[sorted.length - 1].timestamp);
+    lines.push(chalk7.dim(
+      `       ${formatTime(first)}${" ".repeat(Math.max(0, CHART_WIDTH - 12))}${formatTime(last)}`
+    ));
+  }
+  return lines.join("\n");
+}
+function renderComparisonChart(recordsByEmail, metric) {
+  const lines = [];
+  const emails = Object.keys(recordsByEmail);
+  lines.push(chalk7.bold(`  \u{1F4CA} Cross-Account Comparison \u2014 ${metricLabel(metric)}`));
+  lines.push("");
+  const maxEmailLen = Math.max(...emails.map((e) => e.length), 8);
+  for (const email of emails) {
+    const records = recordsByEmail[email];
+    const latest = records[0];
+    if (!latest) continue;
+    let value = null;
+    switch (metric) {
+      case "geminiSession":
+        value = latest.geminiSessionRemaining;
+        break;
+      case "claudeSession":
+        value = latest.claudeSessionRemaining;
+        break;
+      case "geminiWeekly":
+        value = latest.geminiWeeklyRemaining;
+        break;
+      case "claudeWeekly":
+        value = latest.claudeWeeklyRemaining;
+        break;
+    }
+    const label = email.slice(0, maxEmailLen).padEnd(maxEmailLen);
+    const pct = value !== null ? Math.round(value * 100) : -1;
+    const bar = value !== null ? renderMiniBar(value, 20) : chalk7.dim("\u2591".repeat(20));
+    const pctStr = pct >= 0 ? `${pct}%` : "N/A";
+    lines.push(`    ${chalk7.dim(label)}  ${bar} ${pctStr}`);
+  }
+  return lines.join("\n");
+}
+function renderMiniBar(fraction, width) {
+  const filled = Math.round(fraction * width);
+  const colorFn = getQuotaColor(fraction);
+  return colorFn("\u2588".repeat(filled)) + chalk7.dim("\u2591".repeat(width - filled));
+}
+function downsample(values, targetWidth) {
+  if (values.length <= targetWidth) return values;
+  const result = [];
+  const step = values.length / targetWidth;
+  for (let i = 0; i < targetWidth; i++) {
+    const idx = Math.round(i * step);
+    result.push(values[Math.min(idx, values.length - 1)]);
+  }
+  return result;
+}
+function formatTime(date) {
+  return `${date.getHours().toString().padStart(2, "0")}:${date.getMinutes().toString().padStart(2, "0")}`;
+}
+function metricLabel(metric) {
+  switch (metric) {
+    case "geminiSession":
+      return "Gemini 5-Hour";
+    case "claudeSession":
+      return "Claude + GPT 5-Hour";
+    case "geminiWeekly":
+      return "Gemini Weekly";
+    case "claudeWeekly":
+      return "Claude + GPT Weekly";
+    default:
+      return metric;
+  }
+}
+
+// src/cli/commands/history.ts
+function registerHistoryCommand(program2) {
+  program2.command("history").description("Show usage history and trends").option("-e, --email <email>", "Account email (default: active account)").option("-d, --days <days>", "Number of days to show", "7").option("--group <group>", "Filter: gemini, claude, all", "all").option("--json", "Output JSON").option("--compare", "Compare all accounts").action(async (opts) => {
+    try {
+      const client = new QuotaClient({ verbose: opts.verbose });
+      const email = opts.email || getActiveEmail();
+      if (!email) {
+        console.log(chalk8.dim("  No active account. Run `aq accounts add` or use --email."));
+        return;
+      }
+      const days = parseInt(opts.days, 10);
+      const history = client.getHistory(email, days);
+      const summary = client.getDailySummary(email, days);
+      if (opts.json) {
+        console.log(JSON.stringify({ email, days, history, summary }, null, 2));
+        return;
+      }
+      if (opts.compare) {
+        const allAccounts = listAccounts();
+        const allHistory = {};
+        for (const acct of allAccounts) {
+          allHistory[acct.email] = client.getHistory(acct.email, days);
+        }
+        console.log(renderComparisonChart(allHistory, "geminiSession"));
+        console.log("");
+        console.log(renderComparisonChart(allHistory, "claudeSession"));
+        return;
+      }
+      console.log(chalk8.bold(`
+  \u{1F4CA} Usage History \u2014 ${email} (last ${days} days)
+`));
+      if (opts.group === "all" || opts.group === "gemini") {
+        console.log(renderHistoryChart(history, "Gemini Session (5-hour)"));
+        console.log("");
+        console.log(renderHistoryChart(history, "Gemini Weekly"));
+        console.log("");
+      }
+      if (opts.group === "all" || opts.group === "claude") {
+        console.log(renderHistoryChart(history, "Claude + GPT Session (5-hour)"));
+        console.log("");
+        console.log(renderHistoryChart(history, "Claude + GPT Weekly"));
+        console.log("");
+      }
+      if (summary.length > 0) {
+        console.log(chalk8.bold("  \u{1F4C5} Daily Summary"));
+        for (const day of summary) {
+          const gemini = day.geminiSessionAvg !== null ? `${Math.round(day.geminiSessionAvg * 100)}%` : "\u2014";
+          const claude = day.claudeSessionAvg !== null ? `${Math.round(day.claudeSessionAvg * 100)}%` : "\u2014";
+          console.log(chalk8.dim(`    ${day.date}  `) + `Gemini: ${gemini}  Claude: ${claude}  (${day.count} readings)`);
+        }
+      }
+    } catch (err) {
+      console.error(chalk8.red(`Error: ${err.message}`));
+      process.exit(1);
+    }
+  });
+}
+function getActiveEmail() {
+  const accounts = listAccounts();
+  const active = accounts.find((a) => a.isActive);
+  return active?.email || null;
+}
+
+// src/cli/commands/doctor.ts
+import chalk9 from "chalk";
+function registerDoctorCommand(program2) {
+  program2.command("doctor").description("Diagnose setup issues").action(async () => {
+    console.log(chalk9.bold.cyan("\n  when-does-my-quota-refresh \u2014 Doctor\n"));
+    const checks = [];
+    const platform = isMacOS() ? "macOS" : isLinux() ? "Linux" : isWindows() ? "Windows" : process.platform;
+    checks.push({
+      label: "Platform",
+      status: "ok",
+      detail: platform
+    });
+    checks.push({
+      label: "Node.js",
+      status: process.version >= "v18" ? "ok" : "warn",
+      detail: process.version
+    });
+    try {
+      const configDir = getConfigDirPath();
+      checks.push({ label: "Config directory", status: "ok", detail: configDir });
+    } catch (err) {
+      checks.push({ label: "Config directory", status: "error", detail: err.message });
+    }
+    const config = loadConfig();
+    checks.push({
+      label: "Config loaded",
+      status: "ok",
+      detail: `mode=${config.defaultMode}, cache=${config.cacheTtlMs / 1e3}s`
+    });
+    const accounts = listAccounts();
+    if (accounts.length > 0) {
+      checks.push({
+        label: "Accounts",
+        status: "ok",
+        detail: `${accounts.length} configured (${accounts.find((a) => a.isActive)?.email || "none active"})`
+      });
+    } else {
+      checks.push({
+        label: "Accounts",
+        status: "warn",
+        detail: "No accounts configured (local mode may still work)"
+      });
+    }
+    const tokens = getActiveAccountTokens();
+    if (tokens) {
+      const expired = Date.now() >= (tokens.expiresAt || 0);
+      checks.push({
+        label: "Token status",
+        status: expired ? "warn" : "ok",
+        detail: expired ? "Access token expired (will refresh)" : "Valid"
+      });
+    }
+    try {
+      const processes = await detectAntigravityProcesses();
+      if (processes.length > 0) {
+        checks.push({
+          label: "Antigravity process",
+          status: "ok",
+          detail: `Found ${processes.length} process(es): ${processes.map((p) => `PID ${p.pid} (${p.scope})`).join(", ")}`
+        });
+      } else {
+        checks.push({
+          label: "Antigravity process",
+          status: "warn",
+          detail: "No process found (try opening Antigravity in your IDE)"
+        });
+      }
+    } catch (err) {
+      checks.push({
+        label: "Process detection",
+        status: "error",
+        detail: err.message
+      });
+    }
+    try {
+      const client = new QuotaClient();
+      const snapshot = await client.fetchQuota();
+      checks.push({
+        label: "Quota fetch",
+        status: "ok",
+        detail: `Source: ${snapshot.method}, Email: ${snapshot.email || "unknown"}, Groups: ${snapshot.groups.length}`
+      });
+    } catch (err) {
+      checks.push({
+        label: "Quota fetch",
+        status: "error",
+        detail: err.message
+      });
+    }
+    for (const check of checks) {
+      const icon = check.status === "ok" ? chalk9.green("\u2713") : check.status === "warn" ? chalk9.yellow("\u26A0") : chalk9.red("\u2717");
+      const label = chalk9.bold(check.label.padEnd(22));
+      console.log(`  ${icon} ${label} ${check.detail}`);
+    }
+    console.log("");
+    const errors = checks.filter((c) => c.status === "error").length;
+    const warnings = checks.filter((c) => c.status === "warn").length;
+    if (errors === 0 && warnings === 0) {
+      console.log(chalk9.green.bold("  \u2705 Everything looks good!"));
+    } else {
+      console.log(chalk9.yellow(`  ${errors} error(s), ${warnings} warning(s)`));
+    }
+    console.log("");
+    closeStore();
+  });
+}
+
+// src/cli/commands/config.ts
+import chalk10 from "chalk";
+function registerConfigCommand(program2) {
+  const config = program2.command("config").description("Manage settings");
+  config.command("show").description("Show current configuration").action(() => {
+    const cfg = loadConfig();
+    console.log(chalk10.bold("\n  Current Configuration\n"));
+    console.log(JSON.stringify(cfg, null, 2));
+    console.log(chalk10.dim(`
+  Config path: ${getConfigDirPath()}/config.json`));
+  });
+  config.command("set <key> <value>").description("Set a config value").action((key, value) => {
+    const cfg = loadConfig();
+    const keys = key.split(".");
+    let target = cfg;
+    for (let i = 0; i < keys.length - 1; i++) {
+      if (!(keys[i] in target)) {
+        target[keys[i]] = {};
+      }
+      target = target[keys[i]];
+    }
+    if (value === "true") value = true;
+    else if (value === "false") value = false;
+    else if (!isNaN(Number(value))) value = Number(value);
+    target[keys[keys.length - 1]] = value;
+    saveConfig(cfg);
+    console.log(chalk10.green(`\u2713 Set ${key} = ${value}`));
+  });
+  config.command("get <key>").description("Get a config value").action((key) => {
+    const cfg = loadConfig();
+    const keys = key.split(".");
+    let target = cfg;
+    for (const k of keys) {
+      if (target === void 0 || target === null) break;
+      target = target[k];
+    }
+    console.log(target !== void 0 ? String(target) : chalk10.dim("not set"));
+  });
+  config.command("path").description("Show config directory path").action(() => {
+    console.log(getConfigDirPath());
+  });
+}
+
+// src/cli/commands/wakeup.ts
+import chalk11 from "chalk";
+import { execSync } from "child_process";
+import { writeFileSync } from "fs";
+import { join as join2 } from "path";
+import { homedir } from "os";
+import inquirer2 from "inquirer";
+var CRON_MARKER = "# when-does-my-quota-refresh-wakeup";
+var TASK_NAME = "when-does-my-quota-refresh-wakeup";
+function registerWakeupCommand(program2) {
+  const wakeup = program2.command("wakeup").description("Auto-trigger quota refresh to maximize daily limits");
+  wakeup.command("config").description("Interactive wakeup setup").action(async () => {
+    console.log(chalk11.bold.cyan("\n  Wakeup Configuration\n"));
+    const config = loadConfig();
+    const answers = await inquirer2.prompt([
+      {
+        type: "list",
+        name: "mode",
+        message: "Trigger mode:",
+        choices: [
+          { name: "Smart detection \u2014 trigger when quota resets (Recommended)", value: "smart" },
+          { name: "Interval \u2014 trigger every N hours", value: "interval" },
+          { name: "Daily \u2014 trigger at specific times", value: "daily" }
+        ]
+      },
+      {
+        type: "number",
+        name: "intervalHours",
+        message: "Interval in hours:",
+        default: 6,
+        when: (a) => a.mode === "interval"
+      },
+      {
+        type: "input",
+        name: "dailyTimes",
+        message: "Times to trigger (comma-separated, e.g. 9,17):",
+        default: "9,17",
+        when: (a) => a.mode === "daily"
+      },
+      {
+        type: "confirm",
+        name: "allAccounts",
+        message: "Trigger for all accounts?",
+        default: true
+      }
+    ]);
+    config.wakeupAccounts = answers.allAccounts ? [] : [];
+    saveConfig(config);
+    console.log(chalk11.green("\n  \u2713 Configuration saved"));
+    console.log(chalk11.dim(`  Run \`aq wakeup install\` to activate`));
+  });
+  wakeup.command("install").description("Install wakeup to system scheduler").action(async () => {
+    try {
+      if (isWindows()) {
+        installWindowsTask();
+      } else {
+        installCrontab();
+      }
+      console.log(chalk11.green("\n  \u2713 Wakeup installed to system scheduler"));
+    } catch (err) {
+      console.error(chalk11.red(`
+  \u2717 Failed: ${err.message}`));
+    }
+  });
+  wakeup.command("uninstall").description("Remove wakeup from system scheduler").action(() => {
+    try {
+      if (isWindows()) {
+        uninstallWindowsTask();
+      } else {
+        uninstallCrontab();
+      }
+      console.log(chalk11.green("\n  \u2713 Wakeup removed from system scheduler"));
+    } catch (err) {
+      console.error(chalk11.red(`
+  \u2717 Failed: ${err.message}`));
+    }
+  });
+  wakeup.command("status").description("Check wakeup status").action(() => {
+    const config = loadConfig();
+    console.log(chalk11.bold("\n  Wakeup Status\n"));
+    console.log(`  Models: ${config.wakeupModels.join(", ")}`);
+    console.log(`  Accounts: ${config.wakeupAccounts.length > 0 ? config.wakeupAccounts.join(", ") : "all"}`);
+    if (isWindows()) {
+      const installed = checkWindowsTask();
+      console.log(`  Scheduler: ${installed ? chalk11.green("Installed") : chalk11.dim("Not installed")}`);
+    } else {
+      const installed = checkCrontab();
+      console.log(`  Cron: ${installed ? chalk11.green("Installed") : chalk11.dim("Not installed")}`);
+    }
+  });
+  wakeup.command("test").description("Test wakeup trigger manually").option("-e, --email <email>", "Account email").option("-m, --model <model>", "Model to test").option("-p, --prompt <prompt>", "Test prompt", "hi").action(async (opts) => {
+    console.log(chalk11.cyan("\n  Testing wakeup trigger...\n"));
+    try {
+      const aqPath = process.argv[1];
+      execSync(`"${aqPath}" quota --refresh`, { stdio: "inherit" });
+      console.log(chalk11.green("\n  \u2713 Wakeup test completed"));
+    } catch (err) {
+      console.error(chalk11.red(`
+  \u2717 Test failed: ${err.message}`));
+    }
+  });
+}
+function installCrontab() {
+  const aqPath = process.argv[1];
+  const config = loadConfig();
+  uninstallCrontab();
+  const intervalHours = 6;
+  const cronLine = `0 */${intervalHours} * * * "${aqPath}" quota --refresh --json > /dev/null 2>&1 ${CRON_MARKER}`;
+  try {
+    const existing = execSync("crontab -l 2>/dev/null", { encoding: "utf-8" }).trim();
+    const newCron = existing ? `${existing}
+${cronLine}` : cronLine;
+    execSync(`echo '${newCron}' | crontab -`, { encoding: "utf-8" });
+  } catch {
+    execSync(`echo '${cronLine}' | crontab -`, { encoding: "utf-8" });
+  }
+}
+function uninstallCrontab() {
+  try {
+    const existing = execSync("crontab -l 2>/dev/null", { encoding: "utf-8" });
+    const filtered = existing.split("\n").filter((l) => !l.includes(CRON_MARKER)).join("\n").trim();
+    execSync(`echo '${filtered}' | crontab -`, { encoding: "utf-8" });
+  } catch {
+  }
+}
+function checkCrontab() {
+  try {
+    const output = execSync("crontab -l 2>/dev/null", { encoding: "utf-8" });
+    return output.includes(CRON_MARKER);
+  } catch {
+    return false;
+  }
+}
+function installWindowsTask() {
+  const aqPath = process.argv[1];
+  const xmlPath = join2(homedir(), "when-does-my-quota-refresh-wakeup.xml");
+  uninstallWindowsTask();
+  const xml = `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <Triggers>
+    <TimeTrigger>
+      <Repetition>
+        <Interval>PT6H</Interval>
+      </Repetition>
+      <StartBoundary>2024-01-01T09:00:00</StartBoundary>
+    </TimeTrigger>
+  </Triggers>
+  <Actions>
+    <Exec>
+      <Command>node</Command>
+      <Arguments>"${aqPath}" quota --refresh</Arguments>
+    </Exec>
+  </Actions>
+  <Settings>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+  </Settings>
+</Task>`;
+  writeFileSync(xmlPath, xml);
+  execSync(`schtasks /create /tn "${TASK_NAME}" /xml "${xmlPath}" /f`, { encoding: "utf-8" });
+}
+function uninstallWindowsTask() {
+  try {
+    execSync(`schtasks /delete /tn "${TASK_NAME}" /f`, { encoding: "utf-8", stdio: "ignore" });
+  } catch {
+  }
+}
+function checkWindowsTask() {
+  try {
+    execSync(`schtasks /query /tn "${TASK_NAME}"`, { encoding: "utf-8", stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/commands/watch.ts
+import chalk12 from "chalk";
+function registerWatchCommand(program2) {
+  const watch = program2.command("watch").description("Real-time quota monitoring daemon");
+  watch.command("start").description("Start watching in the foreground").option("--interval <seconds>", "Poll interval in seconds", "60").action(async (opts) => {
+    const client = new QuotaClient({ verbose: opts.verbose });
+    const interval = parseInt(opts.interval, 10) * 1e3;
+    console.log(chalk12.bold.cyan(`
+  \u{1F504} Starting watch mode (every ${interval / 1e3}s)
+`));
+    const refresh = async () => {
+      try {
+        const { snapshots, history } = await client.getFullDashboard();
+        process.stdout.write("\x1B[2J\x1B[0f");
+        console.log(renderFullDashboard(snapshots, history));
+        console.log(chalk12.dim(`
+  Polling every ${interval / 1e3}s \u2014 Ctrl+C to exit`));
+      } catch (err) {
+        console.error(chalk12.red(`  Error: ${err.message}`));
+      }
+    };
+    await refresh();
+    setInterval(refresh, interval);
+    await new Promise(() => {
+    });
+  });
+  watch.command("status").description("Check daemon status").action(() => {
+    console.log(chalk12.bold("\n  Watch Status\n"));
+    console.log(chalk12.dim("  Use `aq watch start` to start monitoring in foreground"));
+  });
+}
+
+// src/cli/commands/plugin.ts
+import chalk13 from "chalk";
+function registerPluginCommand(program2) {
+  const plugin = program2.command("plugin").description("Manage plugins");
+  plugin.command("list").description("List installed plugins").action(() => {
+    const config = loadConfig();
+    if (config.plugins.length === 0) {
+      console.log(chalk13.dim("  No plugins installed"));
+      return;
+    }
+    console.log(chalk13.bold("\n  Installed Plugins\n"));
+    for (const p of config.plugins) {
+      console.log(`  \u{1F4E6} ${p}`);
+    }
+  });
+  plugin.command("install <name>").description("Install a plugin").action((name) => {
+    const config = loadConfig();
+    if (config.plugins.includes(name)) {
+      console.log(chalk13.yellow(`  Plugin "${name}" already installed`));
+      return;
+    }
+    config.plugins.push(name);
+    saveConfig(config);
+    console.log(chalk13.green(`\u2713 Plugin "${name}" installed`));
+  });
+  plugin.command("remove <name>").description("Remove a plugin").action((name) => {
+    const config = loadConfig();
+    const idx = config.plugins.indexOf(name);
+    if (idx < 0) {
+      console.log(chalk13.red(`  Plugin "${name}" not found`));
+      return;
+    }
+    config.plugins.splice(idx, 1);
+    saveConfig(config);
+    console.log(chalk13.green(`\u2713 Plugin "${name}" removed`));
+  });
+}
+
+// src/cli/index.ts
+var VERSION = "1.0.0";
+try {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const pkg = JSON.parse(readFileSync2(join3(__dirname, "..", "..", "package.json"), "utf-8"));
+  VERSION = pkg.version;
+} catch {
+}
+var program = new Command();
+program.name("aq").description("Cross-platform CLI for tracking Antigravity AI model quotas").version(VERSION).option("--verbose", "Enable debug output");
+registerQuotaCommand(program);
+registerAccountsCommand(program);
+registerHistoryCommand(program);
+registerDoctorCommand(program);
+registerConfigCommand(program);
+registerWakeupCommand(program);
+registerWatchCommand(program);
+registerPluginCommand(program);
+program.option("--full", "Show full dashboard with all accounts, groups, and sparklines");
+program.option("--json", "Output JSON (global)");
+program.option("--no-history", "Skip history sparkline in full dashboard");
+program.option("--watch", "Auto-refresh mode");
+var args = process.argv.slice(2);
+if (args.includes("--verbose")) {
+  setVerbose(true);
+}
+var isFull = args.includes("--full");
+program.action(async (opts) => {
+  if (isFull || opts.full) {
+    await executeFullDashboard({
+      json: opts.json,
+      watch: opts.watch,
+      noHistory: opts.noHistory,
+      verbose: opts.verbose
+    });
+  } else {
+    await program.parseAsync(["node", "aq", "quota", ...args.filter((a) => a !== "--full")]);
+  }
+});
+program.parse();
+//# sourceMappingURL=index.js.map