antigravity-usage 0.1.0

package/dist/index.js

@@ -0,0 +1,2732 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/version.ts
+var version = "0.1.0";
+
+// src/core/logger.ts
+var debugMode = false;
+function setDebugMode(enabled) {
+  debugMode = enabled;
+}
+function isDebugMode() {
+  return debugMode;
+}
+function debug(category, message, data) {
+  if (!debugMode) return;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const prefix = `[${timestamp}] [${category}]`;
+  if (data !== void 0) {
+    console.error(`${prefix} ${message}`, data);
+  } else {
+    console.error(`${prefix} ${message}`);
+  }
+}
+function info(message) {
+  console.log(message);
+}
+function warn(message) {
+  console.warn(`\u26A0\uFE0F  ${message}`);
+}
+function error(message) {
+  console.error(`\u274C ${message}`);
+}
+function success(message) {
+  console.log(`\u2705 ${message}`);
+}
+
+// src/google/oauth.ts
+import { createServer } from "http";
+import { URL as URL2, URLSearchParams } from "url";
+import open from "open";
+
+// src/accounts/types.ts
+var DEFAULT_CONFIG = {
+  version: "2.0",
+  activeAccount: null,
+  preferences: {
+    cacheTTL: 300
+  }
+};
+
+// src/accounts/storage.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, rmSync } from "fs";
+import { join as join2 } from "path";
+
+// src/core/env.ts
+import { homedir, platform } from "os";
+import { join } from "path";
+function getPlatform() {
+  const p = platform();
+  if (p === "win32") return "windows";
+  if (p === "darwin") return "macos";
+  return "linux";
+}
+function getConfigDir() {
+  const p = getPlatform();
+  const home = homedir();
+  switch (p) {
+    case "windows":
+      return join(process.env.APPDATA || join(home, "AppData", "Roaming"), "antigravity-usage");
+    case "macos":
+      return join(home, "Library", "Application Support", "antigravity-usage");
+    case "linux":
+    default:
+      return join(process.env.XDG_CONFIG_HOME || join(home, ".config"), "antigravity-usage");
+  }
+}
+function getTokensPath() {
+  return join(getConfigDir(), "tokens.json");
+}
+function getAccountsDir() {
+  return join(getConfigDir(), "accounts");
+}
+function getAccountDir(email) {
+  const safeName = email.replace(/[^a-zA-Z0-9@._-]/g, "_");
+  return join(getAccountsDir(), safeName);
+}
+function getGlobalConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+
+// src/accounts/storage.ts
+function ensureAccountsDir() {
+  const dir = getAccountsDir();
+  if (!existsSync(dir)) {
+    debug("accounts-storage", `Creating accounts directory: ${dir}`);
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function ensureAccountDir(email) {
+  ensureAccountsDir();
+  const dir = getAccountDir(email);
+  if (!existsSync(dir)) {
+    debug("accounts-storage", `Creating account directory: ${dir}`);
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function accountExists(email) {
+  const dir = getAccountDir(email);
+  return existsSync(dir) && existsSync(join2(dir, "tokens.json"));
+}
+function listAccountEmails() {
+  const accountsDir = getAccountsDir();
+  if (!existsSync(accountsDir)) {
+    return [];
+  }
+  try {
+    const entries = readdirSync(accountsDir, { withFileTypes: true });
+    const emails = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const tokensPath = join2(accountsDir, entry.name, "tokens.json");
+        if (existsSync(tokensPath)) {
+          emails.push(entry.name);
+        }
+      }
+    }
+    return emails;
+  } catch (err) {
+    debug("accounts-storage", "Failed to list accounts", err);
+    return [];
+  }
+}
+function saveAccountTokens(email, tokens) {
+  ensureAccountDir(email);
+  const path = join2(getAccountDir(email), "tokens.json");
+  debug("accounts-storage", `Saving tokens for ${email}`);
+  writeFileSync(path, JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+function loadAccountTokens(email) {
+  const path = join2(getAccountDir(email), "tokens.json");
+  if (!existsSync(path)) {
+    debug("accounts-storage", `No tokens file for ${email}`);
+    return null;
+  }
+  try {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    debug("accounts-storage", `Failed to parse tokens for ${email}`, err);
+    return null;
+  }
+}
+function saveAccountMetadata(email, metadata) {
+  ensureAccountDir(email);
+  const path = join2(getAccountDir(email), "metadata.json");
+  debug("accounts-storage", `Saving metadata for ${email}`);
+  writeFileSync(path, JSON.stringify(metadata, null, 2), { mode: 384 });
+}
+function loadAccountMetadata(email) {
+  const path = join2(getAccountDir(email), "metadata.json");
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    debug("accounts-storage", `Failed to parse metadata for ${email}`, err);
+    return null;
+  }
+}
+function updateLastUsed(email) {
+  const metadata = loadAccountMetadata(email);
+  if (metadata) {
+    metadata.lastUsed = (/* @__PURE__ */ new Date()).toISOString();
+    saveAccountMetadata(email, metadata);
+  }
+}
+function saveAccountCache(email, cache) {
+  ensureAccountDir(email);
+  const path = join2(getAccountDir(email), "cache.json");
+  debug("accounts-storage", `Saving cache for ${email}`);
+  writeFileSync(path, JSON.stringify(cache, null, 2));
+}
+function loadAccountCache(email) {
+  const path = join2(getAccountDir(email), "cache.json");
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    debug("accounts-storage", `Failed to parse cache for ${email}`, err);
+    return null;
+  }
+}
+function deleteAccount(email) {
+  const dir = getAccountDir(email);
+  if (!existsSync(dir)) {
+    debug("accounts-storage", `Account ${email} does not exist`);
+    return false;
+  }
+  try {
+    rmSync(dir, { recursive: true, force: true });
+    debug("accounts-storage", `Deleted account ${email}`);
+    return true;
+  } catch (err) {
+    debug("accounts-storage", `Failed to delete account ${email}`, err);
+    return false;
+  }
+}
+
+// src/accounts/config.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname } from "path";
+function loadConfig() {
+  const path = getGlobalConfigPath();
+  if (!existsSync2(path)) {
+    debug("config", "No config file found, using defaults");
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const content = readFileSync2(path, "utf-8");
+    const config = JSON.parse(content);
+    return {
+      ...DEFAULT_CONFIG,
+      ...config,
+      preferences: {
+        ...DEFAULT_CONFIG.preferences,
+        ...config.preferences
+      }
+    };
+  } catch (err) {
+    debug("config", "Failed to parse config, using defaults", err);
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function saveConfig(config) {
+  const path = getGlobalConfigPath();
+  const dir = dirname(path);
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  debug("config", `Saving config to ${path}`);
+  writeFileSync2(path, JSON.stringify(config, null, 2));
+}
+function getActiveAccountEmail() {
+  const config = loadConfig();
+  return config.activeAccount;
+}
+function setActiveAccountEmail(email) {
+  const config = loadConfig();
+  config.activeAccount = email;
+  saveConfig(config);
+}
+function getCacheTTL() {
+  const config = loadConfig();
+  return config.preferences.cacheTTL;
+}
+
+// src/accounts/cache.ts
+function isCacheValid(email) {
+  const cache = loadAccountCache(email);
+  if (!cache || !cache.data) {
+    debug("cache", `No valid cache for ${email}`);
+    return false;
+  }
+  const cachedAt = new Date(cache.cachedAt).getTime();
+  const ttlMs = cache.ttl * 1e3;
+  const now = Date.now();
+  const isValid = now - cachedAt < ttlMs;
+  debug("cache", `Cache for ${email} is ${isValid ? "valid" : "stale"}`);
+  return isValid;
+}
+function getCacheAge(email) {
+  const cache = loadAccountCache(email);
+  if (!cache) {
+    return null;
+  }
+  const cachedAt = new Date(cache.cachedAt).getTime();
+  return Math.floor((Date.now() - cachedAt) / 1e3);
+}
+function saveCache(email, data) {
+  const ttl = getCacheTTL();
+  const cache = {
+    cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ttl,
+    data
+  };
+  saveAccountCache(email, cache);
+  debug("cache", `Cached quota for ${email}, TTL: ${ttl}s`);
+}
+function loadCache(email) {
+  const cache = loadAccountCache(email);
+  return cache?.data || null;
+}
+function loadCacheWithMeta(email) {
+  return loadAccountCache(email);
+}
+
+// src/accounts/manager.ts
+var EXPIRY_BUFFER_MS = 5 * 60 * 1e3;
+var AccountManager = class _AccountManager {
+  static instance = null;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_AccountManager.instance) {
+      _AccountManager.instance = new _AccountManager();
+    }
+    return _AccountManager.instance;
+  }
+  /**
+   * Reset instance (for testing)
+   */
+  static resetInstance() {
+    _AccountManager.instance = null;
+  }
+  /**
+   * Get all account emails
+   */
+  getAccountEmails() {
+    return listAccountEmails();
+  }
+  /**
+   * Get active account email
+   */
+  getActiveEmail() {
+    return getActiveAccountEmail();
+  }
+  /**
+   * Set active account
+   */
+  setActiveAccount(email) {
+    if (!accountExists(email)) {
+      debug("account-manager", `Account ${email} does not exist`);
+      return false;
+    }
+    setActiveAccountEmail(email);
+    updateLastUsed(email);
+    debug("account-manager", `Switched to account ${email}`);
+    return true;
+  }
+  /**
+   * Check if an account exists
+   */
+  hasAccount(email) {
+    return accountExists(email);
+  }
+  /**
+   * Get account status
+   */
+  getAccountStatus(email) {
+    const tokens = loadAccountTokens(email);
+    if (!tokens) {
+      return "invalid";
+    }
+    const now = Date.now();
+    if (now >= tokens.expiresAt - EXPIRY_BUFFER_MS) {
+      if (tokens.refreshToken) {
+        return "expired";
+      }
+      return "invalid";
+    }
+    return "valid";
+  }
+  /**
+   * Get detailed account info
+   */
+  getAccountInfo(email) {
+    if (!accountExists(email)) {
+      return null;
+    }
+    const activeEmail = getActiveAccountEmail();
+    const tokens = loadAccountTokens(email);
+    const metadata = loadAccountMetadata(email);
+    const cache = loadCacheWithMeta(email);
+    const status = this.getAccountStatus(email);
+    return {
+      email,
+      isActive: email === activeEmail,
+      tokens,
+      metadata,
+      cache,
+      status
+    };
+  }
+  /**
+   * Get account summaries for list display
+   */
+  getAccountSummaries() {
+    const emails = this.getAccountEmails();
+    const activeEmail = getActiveAccountEmail();
+    return emails.map((email) => {
+      const metadata = loadAccountMetadata(email);
+      const cache = loadCacheWithMeta(email);
+      const status = this.getAccountStatus(email);
+      let cachedCredits = null;
+      if (cache?.data?.promptCredits) {
+        const pc = cache.data.promptCredits;
+        cachedCredits = {
+          used: pc.monthly - pc.available,
+          limit: pc.monthly
+        };
+      }
+      return {
+        email,
+        isActive: email === activeEmail,
+        status,
+        lastUsed: metadata?.lastUsed || null,
+        cachedCredits
+      };
+    });
+  }
+  /**
+   * Add a new account after successful OAuth
+   */
+  addAccount(tokens, email) {
+    debug("account-manager", `Adding account ${email}`);
+    saveAccountTokens(email, tokens);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const metadata = {
+      email,
+      addedAt: now,
+      lastUsed: now
+    };
+    saveAccountMetadata(email, metadata);
+    setActiveAccountEmail(email);
+    debug("account-manager", `Account ${email} added and set as active`);
+  }
+  /**
+   * Update tokens for existing account
+   */
+  updateTokens(email, tokens) {
+    if (!accountExists(email)) {
+      debug("account-manager", `Cannot update tokens: account ${email} does not exist`);
+      return;
+    }
+    saveAccountTokens(email, tokens);
+    updateLastUsed(email);
+    debug("account-manager", `Updated tokens for ${email}`);
+  }
+  /**
+   * Remove an account
+   */
+  removeAccount(email) {
+    if (!accountExists(email)) {
+      debug("account-manager", `Account ${email} does not exist`);
+      return false;
+    }
+    const activeEmail = getActiveAccountEmail();
+    if (email === activeEmail) {
+      setActiveAccountEmail(null);
+    }
+    const deleted = deleteAccount(email);
+    if (deleted && email === activeEmail) {
+      const remaining = this.getAccountEmails();
+      if (remaining.length > 0) {
+        setActiveAccountEmail(remaining[0]);
+        debug("account-manager", `Set ${remaining[0]} as new active account`);
+      }
+    }
+    return deleted;
+  }
+  /**
+   * Remove all accounts
+   */
+  removeAllAccounts() {
+    const emails = this.getAccountEmails();
+    let count = 0;
+    for (const email of emails) {
+      if (deleteAccount(email)) {
+        count++;
+      }
+    }
+    setActiveAccountEmail(null);
+    debug("account-manager", `Removed ${count} accounts`);
+    return count;
+  }
+  /**
+   * Get tokens for an account
+   */
+  getTokens(email) {
+    return loadAccountTokens(email);
+  }
+  /**
+   * Get tokens for active account
+   */
+  getActiveTokens() {
+    const email = getActiveAccountEmail();
+    if (!email) {
+      return null;
+    }
+    return loadAccountTokens(email);
+  }
+  /**
+   * Check if cache is valid for an account
+   */
+  isCacheValid(email) {
+    return isCacheValid(email);
+  }
+  /**
+   * Get cache age in seconds
+   */
+  getCacheAge(email) {
+    return getCacheAge(email);
+  }
+};
+function getAccountManager() {
+  return AccountManager.getInstance();
+}
+
+// src/google/oauth.ts
+var OAUTH_CONFIG = {
+  clientId: process.env.ANTIGRAVITY_OAUTH_CLIENT_ID || "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com",
+  clientSecret: process.env.ANTIGRAVITY_OAUTH_CLIENT_SECRET || "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",
+  authUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+  tokenUrl: "https://oauth2.googleapis.com/token",
+  scopes: [
+    "https://www.googleapis.com/auth/cloud-platform",
+    "https://www.googleapis.com/auth/userinfo.email"
+  ]
+};
+function generateState() {
+  return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+}
+async function getAvailablePort(preferredPort) {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.listen(preferredPort || 0, "127.0.0.1", () => {
+      const address = server.address();
+      if (address && typeof address === "object") {
+        const port = address.port;
+        server.close(() => resolve(port));
+      } else {
+        reject(new Error("Failed to get server address"));
+      }
+    });
+    server.on("error", reject);
+  });
+}
+async function exchangeCodeForTokens(code, redirectUri) {
+  debug("oauth", "Exchanging code for tokens");
+  const params = new URLSearchParams({
+    code,
+    client_id: OAUTH_CONFIG.clientId,
+    client_secret: OAUTH_CONFIG.clientSecret,
+    redirect_uri: redirectUri,
+    grant_type: "authorization_code"
+  });
+  const response = await fetch(OAUTH_CONFIG.tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: params.toString()
+  });
+  if (!response.ok) {
+    const error2 = await response.text();
+    debug("oauth", "Token exchange failed", error2);
+    throw new Error(`Token exchange failed: ${response.status} ${error2}`);
+  }
+  const data = await response.json();
+  debug("oauth", "Token exchange successful");
+  return data;
+}
+async function getUserEmail(accessToken) {
+  debug("oauth", "Fetching user info");
+  try {
+    const response = await fetch("https://www.googleapis.com/oauth2/v2/userinfo", {
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      return data.email;
+    }
+  } catch (err) {
+    debug("oauth", "Failed to get user info", err);
+  }
+  return void 0;
+}
+async function fetchProjectId(accessToken) {
+  debug("oauth", "Fetching project ID from Cloud Code API");
+  try {
+    const response = await fetch("https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist", {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        "User-Agent": "antigravity/1.11.3 Darwin/arm64"
+      },
+      body: JSON.stringify({ metadata: { ideType: "ANTIGRAVITY" } })
+    });
+    if (response.ok) {
+      const data = await response.json();
+      debug("oauth", `Got project ID: ${data.cloudaicompanionProject}`);
+      return data.cloudaicompanionProject;
+    }
+    debug("oauth", `Failed to get project ID: ${response.status}`);
+  } catch (err) {
+    debug("oauth", "Error fetching project ID", err);
+  }
+  return void 0;
+}
+async function startOAuthFlow(options = {}) {
+  const port = await getAvailablePort(options.port);
+  const redirectUri = `http://127.0.0.1:${port}/callback`;
+  const state = generateState();
+  debug("oauth", `Starting OAuth flow on port ${port}`);
+  const authParams = new URLSearchParams({
+    client_id: OAUTH_CONFIG.clientId,
+    redirect_uri: redirectUri,
+    response_type: "code",
+    scope: OAUTH_CONFIG.scopes.join(" "),
+    access_type: "offline",
+    prompt: "consent",
+    state
+  });
+  const authUrl = `${OAUTH_CONFIG.authUrl}?${authParams.toString()}`;
+  return new Promise((resolve) => {
+    let resolved = false;
+    const server = createServer(async (req, res) => {
+      if (resolved) return;
+      const url = new URL2(req.url || "/", `http://127.0.0.1:${port}`);
+      if (url.pathname === "/callback") {
+        const code = url.searchParams.get("code");
+        const returnedState = url.searchParams.get("state");
+        const errorParam = url.searchParams.get("error");
+        if (errorParam) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end("<html><body><h1>Login Failed</h1><p>You can close this window.</p></body></html>");
+          resolved = true;
+          server.close();
+          resolve({ success: false, error: errorParam });
+          return;
+        }
+        if (!code || returnedState !== state) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end("<html><body><h1>Invalid Request</h1><p>State mismatch or missing code.</p></body></html>");
+          resolved = true;
+          server.close();
+          resolve({ success: false, error: "Invalid callback" });
+          return;
+        }
+        try {
+          const tokenResponse = await exchangeCodeForTokens(code, redirectUri);
+          const email = await getUserEmail(tokenResponse.access_token);
+          let projectId;
+          try {
+            projectId = await fetchProjectId(tokenResponse.access_token);
+          } catch (err) {
+            debug("oauth", "Failed to fetch project ID during login (will fetch on demand)", err);
+          }
+          const tokens = {
+            accessToken: tokenResponse.access_token,
+            refreshToken: tokenResponse.refresh_token || "",
+            expiresAt: Date.now() + tokenResponse.expires_in * 1e3,
+            email,
+            projectId
+          };
+          if (email) {
+            getAccountManager().addAccount(tokens, email);
+          }
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+            <html>
+              <body style="font-family: system-ui; padding: 40px; text-align: center;">
+                <h1>Login Successful!</h1>
+                <p>You are now logged in${email ? ` as <strong>${email}</strong>` : ""}.</p>
+                <p>You can close this window and return to the terminal.</p>
+              </body>
+            </html>
+          `);
+          resolved = true;
+          server.close();
+          resolve({ success: true, email });
+        } catch (err) {
+          res.writeHead(500, { "Content-Type": "text/html" });
+          res.end("<html><body><h1>Login Failed</h1><p>Token exchange failed.</p></body></html>");
+          resolved = true;
+          server.close();
+          resolve({ success: false, error: err instanceof Error ? err.message : "Unknown error" });
+        }
+      }
+    });
+    server.listen(port, "127.0.0.1", async () => {
+      info("");
+      info("Opening browser for Google login...");
+      info("");
+      if (options.noBrowser) {
+        info("Open this URL in your browser:");
+        info(authUrl);
+      } else {
+        try {
+          await open(authUrl);
+          info("If the browser did not open, visit this URL:");
+          info(authUrl);
+        } catch (err) {
+          debug("oauth", "Failed to open browser", err);
+          info("Could not open browser. Please visit this URL:");
+          info(authUrl);
+        }
+      }
+      info("");
+      info("Waiting for authentication...");
+    });
+    setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        server.close();
+        resolve({ success: false, error: "Login timed out" });
+      }
+    }, 2 * 60 * 1e3);
+  });
+}
+async function refreshAccessToken(refreshToken) {
+  debug("oauth", "Refreshing access token");
+  const params = new URLSearchParams({
+    refresh_token: refreshToken,
+    client_id: OAUTH_CONFIG.clientId,
+    client_secret: OAUTH_CONFIG.clientSecret,
+    grant_type: "refresh_token"
+  });
+  const response = await fetch(OAUTH_CONFIG.tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: params.toString()
+  });
+  if (!response.ok) {
+    const error2 = await response.text();
+    debug("oauth", "Token refresh failed", error2);
+    throw new Error(`Token refresh failed: ${response.status}`);
+  }
+  const data = await response.json();
+  debug("oauth", "Token refresh successful");
+  return data;
+}
+
+// src/google/storage.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync } from "fs";
+import { dirname as dirname2 } from "path";
+function saveTokens(tokens) {
+  const email = tokens.email;
+  if (!email) {
+    const path = getTokensPath();
+    const dir = dirname2(path);
+    debug("storage", `Saving tokens to legacy path ${path}`);
+    if (!existsSync3(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+    writeFileSync3(path, JSON.stringify(tokens, null, 2), { mode: 384 });
+    return;
+  }
+  debug("storage", `Saving tokens for account ${email}`);
+  saveAccountTokens(email, tokens);
+  if (!getActiveAccountEmail()) {
+    setActiveAccountEmail(email);
+  }
+}
+function loadTokens() {
+  const activeEmail = getActiveAccountEmail();
+  if (activeEmail) {
+    const tokens = loadAccountTokens(activeEmail);
+    if (tokens) {
+      debug("storage", `Loaded tokens for active account ${activeEmail}`);
+      return tokens;
+    }
+  }
+  const legacyPath = getTokensPath();
+  debug("storage", `Loading tokens from legacy path ${legacyPath}`);
+  if (!existsSync3(legacyPath)) {
+    debug("storage", "No tokens file found");
+    return null;
+  }
+  try {
+    const content = readFileSync3(legacyPath, "utf-8");
+    const tokens = JSON.parse(content);
+    debug("storage", "Tokens loaded successfully from legacy path");
+    return tokens;
+  } catch (err) {
+    debug("storage", "Failed to parse tokens file", err);
+    return null;
+  }
+}
+function hasTokens() {
+  const activeEmail = getActiveAccountEmail();
+  if (activeEmail && accountExists(activeEmail)) {
+    return true;
+  }
+  return existsSync3(getTokensPath());
+}
+function getStorageInfo() {
+  const configDir = getConfigDir();
+  const activeEmail = getActiveAccountEmail();
+  let tokensPath;
+  let exists;
+  if (activeEmail) {
+    tokensPath = `${getAccountDir(activeEmail)}/tokens.json`;
+    exists = accountExists(activeEmail);
+  } else {
+    tokensPath = getTokensPath();
+    exists = existsSync3(tokensPath);
+  }
+  return {
+    configDir,
+    tokensPath,
+    exists
+  };
+}
+
+// src/core/errors.ts
+var NotLoggedInError = class extends Error {
+  constructor(message = "Not logged in. Run: antigravity-usage login") {
+    super(message);
+    this.name = "NotLoggedInError";
+  }
+};
+var AuthenticationError = class extends Error {
+  constructor(message = "Authentication failed. Please login again.") {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+var NetworkError = class extends Error {
+  constructor(message = "Network error. Please check your connection.") {
+    super(message);
+    this.name = "NetworkError";
+  }
+};
+var RateLimitError = class extends Error {
+  retryAfterMs;
+  constructor(message = "Rate limited. Please try again later.", retryAfterMs) {
+    super(message);
+    this.name = "RateLimitError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+var APIError = class extends Error {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "APIError";
+    this.statusCode = statusCode;
+  }
+};
+var TokenRefreshError = class extends Error {
+  constructor(message = "Failed to refresh token. Please login again.") {
+    super(message);
+    this.name = "TokenRefreshError";
+  }
+};
+var AntigravityNotRunningError = class extends Error {
+  constructor(message = "Antigravity language server is not running. Please start Antigravity in your IDE.") {
+    super(message);
+    this.name = "AntigravityNotRunningError";
+  }
+};
+var LocalConnectionError = class extends Error {
+  constructor(message = "Failed to connect to local Antigravity server.") {
+    super(message);
+    this.name = "LocalConnectionError";
+  }
+};
+var PortDetectionError = class extends Error {
+  constructor(message = "Could not detect Antigravity server port.") {
+    super(message);
+    this.name = "PortDetectionError";
+  }
+};
+var NoAuthMethodAvailableError = class extends Error {
+  constructor(message = "Unable to fetch quota: Antigravity is not running and you are not logged in.\n\nPlease do one of the following:\n  \u2022 Run Antigravity in your IDE (VSCode, etc.), or\n  \u2022 Login with: antigravity-usage login") {
+    super(message);
+    this.name = "NoAuthMethodAvailableError";
+  }
+};
+
+// src/google/token-manager.ts
+var EXPIRY_BUFFER_MS2 = 5 * 60 * 1e3;
+var TokenManager = class {
+  tokens = null;
+  accountEmail = null;
+  constructor(email) {
+    if (email) {
+      this.accountEmail = email;
+      this.tokens = loadAccountTokens(email);
+    } else {
+      this.accountEmail = getActiveAccountEmail();
+      this.tokens = loadTokens();
+    }
+  }
+  /**
+   * Get the email this manager is for
+   */
+  getAccountEmail() {
+    return this.accountEmail || this.tokens?.email || null;
+  }
+  /**
+   * Check if user is logged in (has tokens)
+   */
+  isLoggedIn() {
+    if (this.accountEmail) {
+      return accountExists(this.accountEmail) && this.tokens !== null;
+    }
+    return hasTokens() && this.tokens !== null;
+  }
+  /**
+   * Get the stored email
+   */
+  getEmail() {
+    return this.tokens?.email;
+  }
+  /**
+   * Get token expiry time
+   */
+  getExpiresAt() {
+    if (!this.tokens) return void 0;
+    return new Date(this.tokens.expiresAt);
+  }
+  /**
+   * Get stored project ID
+   */
+  getProjectId() {
+    return this.tokens?.projectId;
+  }
+  /**
+   * Check if token is expired or about to expire
+   */
+  isTokenExpired() {
+    if (!this.tokens) return true;
+    return Date.now() >= this.tokens.expiresAt - EXPIRY_BUFFER_MS2;
+  }
+  /**
+   * Get a valid access token, refreshing if necessary
+   */
+  async getValidAccessToken() {
+    if (!this.tokens) {
+      throw new NotLoggedInError();
+    }
+    debug("token-manager", "Checking token validity");
+    if (this.isTokenExpired()) {
+      debug("token-manager", "Token expired or expiring soon, refreshing...");
+      await this.refreshToken();
+    }
+    return this.tokens.accessToken;
+  }
+  /**
+   * Refresh the access token
+   */
+  async refreshToken() {
+    if (!this.tokens?.refreshToken) {
+      throw new NotLoggedInError("No refresh token available. Please login again.");
+    }
+    try {
+      debug("token-manager", "Refreshing token...");
+      const response = await refreshAccessToken(this.tokens.refreshToken);
+      this.tokens = {
+        accessToken: response.access_token,
+        refreshToken: response.refresh_token || this.tokens.refreshToken,
+        expiresAt: Date.now() + response.expires_in * 1e3,
+        email: this.tokens.email,
+        projectId: this.tokens.projectId
+      };
+      if (this.accountEmail) {
+        saveAccountTokens(this.accountEmail, this.tokens);
+        updateLastUsed(this.accountEmail);
+      } else {
+        saveTokens(this.tokens);
+      }
+      debug("token-manager", "Token refreshed successfully");
+    } catch (err) {
+      debug("token-manager", "Token refresh failed", err);
+      throw new TokenRefreshError();
+    }
+  }
+  /**
+   * Reload tokens from disk
+   */
+  reload() {
+    if (this.accountEmail) {
+      this.tokens = loadAccountTokens(this.accountEmail);
+    } else {
+      this.tokens = loadTokens();
+    }
+  }
+};
+var tokenManagerInstance = null;
+function getTokenManager() {
+  if (!tokenManagerInstance) {
+    tokenManagerInstance = new TokenManager();
+  }
+  return tokenManagerInstance;
+}
+function getTokenManagerForAccount(email) {
+  return new TokenManager(email);
+}
+function resetTokenManager() {
+  tokenManagerInstance = null;
+}
+
+// src/commands/login.ts
+async function loginCommand(options) {
+  const manager = getAccountManager();
+  const existingAccounts = manager.getAccountEmails();
+  if (existingAccounts.length > 0) {
+    info(`You have ${existingAccounts.length} account(s). Adding another account...`);
+  }
+  const result = await startOAuthFlow({
+    noBrowser: options.noBrowser,
+    port: options.port
+  });
+  if (result.success) {
+    resetTokenManager();
+    success(`Logged in successfully${result.email ? ` as ${result.email}` : ""}!`);
+    const accounts = manager.getAccountEmails();
+    if (accounts.length > 1) {
+      info(`
+You now have ${accounts.length} accounts. Use \`antigravity-usage accounts list\` to see all.`);
+    }
+    process.exit(0);
+  } else {
+    error(`Login failed: ${result.error}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/logout.ts
+function logoutCommand(options, email) {
+  const manager = getAccountManager();
+  if (options.all) {
+    const count = manager.removeAllAccounts();
+    resetTokenManager();
+    if (count > 0) {
+      success(`Logged out of ${count} account(s).`);
+    } else {
+      warn("No accounts to log out.");
+    }
+    return;
+  }
+  if (email) {
+    if (!manager.hasAccount(email)) {
+      warn(`Account '${email}' not found.`);
+      return;
+    }
+    const removed2 = manager.removeAccount(email);
+    resetTokenManager();
+    if (removed2) {
+      success(`Logged out of ${email}.`);
+      const remaining = manager.getAccountEmails();
+      if (remaining.length > 0) {
+        info(`Active account: ${manager.getActiveEmail() || "none"}`);
+      }
+    } else {
+      warn(`Could not log out of ${email}.`);
+    }
+    return;
+  }
+  const activeEmail = manager.getActiveEmail();
+  if (!activeEmail) {
+    warn("Not logged in.");
+    return;
+  }
+  const removed = manager.removeAccount(activeEmail);
+  resetTokenManager();
+  if (removed) {
+    success(`Logged out of ${activeEmail}.`);
+    const remaining = manager.getAccountEmails();
+    if (remaining.length > 0) {
+      const newActive = manager.getActiveEmail();
+      info(`Switched to: ${newActive}`);
+    }
+  } else {
+    warn("Could not delete account.");
+  }
+}
+
+// src/core/mask.ts
+function maskToken(token) {
+  if (!token) return "";
+  if (token.length <= 10) return "***";
+  const first = token.slice(0, 6);
+  const last = token.slice(-4);
+  return `${first}...${last}`;
+}
+function maskEmail(email) {
+  if (!email) return "";
+  const [local, domain] = email.split("@");
+  if (!domain) return email;
+  if (local.length <= 2) {
+    return `${local[0] || ""}**@${domain}`;
+  }
+  return `${local.slice(0, 2)}**@${domain}`;
+}
+
+// src/commands/status.ts
+import Table from "cli-table3";
+function showSingleAccountStatus(email) {
+  const tokenManager = email ? getTokenManagerForAccount(email) : getTokenManager();
+  console.log();
+  console.log("\u{1F4CD} Antigravity Usage Status");
+  console.log("\u2500".repeat(40));
+  if (!tokenManager.isLoggedIn()) {
+    warn("Not logged in");
+    console.log();
+    info("Run `antigravity-usage login` to authenticate.");
+    console.log();
+    return;
+  }
+  const accountEmail = tokenManager.getEmail();
+  const expiresAt = tokenManager.getExpiresAt();
+  const isExpired = tokenManager.isTokenExpired();
+  console.log(`\u2705 Logged in: Yes`);
+  if (accountEmail) {
+    console.log(`\u{1F4E7} Email: ${maskEmail(accountEmail)}`);
+  }
+  if (expiresAt) {
+    const expiryStr = expiresAt.toLocaleString();
+    const status = isExpired ? " (expired/expiring soon)" : "";
+    console.log(`\u23F0 Token expires: ${expiryStr}${status}`);
+  }
+  if (isDebugMode()) {
+    const tokens = email ? getAccountManager().getTokens(email) : getAccountManager().getActiveTokens();
+    if (tokens) {
+      console.log();
+      console.log("Debug info:");
+      console.log(`  Access token: ${maskToken(tokens.accessToken)}`);
+      console.log(`  Refresh token: ${maskToken(tokens.refreshToken)}`);
+    }
+  }
+  console.log();
+}
+function showAllAccountsStatus() {
+  const manager = getAccountManager();
+  const emails = manager.getAccountEmails();
+  const activeEmail = manager.getActiveEmail();
+  console.log();
+  console.log("\u{1F4CD} Antigravity Usage Status - All Accounts");
+  console.log("\u2550".repeat(60));
+  if (emails.length === 0) {
+    warn("No accounts found.");
+    console.log();
+    info("Run `antigravity-usage login` to add an account.");
+    console.log();
+    return;
+  }
+  const table = new Table({
+    head: ["Account", "Logged In", "Token Expiry"],
+    style: {
+      head: ["cyan"],
+      border: ["gray"]
+    },
+    colWidths: [30, 12, 28]
+  });
+  for (const email of emails) {
+    const tokenManager = getTokenManagerForAccount(email);
+    const isActive = email === activeEmail;
+    const nameDisplay = isActive ? `${email} [*]` : email;
+    if (tokenManager.isLoggedIn()) {
+      const expiresAt = tokenManager.getExpiresAt();
+      const isExpired = tokenManager.isTokenExpired();
+      let expiryDisplay = "-";
+      if (expiresAt) {
+        expiryDisplay = expiresAt.toLocaleString();
+        if (isExpired) {
+          expiryDisplay = `\u26A0\uFE0F ${expiryDisplay}`;
+        }
+      }
+      table.push([
+        nameDisplay,
+        "\u2705",
+        expiryDisplay
+      ]);
+    } else {
+      table.push([
+        nameDisplay,
+        "\u274C",
+        "Invalid or missing"
+      ]);
+    }
+  }
+  console.log(table.toString());
+  console.log();
+  console.log("[*] = active account");
+  console.log();
+}
+function statusCommand(options = {}) {
+  if (options.all) {
+    showAllAccountsStatus();
+    return;
+  }
+  if (options.account) {
+    const manager = getAccountManager();
+    if (!manager.hasAccount(options.account)) {
+      warn(`Account '${options.account}' not found.`);
+      return;
+    }
+    showSingleAccountStatus(options.account);
+    return;
+  }
+  showSingleAccountStatus();
+}
+
+// src/google/cloudcode.ts
+var BASE_URL = "https://cloudcode-pa.googleapis.com";
+var USER_AGENT = "antigravity/1.11.3 Darwin/arm64";
+var CloudCodeClient = class {
+  constructor(tokenManager) {
+    this.tokenManager = tokenManager;
+  }
+  projectId;
+  /**
+   * Make an authenticated API request
+   */
+  async request(endpoint, body) {
+    const token = await this.tokenManager.getValidAccessToken();
+    const url = `${BASE_URL}${endpoint}`;
+    debug("cloudcode", `Calling ${endpoint}`);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Content-Type": "application/json",
+          "User-Agent": USER_AGENT
+        },
+        body: body ? JSON.stringify(body) : void 0
+      });
+      debug("cloudcode", `Response status: ${response.status}`);
+      if (response.status === 401 || response.status === 403) {
+        const errorBody = await response.text();
+        debug("cloudcode", `Auth error body: ${errorBody}`);
+        throw new AuthenticationError("Authentication failed. Please run: antigravity-usage login");
+      }
+      if (response.status === 429) {
+        const retryAfter = response.headers.get("retry-after");
+        const retryMs = retryAfter ? parseInt(retryAfter) * 1e3 : void 0;
+        throw new RateLimitError("Rate limited by Google API", retryMs);
+      }
+      if (response.status >= 500) {
+        throw new APIError(`Server error: ${response.status}`, response.status);
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        debug("cloudcode", "API error response", errorText);
+        throw new APIError(`API request failed: ${response.status}`, response.status);
+      }
+      const data = await response.json();
+      debug("cloudcode", "API call successful");
+      return data;
+    } catch (err) {
+      if (err instanceof AuthenticationError || err instanceof RateLimitError || err instanceof APIError) {
+        throw err;
+      }
+      if (err instanceof TypeError && err.message.includes("fetch")) {
+        throw new NetworkError("Network error. Please check your connection.");
+      }
+      throw err;
+    }
+  }
+  /**
+   * Load code assist status and plan info
+   * Also extracts project ID for subsequent calls
+   */
+  async loadCodeAssist() {
+    const response = await this.request("/v1internal:loadCodeAssist", {
+      metadata: { ideType: "ANTIGRAVITY" }
+    });
+    if (response.cloudaicompanionProject) {
+      this.projectId = response.cloudaicompanionProject;
+      debug("cloudcode", `Project ID: ${this.projectId}`);
+    }
+    return response;
+  }
+  /**
+   * Fetch available models with quota info
+   * Requires project ID from loadCodeAssist
+   */
+  async fetchAvailableModels() {
+    const body = this.projectId ? { project: this.projectId } : {};
+    return this.request("/v1internal:fetchAvailableModels", body);
+  }
+};
+
+// src/google/parser.ts
+function parseResetTime(resetTime) {
+  if (!resetTime) return void 0;
+  try {
+    const resetDate = new Date(resetTime);
+    const now = Date.now();
+    const diff = resetDate.getTime() - now;
+    return diff > 0 ? diff : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseModelInfo(modelId, model) {
+  const quotaInfo = model.quotaInfo;
+  return {
+    label: model.displayName || model.label || modelId,
+    modelId,
+    remainingPercentage: quotaInfo?.remainingFraction,
+    isExhausted: quotaInfo?.isExhausted ?? quotaInfo?.remainingFraction === 0,
+    resetTime: quotaInfo?.resetTime,
+    timeUntilResetMs: parseResetTime(quotaInfo?.resetTime)
+  };
+}
+function parsePromptCredits(response) {
+  const monthly = response.planInfo?.monthlyPromptCredits;
+  const available = response.availablePromptCredits;
+  if (monthly === void 0 || available === void 0) {
+    return void 0;
+  }
+  const used = monthly - available;
+  const usedPercentage = monthly > 0 ? used / monthly : 0;
+  const remainingPercentage = monthly > 0 ? available / monthly : 0;
+  return {
+    available,
+    monthly,
+    usedPercentage,
+    remainingPercentage
+  };
+}
+function shouldShowModel(modelId, model) {
+  if (modelId.startsWith("chat_") || modelId.startsWith("tab_")) {
+    return false;
+  }
+  if (modelId.includes("image")) {
+    return false;
+  }
+  if (modelId.startsWith("rev")) {
+    return false;
+  }
+  if (modelId.includes("mquery") || modelId.includes("lite")) {
+    return false;
+  }
+  if (!model.quotaInfo) {
+    return false;
+  }
+  return true;
+}
+function parseQuotaSnapshot(codeAssistResponse, modelsResponse, email) {
+  debug("parser", "Parsing quota snapshot");
+  const promptCredits = parsePromptCredits(codeAssistResponse);
+  const planType = codeAssistResponse.planInfo?.planType;
+  const modelsMap = modelsResponse.models || {};
+  const models = [];
+  for (const [modelId, modelInfo] of Object.entries(modelsMap)) {
+    if (shouldShowModel(modelId, modelInfo)) {
+      models.push(parseModelInfo(modelId, modelInfo));
+    }
+  }
+  models.sort((a, b) => a.label.localeCompare(b.label));
+  debug("parser", `Parsed ${models.length} models`);
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    method: "google",
+    email,
+    planType,
+    promptCredits,
+    models
+  };
+}
+
+// src/local/process-detector.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function detectAntigravityProcess() {
+  const platform2 = process.platform;
+  debug("process-detector", `Detecting Antigravity process on platform: ${platform2}`);
+  if (platform2 === "win32") {
+    return detectOnWindows();
+  } else {
+    return detectOnUnix();
+  }
+}
+async function detectOnUnix() {
+  try {
+    const { stdout } = await execAsync("ps aux");
+    const lines = stdout.split("\n");
+    for (const line of lines) {
+      if (line.toLowerCase().includes("antigravity") && (line.includes("language-server") || line.includes("lsp") || line.includes("server"))) {
+        debug("process-detector", `Found potential Antigravity process: ${line}`);
+        const processInfo = parseUnixProcessLine(line);
+        if (processInfo) {
+          return processInfo;
+        }
+      }
+    }
+    debug("process-detector", "No Antigravity process found");
+    return null;
+  } catch (err) {
+    debug("process-detector", "Error detecting process on Unix", err);
+    return null;
+  }
+}
+function parseUnixProcessLine(line) {
+  const parts = line.trim().split(/\s+/);
+  if (parts.length < 11) {
+    return null;
+  }
+  const pid = parseInt(parts[1], 10);
+  if (isNaN(pid)) {
+    return null;
+  }
+  const commandLine = parts.slice(10).join(" ");
+  const csrfToken = extractArgument(commandLine, "--csrf_token");
+  const extensionServerPort = extractArgument(commandLine, "--extension_server_port");
+  return {
+    pid,
+    csrfToken: csrfToken || void 0,
+    extensionServerPort: extensionServerPort ? parseInt(extensionServerPort, 10) : void 0,
+    commandLine
+  };
+}
+async function detectOnWindows() {
+  try {
+    const { stdout } = await execAsync(
+      `wmic process where "name like '%antigravity%' or commandline like '%antigravity%'" get processid,commandline /format:csv`,
+      { maxBuffer: 10 * 1024 * 1024 }
+      // 10MB buffer for long command lines
+    );
+    const lines = stdout.split("\n").filter((line) => line.trim() && !line.includes("Node,CommandLine,ProcessId"));
+    for (const line of lines) {
+      const parts = line.split(",");
+      if (parts.length >= 3) {
+        const commandLine = parts.slice(1, -1).join(",");
+        const pid = parseInt(parts[parts.length - 1].trim(), 10);
+        if (!isNaN(pid) && commandLine.toLowerCase().includes("antigravity")) {
+          debug("process-detector", `Found Antigravity process on Windows: PID ${pid}`);
+          const csrfToken = extractArgument(commandLine, "--csrf_token");
+          const extensionServerPort = extractArgument(commandLine, "--extension_server_port");
+          return {
+            pid,
+            csrfToken: csrfToken || void 0,
+            extensionServerPort: extensionServerPort ? parseInt(extensionServerPort, 10) : void 0,
+            commandLine
+          };
+        }
+      }
+    }
+    return await detectOnWindowsPowerShell();
+  } catch (err) {
+    debug("process-detector", "Error detecting process on Windows with WMIC, trying PowerShell", err);
+    return await detectOnWindowsPowerShell();
+  }
+}
+async function detectOnWindowsPowerShell() {
+  try {
+    const { stdout } = await execAsync(
+      `powershell -Command "Get-Process | Where-Object { $_.ProcessName -like '*antigravity*' } | Select-Object Id, ProcessName | ConvertTo-Json"`
+    );
+    if (!stdout.trim()) {
+      return null;
+    }
+    const processes = JSON.parse(stdout);
+    const processList = Array.isArray(processes) ? processes : [processes];
+    for (const proc of processList) {
+      if (proc.Id) {
+        const { stdout: cmdLine } = await execAsync(
+          `powershell -Command "(Get-CimInstance Win32_Process -Filter 'ProcessId = ${proc.Id}').CommandLine"`
+        );
+        const commandLine = cmdLine.trim();
+        const csrfToken = extractArgument(commandLine, "--csrf_token");
+        const extensionServerPort = extractArgument(commandLine, "--extension_server_port");
+        return {
+          pid: proc.Id,
+          csrfToken: csrfToken || void 0,
+          extensionServerPort: extensionServerPort ? parseInt(extensionServerPort, 10) : void 0,
+          commandLine
+        };
+      }
+    }
+    return null;
+  } catch (err) {
+    debug("process-detector", "Error detecting process on Windows with PowerShell", err);
+    return null;
+  }
+}
+function extractArgument(commandLine, argName) {
+  const eqRegex = new RegExp(`${argName}=([^\\s"']+|"[^"]*"|'[^']*')`, "i");
+  const eqMatch = commandLine.match(eqRegex);
+  if (eqMatch) {
+    return eqMatch[1].replace(/^["']|["']$/g, "");
+  }
+  const spaceRegex = new RegExp(`${argName}\\s+([^\\s"']+|"[^"]*"|'[^']*')`, "i");
+  const spaceMatch = commandLine.match(spaceRegex);
+  if (spaceMatch) {
+    return spaceMatch[1].replace(/^["']|["']$/g, "");
+  }
+  return null;
+}
+
+// src/local/port-detective.ts
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+async function discoverPorts(pid) {
+  const platform2 = process.platform;
+  debug("port-detective", `Discovering ports for PID ${pid} on platform: ${platform2}`);
+  if (platform2 === "win32") {
+    return discoverPortsOnWindows(pid);
+  } else if (platform2 === "darwin") {
+    return discoverPortsOnMacOS(pid);
+  } else {
+    return discoverPortsOnLinux(pid);
+  }
+}
+async function discoverPortsOnMacOS(pid) {
+  try {
+    const { stdout } = await execAsync2(`lsof -nP -iTCP -sTCP:LISTEN -a -p ${pid}`);
+    const ports = [];
+    const lines = stdout.split("\n");
+    for (const line of lines) {
+      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", `Found ports on macOS: ${ports.join(", ")}`);
+    return ports;
+  } catch (err) {
+    debug("port-detective", "Error discovering ports on macOS", err);
+    return [];
+  }
+}
+async function discoverPortsOnLinux(pid) {
+  try {
+    const { stdout } = await execAsync2(`ss -tlnp | grep "pid=${pid},"`);
+    const ports = [];
+    const lines = stdout.split("\n");
+    for (const line of lines) {
+      const match = line.match(/:(\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", `Found ports on Linux (ss): ${ports.join(", ")}`);
+      return ports;
+    }
+    return await discoverPortsOnLinuxNetstat(pid);
+  } catch {
+    return await discoverPortsOnLinuxNetstat(pid);
+  }
+}
+async function discoverPortsOnLinuxNetstat(pid) {
+  try {
+    const { stdout } = await execAsync2(`netstat -tlnp 2>/dev/null | grep "${pid}/"`);
+    const ports = [];
+    const lines = stdout.split("\n");
+    for (const line of lines) {
+      const match = line.match(/:(\d+)\s/);
+      if (match) {
+        const port = parseInt(match[1], 10);
+        if (!isNaN(port) && !ports.includes(port)) {
+          ports.push(port);
+        }
+      }
+    }
+    debug("port-detective", `Found ports on Linux (netstat): ${ports.join(", ")}`);
+    return ports;
+  } catch (err) {
+    debug("port-detective", "Error discovering ports on Linux", err);
+    return [];
+  }
+}
+async function discoverPortsOnWindows(pid) {
+  try {
+    const { stdout } = await execAsync2("netstat -ano");
+    const ports = [];
+    const lines = stdout.split("\n");
+    for (const line of lines) {
+      if (line.includes("LISTENING")) {
+        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);
+            }
+          }
+        }
+      }
+    }
+    debug("port-detective", `Found ports on Windows: ${ports.join(", ")}`);
+    return ports;
+  } catch (err) {
+    debug("port-detective", "Error discovering ports on Windows", err);
+    return [];
+  }
+}
+
+// src/local/port-prober.ts
+import https from "https";
+import http from "http";
+async function probeForConnectAPI(ports, csrfToken, timeout = 500) {
+  debug("port-prober", `Probing ${ports.length} ports: ${ports.join(", ")}`);
+  const probePromises = ports.map((port) => probePort(port, csrfToken, timeout));
+  const results = await Promise.allSettled(probePromises);
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result.status === "fulfilled" && result.value) {
+      debug("port-prober", `Found working endpoint: ${result.value.baseUrl}`);
+      return result.value;
+    }
+  }
+  debug("port-prober", "No working Connect API endpoint found");
+  return null;
+}
+async function probePort(port, csrfToken, timeout = 500) {
+  const httpsResult = await probeHttps(port, timeout, csrfToken);
+  if (httpsResult) {
+    return httpsResult;
+  }
+  const httpResult = await probeHttp(port, timeout);
+  if (httpResult) {
+    return httpResult;
+  }
+  return null;
+}
+function probeHttps(port, timeout, csrfToken) {
+  return new Promise((resolve) => {
+    const options = {
+      hostname: "127.0.0.1",
+      port,
+      path: "/exa.language_server_pb.LanguageServerService/GetUnleashData",
+      method: "POST",
+      timeout,
+      rejectUnauthorized: false,
+      // Allow self-signed certificates
+      headers: {
+        "Content-Type": "application/json",
+        "Connect-Protocol-Version": "1",
+        ...csrfToken ? { "X-Codeium-Csrf-Token": csrfToken } : {}
+      }
+    };
+    const req = https.request(options, (res) => {
+      if (res.statusCode === 200) {
+        debug("port-prober", `HTTPS Connect RPC probe on port ${port}: status ${res.statusCode} - valid connect port`);
+        resolve({
+          baseUrl: `https://127.0.0.1:${port}`,
+          protocol: "https",
+          port
+        });
+      } else {
+        debug("port-prober", `HTTPS probe on port ${port}: status ${res.statusCode} - not connect port`);
+        resolve(null);
+      }
+      res.resume();
+    });
+    req.on("error", (err) => {
+      debug("port-prober", `HTTPS probe on port ${port} failed: ${err.message}`);
+      resolve(null);
+    });
+    req.on("timeout", () => {
+      debug("port-prober", `HTTPS probe on port ${port} timed out`);
+      req.destroy();
+      resolve(null);
+    });
+    req.write(JSON.stringify({ wrapper_data: {} }));
+    req.end();
+  });
+}
+function probeHttp(port, timeout) {
+  return new Promise((resolve) => {
+    const options = {
+      hostname: "localhost",
+      port,
+      path: "/",
+      method: "GET",
+      timeout
+    };
+    const req = http.request(options, (res) => {
+      debug("port-prober", `HTTP probe on port ${port}: status ${res.statusCode}`);
+      resolve({
+        baseUrl: `http://localhost:${port}`,
+        protocol: "http",
+        port
+      });
+      res.resume();
+    });
+    req.on("error", (err) => {
+      debug("port-prober", `HTTP probe on port ${port} failed: ${err.message}`);
+      resolve(null);
+    });
+    req.on("timeout", () => {
+      debug("port-prober", `HTTP probe on port ${port} timed out`);
+      req.destroy();
+      resolve(null);
+    });
+    req.end();
+  });
+}
+
+// src/local/connect-client.ts
+import https2 from "https";
+import http2 from "http";
+var ConnectClient = class {
+  baseUrl;
+  csrfToken;
+  isHttps;
+  constructor(baseUrl, csrfToken) {
+    this.baseUrl = baseUrl;
+    this.csrfToken = csrfToken;
+    this.isHttps = baseUrl.startsWith("https://");
+    debug("connect-client", `Initialized with baseUrl: ${baseUrl}, hasToken: ${!!csrfToken}`);
+  }
+  /**
+   * Get user status including quota information
+   * Uses Connect RPC protocol to communicate with Antigravity language server
+   */
+  async getUserStatus() {
+    debug("connect-client", "Fetching user status via Connect RPC");
+    const endpoint = "/exa.language_server_pb.LanguageServerService/GetUserStatus";
+    try {
+      const response = await this.request("POST", endpoint, {
+        metadata: {
+          ideName: "antigravity",
+          extensionName: "antigravity",
+          locale: "en"
+        }
+      });
+      if (response) {
+        debug("connect-client", `Got response from ${endpoint}`);
+        return this.parseUserStatus(response);
+      }
+    } catch (err) {
+      debug("connect-client", `Connect RPC call failed: ${err}`);
+      throw new Error(`Failed to fetch user status: ${err instanceof Error ? err.message : "Unknown error"}`);
+    }
+    throw new Error("Could not fetch user status from Connect RPC endpoint");
+  }
+  /**
+   * Make an HTTP(S) request to the Connect API
+   */
+  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
+        // Allow self-signed certificates
+      };
+      const protocol = this.isHttps ? https2 : http2;
+      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 {
+              const parsed = JSON.parse(data);
+              resolve(parsed);
+            } catch {
+              resolve(data);
+            }
+          } else if (res.statusCode === 404) {
+            reject(new Error(`Endpoint not found: ${path}`));
+          } else {
+            reject(new Error(`HTTP ${res.statusCode}: ${data}`));
+          }
+        });
+      });
+      req.on("error", (err) => {
+        reject(err);
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Request timed out"));
+      });
+      if (body) {
+        req.write(JSON.stringify(body));
+      }
+      req.end();
+    });
+  }
+  /**
+   * Parse raw API response into ConnectUserStatus
+   */
+  parseUserStatus(response) {
+    debug("connect-client", "Raw response:", JSON.stringify(response, null, 2));
+    const status = {
+      raw: response
+    };
+    if (typeof response !== "object" || response === null) {
+      return status;
+    }
+    const data = response;
+    const userStatus = data.userStatus || data;
+    if ("email" in userStatus && typeof userStatus.email === "string") {
+      status.email = userStatus.email;
+    }
+    if ("isAuthenticated" in userStatus) {
+      status.isAuthenticated = Boolean(userStatus.isAuthenticated);
+    }
+    status.quota = this.extractQuota(userStatus);
+    return status;
+  }
+  /**
+   * Extract quota information from response
+   */
+  extractQuota(data) {
+    const quota = {};
+    const planStatus = data.planStatus;
+    if (planStatus) {
+      const available = planStatus.availablePromptCredits;
+      const planInfo = planStatus.planInfo;
+      const monthly = planInfo?.monthlyPromptCredits;
+      if (typeof available === "number" && typeof monthly === "number") {
+        const used = monthly - available;
+        quota.promptCredits = {
+          used,
+          limit: monthly,
+          remaining: available
+        };
+      }
+    }
+    const cascadeData = data.cascadeModelConfigData;
+    const clientModelConfigs = cascadeData?.clientModelConfigs;
+    if (Array.isArray(clientModelConfigs)) {
+      quota.models = clientModelConfigs.map(this.parseModel.bind(this));
+    }
+    return quota;
+  }
+  /**
+   * Parse a single model from the response
+   */
+  parseModel(model) {
+    if (typeof model !== "object" || model === null) {
+      return {
+        modelId: "unknown",
+        isExhausted: false
+      };
+    }
+    const m = model;
+    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: {
+        remaining: void 0,
+        limit: void 0,
+        usedPercentage: remainingFraction !== void 0 ? 1 - remainingFraction : void 0,
+        remainingPercentage: remainingFraction,
+        resetTime,
+        timeUntilResetMs: resetTime ? this.parseResetTime(resetTime) : void 0
+      },
+      isExhausted: remainingFraction === 0
+    };
+  }
+  /**
+   * Parse reset time to milliseconds until reset
+   */
+  parseResetTime(resetTime) {
+    try {
+      const resetDate = new Date(resetTime);
+      const now = Date.now();
+      const diff = resetDate.getTime() - now;
+      return diff > 0 ? diff : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// src/local/local-parser.ts
+function parseLocalQuotaSnapshot(userStatus) {
+  debug("local-parser", "Parsing local user status into QuotaSnapshot");
+  const snapshot = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    method: "local",
+    email: userStatus.email,
+    models: []
+  };
+  if (userStatus.quota?.promptCredits) {
+    snapshot.promptCredits = parsePromptCredits2(userStatus.quota.promptCredits);
+  }
+  if (userStatus.quota?.models) {
+    snapshot.models = userStatus.quota.models.map(parseModelQuota);
+  }
+  debug("local-parser", `Parsed ${snapshot.models.length} models`);
+  return snapshot;
+}
+function parsePromptCredits2(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;
+  }
+  const usedPercentage = limit > 0 ? used / limit : 0;
+  const remainingPercentage = limit > 0 ? remaining / limit : 1;
+  return {
+    available: remaining,
+    monthly: limit,
+    usedPercentage,
+    remainingPercentage
+  };
+}
+function parseModelQuota(model) {
+  const quota = model.quota;
+  return {
+    label: model.label || model.displayName || model.modelId,
+    modelId: model.modelId,
+    remainingPercentage: quota?.remainingPercentage,
+    isExhausted: model.isExhausted ?? quota?.remainingPercentage === 0,
+    resetTime: quota?.resetTime,
+    timeUntilResetMs: quota?.timeUntilResetMs
+  };
+}
+
+// src/quota/service.ts
+async function fetchQuota(method = "auto") {
+  if (method === "auto") {
+    try {
+      debug("service", "Auto mode: trying local method first");
+      return await fetchQuotaLocal();
+    } catch (err) {
+      debug("service", "Auto mode: local method failed", err);
+      const tokenManager = getTokenManager();
+      if (tokenManager.isLoggedIn()) {
+        debug("service", "User is logged in, falling back to Google method");
+        return fetchQuotaGoogle();
+      }
+      throw new NoAuthMethodAvailableError();
+    }
+  }
+  if (method === "local") {
+    return fetchQuotaLocal();
+  }
+  return fetchQuotaGoogle();
+}
+async function fetchQuotaGoogle() {
+  debug("service", "Fetching quota from Google");
+  const tokenManager = getTokenManager();
+  const email = tokenManager.getEmail();
+  const client = new CloudCodeClient(tokenManager);
+  const codeAssistResponse = await client.loadCodeAssist();
+  debug("service", "Code assist response received", JSON.stringify(codeAssistResponse));
+  let modelsResponse = {};
+  try {
+    modelsResponse = await client.fetchAvailableModels();
+    debug("service", "Models response received", JSON.stringify(modelsResponse));
+  } catch (err) {
+    debug("service", "Failed to fetch models (might need different permissions)", err);
+  }
+  const snapshot = parseQuotaSnapshot(codeAssistResponse, modelsResponse, email);
+  debug("service", "Quota snapshot created");
+  return snapshot;
+}
+async function fetchQuotaLocal() {
+  debug("service", "Fetching quota from local Antigravity server");
+  const processInfo = await detectAntigravityProcess();
+  if (!processInfo) {
+    throw new AntigravityNotRunningError();
+  }
+  debug("service", `Found Antigravity process: PID ${processInfo.pid}`);
+  const ports = await discoverPorts(processInfo.pid);
+  if (ports.length === 0) {
+    throw new PortDetectionError();
+  }
+  debug("service", `Discovered ${ports.length} listening ports: ${ports.join(", ")}`);
+  const probeResult = await probeForConnectAPI(ports, processInfo.csrfToken);
+  if (!probeResult) {
+    throw new LocalConnectionError("Could not find Antigravity Connect API on any port");
+  }
+  debug("service", `Found Connect API at ${probeResult.baseUrl}`);
+  const client = new ConnectClient(probeResult.baseUrl, processInfo.csrfToken);
+  const userStatus = await client.getUserStatus();
+  debug("service", "User status received from local server");
+  const snapshot = parseLocalQuotaSnapshot(userStatus);
+  debug("service", "Local quota snapshot created");
+  return snapshot;
+}
+
+// src/quota/format.ts
+import Table2 from "cli-table3";
+function formatTimeUntilReset(ms) {
+  if (ms === void 0 || ms <= 0) return "N/A";
+  const hours = Math.floor(ms / (1e3 * 60 * 60));
+  const minutes = Math.floor(ms % (1e3 * 60 * 60) / (1e3 * 60));
+  if (hours > 0) {
+    return `${hours}h ${minutes}m`;
+  }
+  return `${minutes}m`;
+}
+function formatRemaining(model) {
+  if (model.isExhausted) {
+    return "\u274C EXHAUSTED";
+  }
+  if (model.remainingPercentage === void 0) {
+    return "N/A";
+  }
+  const pct = Math.round(model.remainingPercentage * 100);
+  if (pct >= 75) return `\u{1F7E2} ${pct}%`;
+  if (pct >= 50) return `\u{1F7E1} ${pct}%`;
+  if (pct >= 25) return `\u{1F7E0} ${pct}%`;
+  return `\u{1F534} ${pct}%`;
+}
+function printQuotaTable(snapshot) {
+  const timestamp = new Date(snapshot.timestamp).toLocaleString();
+  console.log();
+  console.log(`\u{1F4CA} Antigravity Quota Status (via ${snapshot.method.toUpperCase()})`);
+  console.log(`   Retrieved: ${timestamp}`);
+  if (snapshot.email || snapshot.planType) {
+    const userParts = [];
+    if (snapshot.email) {
+      userParts.push(`\u{1F464} ${snapshot.email}`);
+    }
+    if (snapshot.planType) {
+      userParts.push(`\u{1F4CB} Plan: ${snapshot.planType}`);
+    }
+    console.log(`   ${userParts.join(" | ")}`);
+  }
+  console.log();
+  if (snapshot.models.length > 0) {
+    const table = new Table2({
+      head: ["Model", "Remaining", "Resets In"],
+      style: {
+        head: ["cyan"],
+        border: ["gray"]
+      }
+    });
+    for (const model of snapshot.models) {
+      table.push([
+        model.label,
+        formatRemaining(model),
+        formatTimeUntilReset(model.timeUntilResetMs)
+      ]);
+    }
+    console.log(table.toString());
+  } else {
+    console.log("No model quota information available.");
+  }
+  console.log();
+}
+function printQuotaJson(snapshot) {
+  console.log(JSON.stringify(snapshot, null, 2));
+}
+
+// src/render/table.ts
+import Table3 from "cli-table3";
+function formatRelativeTime(isoDate) {
+  if (!isoDate) return "Never";
+  const date = new Date(isoDate);
+  const now = Date.now();
+  const diffMs = now - date.getTime();
+  const minutes = Math.floor(diffMs / (1e3 * 60));
+  const hours = Math.floor(diffMs / (1e3 * 60 * 60));
+  const days = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+  if (minutes < 1) return "Just now";
+  if (minutes < 60) return `${minutes}m ago`;
+  if (hours < 24) return `${hours}h ago`;
+  if (days === 1) return "Yesterday";
+  return `${days} days ago`;
+}
+function formatStatus(status) {
+  switch (status) {
+    case "valid":
+      return "\u2705";
+    case "expired":
+      return "\u26A0\uFE0F";
+    case "invalid":
+      return "\u274C";
+    default:
+      return "\u2753";
+  }
+}
+function formatCredits(credits) {
+  if (!credits) return "-";
+  return `${credits.limit - credits.used} / ${credits.limit}`;
+}
+function renderAccountsTable(accounts) {
+  if (accounts.length === 0) {
+    console.log("\n\u{1F4ED} No accounts found.");
+    console.log("\n\u{1F4A1} Run `antigravity-usage login` to add an account.\n");
+    return;
+  }
+  console.log("\n\u{1F4CA} Antigravity Accounts");
+  console.log("\u2550".repeat(60));
+  const totalWidth = process.stdout.columns || 80;
+  const isSmallTerminal = totalWidth < 90;
+  const colWidths = isSmallTerminal ? [25, 8, 12, 12] : [30, 10, 15, 15];
+  const finalColWidths = totalWidth < 60 ? void 0 : colWidths;
+  const tableOptions = {
+    head: ["Account", "Status", "Credits", "Last Used"],
+    style: {
+      head: ["cyan"],
+      border: ["gray"]
+    }
+  };
+  if (finalColWidths) {
+    tableOptions.colWidths = finalColWidths;
+  }
+  const table = new Table3(tableOptions);
+  for (const account of accounts) {
+    const nameDisplay = account.isActive ? `${account.email} [*]` : account.email;
+    table.push([
+      nameDisplay,
+      formatStatus(account.status),
+      formatCredits(account.cachedCredits),
+      formatRelativeTime(account.lastUsed)
+    ]);
+  }
+  console.log(table.toString());
+  console.log("\n[*] = active account\n");
+}
+function formatQuotaRemainingBar(remainingPercentage) {
+  const width = 10;
+  const filled = Math.round(remainingPercentage / 100 * width);
+  const empty = width - filled;
+  const filledChar = "\u2588";
+  const emptyChar = "\u2591";
+  return `${filledChar.repeat(filled)}${emptyChar.repeat(empty)} ${Math.round(remainingPercentage)}%`;
+}
+function renderAllQuotaTable(results) {
+  if (results.length === 0) {
+    console.log("\n\u{1F4ED} No accounts found.");
+    console.log("\n\u{1F4A1} Run `antigravity-usage login` to add an account.\n");
+    return;
+  }
+  const sortedResults = [...results].sort((a, b) => {
+    if (a.status === "error" && b.status !== "error") return 1;
+    if (a.status !== "error" && b.status === "error") return -1;
+    if (a.status === "error" && b.status === "error") return 0;
+    const getRemaining = (result) => {
+      const firstModel = result.snapshot?.models?.[0];
+      if (!firstModel) return -1;
+      if (firstModel.isExhausted) return 0;
+      return firstModel.remainingPercentage ?? -1;
+    };
+    const aRemaining = getRemaining(a);
+    const bRemaining = getRemaining(b);
+    return bRemaining - aRemaining;
+  });
+  console.log("\n\u{1F4CA} Quota Overview - All Accounts");
+  console.log("\u2550".repeat(70));
+  const totalWidth = process.stdout.columns || 80;
+  let colWidths;
+  if (totalWidth < 80) {
+    colWidths = void 0;
+  } else if (totalWidth < 100) {
+    colWidths = [25, 8, 12, 18];
+  } else {
+    colWidths = [30, 10, 15, 20];
+  }
+  const tableOptions = {
+    head: ["Account", "Source", "Credits", "Quota Remaining"],
+    style: {
+      head: ["cyan"],
+      border: ["gray"]
+    }
+  };
+  if (colWidths) {
+    tableOptions.colWidths = colWidths;
+  }
+  const table = new Table3(tableOptions);
+  const errors = [];
+  for (const result of sortedResults) {
+    const nameDisplay = result.isActive ? `${result.email} [*]` : result.email;
+    if (result.status === "error") {
+      table.push([
+        nameDisplay,
+        "-",
+        "-",
+        result.error || "Error"
+      ]);
+      errors.push(`${result.email}: ${result.error}`);
+    } else {
+      const snapshot = result.snapshot;
+      const source = result.status === "cached" ? `Cached (${formatCacheAge(result.cacheAge)})` : snapshot?.method.toUpperCase() || "-";
+      let credits = "-";
+      if (snapshot?.promptCredits) {
+        const pc = snapshot.promptCredits;
+        credits = `${pc.available} / ${pc.monthly}`;
+      }
+      let quotaRemaining = "-";
+      if (snapshot?.models && snapshot.models.length > 0) {
+        const minRemaining = Math.min(
+          ...snapshot.models.filter((m) => m.remainingPercentage !== void 0).map((m) => m.remainingPercentage)
+        );
+        if (isFinite(minRemaining)) {
+          const remainingPct = minRemaining * 100;
+          quotaRemaining = formatQuotaRemainingBar(remainingPct);
+        } else if (snapshot.models.some((m) => m.isExhausted)) {
+          quotaRemaining = "\u274C EXHAUSTED";
+        }
+      }
+      table.push([
+        nameDisplay,
+        source,
+        credits,
+        quotaRemaining
+      ]);
+    }
+  }
+  console.log(table.toString());
+  if (errors.length > 0) {
+    console.log(`
+\u26A0\uFE0F  ${errors.length} account(s) had errors:`);
+    for (const err of errors) {
+      console.log(`   - ${err}`);
+    }
+  }
+  console.log("\n[*] = active account");
+  console.log("\u{1F4A1} Use --refresh to fetch latest data\n");
+}
+function formatCacheAge(seconds) {
+  if (seconds === void 0) return "?";
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+  return `${Math.floor(seconds / 3600)}h`;
+}
+
+// src/commands/quota.ts
+async function fetchSingleAccountQuota(options) {
+  const manager = getAccountManager();
+  const accountEmail = options.account || manager.getActiveEmail();
+  const originalActiveEmail = manager.getActiveEmail();
+  let method = options.method || "auto";
+  if (options.account && method !== "google") {
+    debug("quota", `Account specified, forcing google method (local uses IDE account)`);
+    method = "google";
+  }
+  if (method === "google") {
+    const tokenManager = options.account ? getTokenManagerForAccount(options.account) : getTokenManager();
+    if (!tokenManager.isLoggedIn()) {
+      error("Not logged in. Run: antigravity-usage login");
+      process.exit(1);
+    }
+  }
+  try {
+    let accountSwitched = false;
+    if (options.account && options.account !== originalActiveEmail) {
+      debug("quota", `Temporarily switching to account ${options.account} for fetch`);
+      manager.setActiveAccount(options.account);
+      accountSwitched = true;
+    }
+    try {
+      debug("quota", `Fetching quota via ${method} method...`);
+      const snapshot = await fetchQuota(method);
+      if (accountEmail) {
+        saveCache(accountEmail, snapshot);
+      }
+      if (options.json) {
+        printQuotaJson(snapshot);
+      } else {
+        printQuotaTable(snapshot);
+      }
+    } finally {
+      if (accountSwitched && originalActiveEmail) {
+        debug("quota", `Restoring active account to ${originalActiveEmail}`);
+        manager.setActiveAccount(originalActiveEmail);
+      }
+    }
+  } catch (err) {
+    handleQuotaError(err);
+  }
+}
+async function fetchAllAccountsQuota(options) {
+  const manager = getAccountManager();
+  const emails = manager.getAccountEmails();
+  const activeEmail = manager.getActiveEmail();
+  if (emails.length === 0) {
+    error("No accounts found. Run: antigravity-usage login");
+    process.exit(1);
+  }
+  if (options.refresh) {
+    info("\u{1F504} Refreshing quota data for all accounts...\n");
+  }
+  const results = [];
+  for (const email of emails) {
+    const isActive = email === activeEmail;
+    try {
+      if (!options.refresh && isCacheValid(email)) {
+        const cached = loadCache(email);
+        if (cached) {
+          debug("quota", `Using cached data for ${email}`);
+          results.push({
+            email,
+            isActive,
+            status: "cached",
+            snapshot: cached,
+            cacheAge: getCacheAge(email) || 0
+          });
+          continue;
+        }
+      }
+      debug("quota", `Fetching fresh data for ${email}`);
+      const snapshot = await fetchQuotaForAccount(email, options.method || "auto");
+      saveCache(email, snapshot);
+      results.push({
+        email,
+        isActive,
+        status: "success",
+        snapshot
+      });
+    } catch (err) {
+      debug("quota", `Error fetching quota for ${email}:`, err);
+      const cached = loadCache(email);
+      if (cached) {
+        results.push({
+          email,
+          isActive,
+          status: "cached",
+          snapshot: cached,
+          cacheAge: getCacheAge(email) || 0
+        });
+      } else {
+        results.push({
+          email,
+          isActive,
+          status: "error",
+          error: err instanceof Error ? err.message : "Unknown error"
+        });
+      }
+    }
+  }
+  if (options.json) {
+    console.log(JSON.stringify(results, null, 2));
+  } else {
+    renderAllQuotaTable(results);
+  }
+}
+async function fetchQuotaForAccount(email, method) {
+  const manager = getAccountManager();
+  const originalActiveEmail = manager.getActiveEmail();
+  let effectiveMethod = method;
+  if (method === "auto" || method === "local") {
+    effectiveMethod = "google";
+    debug("quota", `Forcing Google API for multi-account fetch (email: ${email})`);
+  }
+  let accountSwitched = false;
+  if (email !== originalActiveEmail) {
+    debug("quota", `Switching to ${email} for fetch`);
+    manager.setActiveAccount(email);
+    resetTokenManager();
+    accountSwitched = true;
+  }
+  try {
+    const snapshot = await fetchQuota(effectiveMethod);
+    return snapshot;
+  } finally {
+    if (accountSwitched && originalActiveEmail) {
+      debug("quota", `Restoring active account to ${originalActiveEmail}`);
+      manager.setActiveAccount(originalActiveEmail);
+      resetTokenManager();
+    }
+  }
+}
+function handleQuotaError(err) {
+  if (err instanceof NoAuthMethodAvailableError) {
+    error(err.message);
+    process.exit(1);
+  }
+  if (err instanceof AntigravityNotRunningError) {
+    error(err.message);
+    console.log("\nTip: Make sure Antigravity is running in your IDE (VSCode, etc.)");
+    process.exit(1);
+  }
+  if (err instanceof LocalConnectionError) {
+    error(err.message);
+    console.log("\nTip: Try restarting your IDE or the Antigravity extension.");
+    process.exit(1);
+  }
+  if (err instanceof PortDetectionError) {
+    error(err.message);
+    console.log("\nTip: This may happen if the Antigravity language server is still starting up.");
+    process.exit(1);
+  }
+  if (err instanceof NotLoggedInError) {
+    error(err.message);
+    process.exit(1);
+  }
+  if (err instanceof AuthenticationError) {
+    error(err.message);
+    process.exit(1);
+  }
+  if (err instanceof NetworkError) {
+    error(err.message);
+    process.exit(1);
+  }
+  if (err instanceof RateLimitError) {
+    error(err.message);
+    if (err.retryAfterMs) {
+      const seconds = Math.ceil(err.retryAfterMs / 1e3);
+      console.log(`Retry after ${seconds} seconds.`);
+    }
+    process.exit(1);
+  }
+  if (err instanceof APIError) {
+    error(err.message);
+    process.exit(1);
+  }
+  error(`Failed to fetch quota: ${err instanceof Error ? err.message : "Unknown error"}`);
+  debug("quota", "Error details", err);
+  process.exit(1);
+}
+async function quotaCommand(options) {
+  if (options.all) {
+    await fetchAllAccountsQuota(options);
+  } else {
+    await fetchSingleAccountQuota(options);
+  }
+}
+
+// src/commands/doctor.ts
+function doctorCommand() {
+  console.log();
+  console.log("\u{1FA7A} Antigravity Usage - Diagnostics");
+  console.log("\u2550".repeat(50));
+  console.log();
+  console.log("\u{1F4E6} Version");
+  console.log("\u2500".repeat(40));
+  console.log(`  CLI version: ${version}`);
+  console.log(`  Node.js: ${process.version}`);
+  console.log(`  Platform: ${getPlatform()}`);
+  console.log();
+  const storage = getStorageInfo();
+  console.log("\u{1F4C1} Configuration");
+  console.log("\u2500".repeat(40));
+  console.log(`  Config dir: ${storage.configDir}`);
+  console.log(`  Tokens file: ${storage.tokensPath}`);
+  console.log(`  Tokens exist: ${storage.exists ? "Yes" : "No"}`);
+  console.log();
+  const tokenManager = getTokenManager();
+  console.log("\u{1F510} Authentication");
+  console.log("\u2500".repeat(40));
+  if (!tokenManager.isLoggedIn()) {
+    console.log("  Status: Not logged in");
+    console.log();
+    console.log("  \u{1F4A1} Run `antigravity-usage login` to authenticate.");
+  } else {
+    console.log("  Status: Logged in");
+    const email = tokenManager.getEmail();
+    if (email) {
+      console.log(`  Email: ${maskEmail(email)}`);
+    }
+    const expiresAt = tokenManager.getExpiresAt();
+    if (expiresAt) {
+      const isExpired = tokenManager.isTokenExpired();
+      console.log(`  Token expires: ${expiresAt.toLocaleString()}`);
+      console.log(`  Token valid: ${isExpired ? "No (needs refresh)" : "Yes"}`);
+    }
+  }
+  console.log();
+  console.log("\u{1F527} OAuth Configuration");
+  console.log("\u2500".repeat(40));
+  const hasClientId = !!process.env.ANTIGRAVITY_OAUTH_CLIENT_ID;
+  const hasClientSecret = !!process.env.ANTIGRAVITY_OAUTH_CLIENT_SECRET;
+  if (hasClientId || hasClientSecret) {
+    console.log("  Using custom OAuth credentials:");
+    console.log(`    ANTIGRAVITY_OAUTH_CLIENT_ID: ${hasClientId ? "Set" : "Not set"}`);
+    console.log(`    ANTIGRAVITY_OAUTH_CLIENT_SECRET: ${hasClientSecret ? "Set" : "Not set"}`);
+  } else {
+    console.log("  \u2705 Using built-in OAuth credentials");
+    console.log("  \u{1F4A1} Set ANTIGRAVITY_OAUTH_CLIENT_ID and ANTIGRAVITY_OAUTH_CLIENT_SECRET");
+    console.log("     environment variables to use custom credentials.");
+  }
+  console.log();
+}
+
+// src/commands/accounts.ts
+function listAccountsCommand(options) {
+  const manager = getAccountManager();
+  const summaries = manager.getAccountSummaries();
+  renderAccountsTable(summaries);
+  if (options.refresh) {
+    info("Use `antigravity-usage quota --all --refresh` to fetch fresh quota data.");
+  }
+}
+async function addAccountCommand() {
+  info("Adding a new account...");
+  const result = await startOAuthFlow();
+  if (result.success) {
+    success(`Account added successfully${result.email ? `: ${result.email}` : ""}!`);
+    const manager = getAccountManager();
+    const summaries = manager.getAccountSummaries();
+    console.log("\nYour accounts:");
+    renderAccountsTable(summaries);
+  } else {
+    error(`Failed to add account: ${result.error}`);
+    process.exit(1);
+  }
+}
+function switchAccountCommand(email) {
+  const manager = getAccountManager();
+  if (!manager.hasAccount(email)) {
+    error(`Account '${email}' not found.`);
+    const emails = manager.getAccountEmails();
+    if (emails.length > 0) {
+      console.log("\nAvailable accounts:");
+      for (const e of emails) {
+        console.log(`  - ${e}`);
+      }
+    } else {
+      info("\nNo accounts found. Run `antigravity-usage login` to add one.");
+    }
+    process.exit(1);
+  }
+  const switched = manager.setActiveAccount(email);
+  if (switched) {
+    success(`Switched to account: ${email}`);
+  } else {
+    error(`Failed to switch to account: ${email}`);
+    process.exit(1);
+  }
+}
+function removeAccountCommand(email, options) {
+  const manager = getAccountManager();
+  if (!manager.hasAccount(email)) {
+    error(`Account '${email}' not found.`);
+    process.exit(1);
+  }
+  if (!options.force) {
+    warn(`This will remove account '${email}' and all its data.`);
+    info("Use --force to skip this warning.");
+  }
+  const removed = manager.removeAccount(email);
+  if (removed) {
+    success(`Account '${email}' removed.`);
+    const remaining = manager.getAccountEmails();
+    if (remaining.length > 0) {
+      const active = manager.getActiveEmail();
+      console.log(`
+Active account: ${active || "none"}`);
+      console.log(`Remaining accounts: ${remaining.length}`);
+    } else {
+      info("\nNo accounts remaining. Run `antigravity-usage login` to add one.");
+    }
+  } else {
+    error(`Failed to remove account: ${email}`);
+    process.exit(1);
+  }
+}
+function currentAccountCommand() {
+  const manager = getAccountManager();
+  const active = manager.getActiveEmail();
+  if (active) {
+    console.log();
+    console.log(`\u{1F4CD} Active account: ${active}`);
+    const info2 = manager.getAccountInfo(active);
+    if (info2) {
+      const statusIcon = info2.status === "valid" ? "\u2705" : info2.status === "expired" ? "\u26A0\uFE0F" : "\u274C";
+      console.log(`   Status: ${statusIcon} ${info2.status}`);
+      if (info2.tokens?.expiresAt) {
+        const expiresAt = new Date(info2.tokens.expiresAt).toLocaleString();
+        console.log(`   Token expires: ${expiresAt}`);
+      }
+    }
+    console.log();
+  } else {
+    warn("No active account set.");
+    const emails = manager.getAccountEmails();
+    if (emails.length > 0) {
+      console.log("\nAvailable accounts:");
+      for (const e of emails) {
+        console.log(`  - ${e}`);
+      }
+      info("\nRun `antigravity-usage accounts switch <email>` to set an active account.");
+    } else {
+      info("\nRun `antigravity-usage login` to add an account.");
+    }
+  }
+}
+async function refreshAccountCommand(email, options) {
+  const manager = getAccountManager();
+  if (options.all) {
+    const emails = manager.getAccountEmails();
+    if (emails.length === 0) {
+      warn("No accounts to refresh.");
+      return;
+    }
+    console.log(`
+\u{1F504} Refreshing ${emails.length} account(s)...
+`);
+    let successCount = 0;
+    let failCount = 0;
+    for (const e of emails) {
+      try {
+        const tokenManager = getTokenManagerForAccount(e);
+        if (tokenManager.isTokenExpired()) {
+          await tokenManager.refreshToken();
+          success(`  \u2705 ${e}`);
+          successCount++;
+        } else {
+          info(`  \u23ED\uFE0F  ${e} (token still valid)`);
+          successCount++;
+        }
+      } catch (err) {
+        error(`  \u274C ${e}: ${err instanceof Error ? err.message : "Failed"}`);
+        failCount++;
+      }
+    }
+    resetTokenManager();
+    console.log();
+    if (failCount > 0) {
+      warn(`${failCount} account(s) need re-authentication. Run: antigravity-usage login`);
+    } else {
+      success(`All ${successCount} account(s) refreshed successfully!`);
+    }
+    return;
+  }
+  const targetEmail = email || manager.getActiveEmail();
+  if (!targetEmail) {
+    error("No account specified and no active account.");
+    info("Usage: antigravity-usage accounts refresh <email>");
+    info("   or: antigravity-usage accounts refresh --all");
+    process.exit(1);
+  }
+  if (!manager.hasAccount(targetEmail)) {
+    error(`Account '${targetEmail}' not found.`);
+    process.exit(1);
+  }
+  console.log(`
+\u{1F504} Refreshing ${targetEmail}...`);
+  try {
+    const tokenManager = getTokenManagerForAccount(targetEmail);
+    if (!tokenManager.isTokenExpired()) {
+      info(`Token for ${targetEmail} is still valid.`);
+      return;
+    }
+    await tokenManager.refreshToken();
+    resetTokenManager();
+    success(`
+\u2705 Token refreshed for ${targetEmail}`);
+  } catch (err) {
+    error(`
+\u274C Failed to refresh token: ${err instanceof Error ? err.message : "Unknown error"}`);
+    info("\nThe refresh token may be expired. Please re-authenticate:");
+    info(`  antigravity-usage accounts switch ${targetEmail}`);
+    info("  antigravity-usage login");
+    process.exit(1);
+  }
+}
+async function accountsCommand(subcommand, args, options) {
+  switch (subcommand) {
+    case "list":
+      listAccountsCommand({ refresh: options.refresh });
+      break;
+    case "add":
+      await addAccountCommand();
+      break;
+    case "switch":
+      if (!args[0]) {
+        error("Please specify an account email to switch to.");
+        console.log("Usage: antigravity-usage accounts switch <email>");
+        process.exit(1);
+      }
+      switchAccountCommand(args[0]);
+      break;
+    case "remove":
+      if (!args[0]) {
+        error("Please specify an account email to remove.");
+        console.log("Usage: antigravity-usage accounts remove <email>");
+        process.exit(1);
+      }
+      removeAccountCommand(args[0], { force: options.force });
+      break;
+    case "current":
+      currentAccountCommand();
+      break;
+    case "refresh":
+      await refreshAccountCommand(args[0], { all: options.all });
+      break;
+    default:
+      listAccountsCommand({ refresh: options.refresh });
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("antigravity-usage").description("CLI tool to check Antigravity model quota via Google Cloud Code API").version(version).option("--debug", "Enable debug mode").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.debug) {
+    setDebugMode(true);
+  }
+});
+program.command("login").description("Authenticate with Google (adds a new account)").option("--no-browser", "Do not open browser, print URL instead").option("-p, --port <port>", "Port for OAuth callback server", parseInt).action(loginCommand);
+program.command("logout [email]").description("Remove stored credentials").option("--all", "Logout from all accounts").action((email, options) => logoutCommand(options, email));
+program.command("status").description("Show current authentication status").option("--all", "Show status for all accounts").option("-a, --account <email>", "Show status for specific account").action(statusCommand);
+program.command("quota", { isDefault: true }).description("Fetch and display quota information").option("--json", "Output as JSON").option("-m, --method <method>", "Method to use: auto (default), local, or google", "auto").option("--all", "Show quota for all accounts").option("-a, --account <email>", "Show quota for specific account").option("--refresh", "Force refresh (ignore cache)").action(quotaCommand);
+var accountsCmd = program.command("accounts").description("Manage multiple accounts");
+accountsCmd.command("list").description("List all accounts").option("--refresh", "Show refresh tip").action((options) => accountsCommand("list", [], options));
+accountsCmd.command("add").description("Add a new account (triggers OAuth login)").action(() => accountsCommand("add", [], {}));
+accountsCmd.command("switch <email>").description("Switch to a different account").action((email) => accountsCommand("switch", [email], {}));
+accountsCmd.command("remove <email>").description("Remove an account").option("--force", "Skip confirmation").action((email, options) => accountsCommand("remove", [email], options));
+accountsCmd.command("current").description("Show current active account").action(() => accountsCommand("current", [], {}));
+accountsCmd.command("refresh [email]").description("Refresh account tokens").option("--all", "Refresh all accounts").action((email, options) => accountsCommand("refresh", email ? [email] : [], options));
+accountsCmd.action(() => accountsCommand("list", [], {}));
+program.command("doctor").description("Run diagnostics and show configuration").action(doctorCommand);
+program.parse();
+//# sourceMappingURL=index.js.map