when-does-my-quota-refresh 1.0.0

package/dist/sdk/index.js

@@ -0,0 +1,1804 @@
+// src/core/logger.ts
+var _verbose = false;
+function setVerbose(verbose) {
+  _verbose = verbose;
+}
+function debug(module, msg, data) {
+  if (!_verbose) return;
+  const prefix = `[${module}]`;
+  if (data !== void 0) {
+    console.error(`${prefix} ${msg}`, data);
+  } else {
+    console.error(`${prefix} ${msg}`);
+  }
+}
+
+// src/core/errors.ts
+var SourceUnavailableError = class extends Error {
+  constructor(source, reason) {
+    super(`Source "${source}" unavailable${reason ? `: ${reason}` : ""}`);
+    this.name = "SourceUnavailableError";
+  }
+};
+var AuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthError";
+  }
+};
+var QuotaFetchError = class extends Error {
+  constructor(source, reason) {
+    super(`Failed to fetch quota from "${source}"${reason ? `: ${reason}` : ""}`);
+    this.name = "QuotaFetchError";
+  }
+};
+
+// 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 "";
+  }
+}
+
+// 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/oauth/client.ts
+import https2 from "https";
+import { URL as URL2 } from "url";
+
+// src/sources/cloud-code-api.ts
+var CLOUD_CODE_ENDPOINTS = {
+  /** Load code assist configuration */
+  loadCodeAssist: "https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist",
+  /** Onboard a new user */
+  onboardUser: "https://cloudcode-pa.googleapis.com/v1internal:onboardUser",
+  /** Fetch available models for the account */
+  fetchAvailableModels: "https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels",
+  /** Fetch raw quota data */
+  retrieveUserQuota: "https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota",
+  /** Fetch quota summary with weekly + session buckets */
+  retrieveUserQuotaSummary: "https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuotaSummary"
+};
+var CLOUD_CODE_DEFAULT_BODY = {
+  metadata: {
+    ideName: "antigravity",
+    extensionName: "antigravity",
+    locale: "en",
+    ideVersion: "unknown"
+  }
+};
+var OAUTH_CLIENT_ID = "764086051850-6qr4p6gpi6hn506pt8ejuq83di341hur.apps.googleusercontent.com";
+var OAUTH_CLIENT_SECRET = "d-FL95Q19q7MQmFpd7hHD0Ty";
+var OAUTH_SCOPES = [
+  "https://www.googleapis.com/auth/cloud-platform",
+  "https://www.googleapis.com/auth/cloudcode"
+].join(" ");
+
+// src/sources/oauth/client.ts
+var OAuthClient = class {
+  tokens = null;
+  constructor(tokens) {
+    this.tokens = tokens || null;
+  }
+  /**
+   * Generate the OAuth authorization URL for user login
+   */
+  getAuthUrl() {
+    const params = new URLSearchParams({
+      client_id: OAUTH_CLIENT_ID,
+      redirect_uri: "http://127.0.0.1:0/callback",
+      response_type: "code",
+      scope: OAUTH_SCOPES,
+      access_type: "offline",
+      prompt: "consent"
+    });
+    return `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;
+  }
+  /**
+   * Exchange an authorization code for tokens
+   */
+  async exchangeCode(code) {
+    const body = new URLSearchParams({
+      code,
+      client_id: OAUTH_CLIENT_ID,
+      client_secret: OAUTH_CLIENT_SECRET,
+      redirect_uri: "http://127.0.0.1:0/callback",
+      grant_type: "authorization_code"
+    });
+    const response = await this.postUrlEncoded("https://oauth2.googleapis.com/token", body);
+    const data = response;
+    this.tokens = {
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token || "",
+      expiresAt: Date.now() + data.expires_in * 1e3
+    };
+    return this.tokens;
+  }
+  /**
+   * Refresh the access token
+   */
+  async refreshAccessToken() {
+    if (!this.tokens?.refreshToken) {
+      throw new Error("No refresh token available");
+    }
+    const body = new URLSearchParams({
+      client_id: OAUTH_CLIENT_ID,
+      client_secret: OAUTH_CLIENT_SECRET,
+      refresh_token: this.tokens.refreshToken,
+      grant_type: "refresh_token"
+    });
+    const response = await this.postUrlEncoded("https://oauth2.googleapis.com/token", body);
+    const data = response;
+    this.tokens = {
+      ...this.tokens,
+      accessToken: data.access_token,
+      expiresAt: Date.now() + data.expires_in * 1e3
+    };
+    return this.tokens;
+  }
+  /**
+   * Get a valid access token, refreshing if necessary
+   */
+  async getAccessToken() {
+    if (!this.tokens) throw new Error("Not authenticated");
+    if (Date.now() >= this.tokens.expiresAt - 6e4) {
+      await this.refreshAccessToken();
+    }
+    return this.tokens.accessToken;
+  }
+  /**
+   * Get stored tokens
+   */
+  getTokens() {
+    return this.tokens;
+  }
+  /**
+   * Make an authenticated POST request to the Cloud Code API
+   */
+  async fetchQuotaSummary() {
+    const token = await this.getAccessToken();
+    return this.authenticatedPost(
+      CLOUD_CODE_ENDPOINTS.retrieveUserQuotaSummary,
+      CLOUD_CODE_DEFAULT_BODY,
+      token
+    );
+  }
+  async fetchUserStatus() {
+    const token = await this.getAccessToken();
+    return this.authenticatedPost(
+      CLOUD_CODE_ENDPOINTS.loadCodeAssist,
+      CLOUD_CODE_DEFAULT_BODY,
+      token
+    );
+  }
+  async fetchAvailableModels() {
+    const token = await this.getAccessToken();
+    return this.authenticatedPost(
+      CLOUD_CODE_ENDPOINTS.fetchAvailableModels,
+      CLOUD_CODE_DEFAULT_BODY,
+      token
+    );
+  }
+  // ── HTTP Helpers ────────────────────────────────────────────────
+  authenticatedPost(url, body, token) {
+    return new Promise((resolve, reject) => {
+      const parsed = new URL2(url);
+      const data = JSON.stringify(body);
+      const options = {
+        hostname: parsed.hostname,
+        path: parsed.pathname,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${token}`,
+          "Content-Length": Buffer.byteLength(data)
+        },
+        timeout: 1e4
+      };
+      const req = https2.request(options, (res) => {
+        let responseData = "";
+        res.on("data", (chunk) => {
+          responseData += chunk;
+        });
+        res.on("end", () => {
+          try {
+            resolve(JSON.parse(responseData));
+          } catch {
+            reject(new Error(`Invalid JSON: ${responseData.slice(0, 200)}`));
+          }
+        });
+      });
+      req.on("error", reject);
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Timeout"));
+      });
+      req.write(data);
+      req.end();
+    });
+  }
+  postUrlEncoded(url, body) {
+    return new Promise((resolve, reject) => {
+      const parsed = new URL2(url);
+      const data = body.toString();
+      const options = {
+        hostname: parsed.hostname,
+        path: parsed.pathname,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          "Content-Length": Buffer.byteLength(data)
+        },
+        timeout: 1e4
+      };
+      const req = https2.request(options, (res) => {
+        let responseData = "";
+        res.on("data", (chunk) => {
+          responseData += chunk;
+        });
+        res.on("end", () => {
+          try {
+            resolve(JSON.parse(responseData));
+          } catch {
+            reject(new Error(`Invalid JSON: ${responseData.slice(0, 200)}`));
+          }
+        });
+      });
+      req.on("error", reject);
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Timeout"));
+      });
+      req.write(data);
+      req.end();
+    });
+  }
+};
+
+// 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 as join2 } from "path";
+
+// src/core/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR_NAME = "when-does-my-quota-refresh";
+var DEFAULT_CONFIG = {
+  defaultMode: "local",
+  cacheTtlMs: 5 * 60 * 1e3,
+  // 5 minutes
+  refreshIntervalMs: 5 * 60 * 1e3,
+  wakeupModels: ["claude-sonnet-4-5", "gemini-3-flash", "gemini-3-pro-low"],
+  wakeupAccounts: [],
+  notifications: true,
+  plugins: [],
+  daemon: {
+    pollIntervalMs: 60 * 1e3,
+    enabled: false
+  }
+};
+function getConfigDir() {
+  const home = homedir();
+  switch (process.platform) {
+    case "darwin":
+      return join(home, "Library", "Application Support", CONFIG_DIR_NAME);
+    case "win32":
+      return join(process.env.APPDATA || join(home, "AppData", "Roaming"), CONFIG_DIR_NAME);
+    default:
+      return join(home, ".config", CONFIG_DIR_NAME);
+  }
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+function getDataDir() {
+  return join(getConfigDir(), "data");
+}
+function ensureDirs() {
+  const configDir = getConfigDir();
+  const dataDir = getDataDir();
+  if (!existsSync(configDir)) mkdirSync(configDir, { recursive: true });
+  if (!existsSync(dataDir)) mkdirSync(dataDir, { recursive: true });
+}
+function loadConfig() {
+  try {
+    const path = getConfigPath();
+    if (!existsSync(path)) return DEFAULT_CONFIG;
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    debug("config", `Loaded config from ${path}`);
+    return { ...DEFAULT_CONFIG, ...parsed };
+  } catch (err) {
+    debug("config", "Failed to load config, using defaults", err);
+    return DEFAULT_CONFIG;
+  }
+}
+function saveConfig(config) {
+  ensureDirs();
+  const path = getConfigPath();
+  writeFileSync(path, JSON.stringify(config, null, 2));
+  debug("config", `Saved config to ${path}`);
+}
+function getConfigDirPath() {
+  return getConfigDir();
+}
+function getDataDirPath() {
+  return getDataDir();
+}
+
+// src/sdk/store.ts
+var db = null;
+function getDb() {
+  if (db) return db;
+  ensureDirs();
+  const dbPath = join2(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 getLatestSnapshot(email) {
+  const history = getHistory(email, { limit: 1 });
+  return history[0] || null;
+}
+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 cleanupHistory(keepDays = 90) {
+  const database = getDb();
+  const cutoff = new Date(Date.now() - keepDays * 24 * 60 * 60 * 1e3).toISOString();
+  const result = database.prepare(
+    "DELETE FROM quota_snapshots WHERE timestamp < ?"
+  ).run(cutoff);
+  return result.changes;
+}
+function closeStore() {
+  if (db) {
+    db.close();
+    db = null;
+    debug("store", "Database closed");
+  }
+}
+
+// src/sdk/accounts/storage.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+var TOKENS_DIR = "accounts";
+function getStorePath() {
+  return join3(getConfigDirPath(), TOKENS_DIR, "tokens.json");
+}
+function loadStore() {
+  const path = getStorePath();
+  if (!existsSync2(path)) return { accounts: [] };
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return { accounts: [] };
+  }
+}
+function saveStore(store) {
+  ensureDirs();
+  writeFileSync2(getStorePath(), JSON.stringify(store, null, 2));
+  debug("account-storage", `Saved ${store.accounts.length} account(s)`);
+}
+function saveAccountTokens(email, tokens) {
+  const store = loadStore();
+  const existing = store.accounts.findIndex((a) => a.email === email);
+  const account = {
+    email,
+    tokens,
+    addedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (existing >= 0) {
+    store.accounts[existing] = account;
+  } else {
+    store.accounts.push(account);
+  }
+  if (store.accounts.length === 1) {
+    store.activeEmail = email;
+  }
+  saveStore(store);
+}
+function getAccountTokens(email) {
+  const store = loadStore();
+  const account = store.accounts.find((a) => a.email === email);
+  return account?.tokens || null;
+}
+function getActiveAccountTokens() {
+  const store = loadStore();
+  if (!store.activeEmail) return null;
+  const account = store.accounts.find((a) => a.email === store.activeEmail);
+  return account?.tokens || null;
+}
+function setActiveAccount(email) {
+  const store = loadStore();
+  if (!store.accounts.find((a) => a.email === email)) return false;
+  store.activeEmail = email;
+  saveStore(store);
+  return true;
+}
+function removeAccount(email) {
+  const store = loadStore();
+  const idx = store.accounts.findIndex((a) => a.email === email);
+  if (idx < 0) return false;
+  store.accounts.splice(idx, 1);
+  if (store.activeEmail === email) {
+    store.activeEmail = store.accounts[0]?.email;
+  }
+  saveStore(store);
+  return true;
+}
+function listAccounts() {
+  const store = loadStore();
+  return store.accounts.map((a) => ({
+    email: a.email,
+    isActive: a.email === store.activeEmail,
+    addedAt: a.addedAt
+  }));
+}
+function getAllAccountTokens() {
+  const store = loadStore();
+  return store.accounts.map((a) => a.tokens);
+}
+
+// src/sdk/accounts/auth.ts
+import open from "open";
+import http2 from "http";
+import { URL as URL3 } from "url";
+async function loginAccount() {
+  const client = new OAuthClient();
+  const authUrl = client.getAuthUrl();
+  debug("auth", "Starting OAuth login flow");
+  const code = await new Promise((resolve, reject) => {
+    const server = http2.createServer(async (req, res) => {
+      const url = new URL3(req.url || "/", `http://127.0.0.1`);
+      const code2 = url.searchParams.get("code");
+      if (code2) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <html><body style="font-family: sans-serif; text-align: center; padding: 50px;">
+            <h1>\u2705 Login successful!</h1>
+            <p>You can close this tab and return to the terminal.</p>
+          </body></html>
+        `);
+        server.close();
+        resolve(code2);
+      } else {
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(`<h1>Login failed: ${error}</h1>`);
+          server.close();
+          reject(new AuthError(`OAuth error: ${error}`));
+        } else {
+          res.writeHead(404);
+          res.end("Waiting for OAuth callback...");
+        }
+      }
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (typeof addr === "object" && addr) {
+        debug("auth", `Callback server on port ${addr.port}`);
+        open(authUrl).catch(() => {
+          console.log(`
+Open this URL in your browser:
+
+${authUrl}
+`);
+        });
+      }
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new AuthError("Login timed out after 5 minutes"));
+    }, 5 * 60 * 1e3);
+  });
+  const tokens = await client.exchangeCode(code);
+  const email = tokens.email || "unknown@gmail.com";
+  tokens.email = email;
+  saveAccountTokens(email, tokens);
+  setActiveAccount(email);
+  debug("auth", `Logged in as ${email}`);
+  return email;
+}
+
+// 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/sdk/index.ts
+function createClient(options) {
+  return new QuotaClient(options);
+}
+export {
+  AuthError,
+  QuotaCache,
+  QuotaClient,
+  QuotaFetchError,
+  SourceRegistry,
+  SourceUnavailableError,
+  cleanupHistory,
+  closeStore,
+  createClient,
+  getAccountTokens,
+  getActiveAccountTokens,
+  getConfigDirPath,
+  getDailySummary,
+  getDataDirPath,
+  getHistory,
+  getLatestSnapshot,
+  listAccounts,
+  loadConfig,
+  loginAccount,
+  removeAccount,
+  saveConfig,
+  setActiveAccount,
+  storeSnapshot
+};
+//# sourceMappingURL=index.js.map