when-does-my-quota-refresh 1.0.1 → 1.2.0

package/dist/sdk/index.js

@@ -421,7 +421,7 @@ var ConnectClient = class {
    * Fetch model configs (last-resort fallback)
    */
   async fetchModelConfigs() {
-    debug("connect-client", "Fetching GetCascadeModelConfigData");
+    debug("connect-client", "Fetching GetCommandModelConfigs");
     try {
       return await this.request("POST", ENDPOINTS.modelConfigs, {
         metadata: {
@@ -568,11 +568,11 @@ var ConnectClient = class {
 };
 
 // src/sources/local/parser.ts
-function parseQuotaSummary(summary, email) {
+function parseQuotaSummary(summary, email, method = "local") {
   debug("parser", `Parsing quota summary: ${summary.groups.length} groups`);
   return {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    method: "local",
+    method,
     email,
     groups: summary.groups.map((g) => ({
       displayName: g.displayName,
@@ -587,11 +587,11 @@ function parseQuotaSummary(summary, email) {
     }))
   };
 }
-function parseUserStatus(userStatus) {
+function parseUserStatus(userStatus, method = "local") {
   debug("parser", "Parsing GetUserStatus fallback");
   const snapshot = {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    method: "local",
+    method,
     email: userStatus.email,
     groups: []
   };
@@ -665,7 +665,7 @@ function isGeminiModel(modelId) {
 }
 function detectAutocomplete(modelId, label) {
   const text = `${modelId} ${label || ""}`.toLowerCase();
-  return text.includes("autocomplete") || text.includes("gemini-2.5") || text.includes("gemini 2.5");
+  return text.includes("autocomplete");
 }
 function clampFraction(value) {
   if (value === void 0 || value === null) return 1;
@@ -839,10 +839,10 @@ var CliSource = class {
         const summary = await client.fetchQuotaSummary();
         if (summary && summary.groups.length > 0) {
           const email = (await client.fetchUserStatus())?.email;
-          return parseQuotaSummary(summary, email);
+          return parseQuotaSummary(summary, email, "cli");
         }
         const userStatus = await client.fetchUserStatus();
-        if (userStatus) return parseUserStatus(userStatus);
+        if (userStatus) return parseUserStatus(userStatus, "cli");
       } catch {
       }
     }
@@ -901,20 +901,25 @@ var OAuthSource = class {
   }
   async fetchQuota() {
     debug("oauth", "Fetching quota via Cloud Code API");
+    let email;
+    try {
+      const userInfo = await this.client.fetchUserInfo();
+      email = userInfo.email;
+    } catch {
+      debug("oauth", "Could not fetch user info for email");
+    }
     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);
+        return parseQuotaSummary(summary, email, "oauth");
       }
       const statusRaw = await this.client.fetchUserStatus();
       const status = this.parseRemoteStatus(statusRaw);
       if (status) {
         debug("oauth", "Got user status via OAuth");
-        return parseUserStatus(status);
+        return parseUserStatus(status, "oauth");
       }
     } catch (err) {
       debug("oauth", `Fetch failed: ${err}`);
@@ -948,13 +953,12 @@ var OAuthSource = class {
    */
   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;
+    const userStatus = data.userStatus || data;
+    return {
+      email: userStatus.email,
+      raw
+    };
   }
 };
 
@@ -988,6 +992,163 @@ var OAUTH_CLIENT_SECRET = "d-FL95Q19q7MQmFpd7hHD0Ty";
 var OAUTH_SCOPES = [
   "https://www.googleapis.com/auth/cloud-platform"
 ].join(" ");
+var OAUTH_REDIRECT_URI = "http://127.0.0.1:0/callback";
+
+// src/sdk/accounts/storage.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2, dirname } 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: [],
+  wakeupMode: "smart",
+  wakeupIntervalHours: 6,
+  wakeupDailyTimes: "9,17",
+  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/accounts/storage.ts
+var TOKENS_DIR = "accounts";
+function getStorePath() {
+  return join2(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();
+  const storePath = getStorePath();
+  mkdirSync2(dirname(storePath), { recursive: true });
+  writeFileSync2(storePath, 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/sources/oauth/client.ts
 var OAuthClient = class {
@@ -998,10 +1159,10 @@ var OAuthClient = class {
   /**
    * Generate the OAuth authorization URL for user login
    */
-  getAuthUrl() {
+  getAuthUrl(redirectUri) {
     const params = new URLSearchParams({
       client_id: OAUTH_CLIENT_ID,
-      redirect_uri: "http://127.0.0.1:0/callback",
+      redirect_uri: redirectUri || OAUTH_REDIRECT_URI,
       response_type: "code",
       scope: OAUTH_SCOPES,
       access_type: "offline",
@@ -1012,12 +1173,12 @@ var OAuthClient = class {
   /**
    * Exchange an authorization code for tokens
    */
-  async exchangeCode(code) {
+  async exchangeCode(code, redirectUri) {
     const body = new URLSearchParams({
       code,
       client_id: OAUTH_CLIENT_ID,
       client_secret: OAUTH_CLIENT_SECRET,
-      redirect_uri: "http://127.0.0.1:0/callback",
+      redirect_uri: redirectUri || OAUTH_REDIRECT_URI,
       grant_type: "authorization_code"
     });
     const response = await this.postUrlEncoded("https://oauth2.googleapis.com/token", body);
@@ -1049,6 +1210,14 @@ var OAuthClient = class {
       accessToken: data.access_token,
       expiresAt: Date.now() + data.expires_in * 1e3
     };
+    if (this.tokens.email) {
+      try {
+        saveAccountTokens(this.tokens.email, this.tokens);
+        debug("oauth", `Persisted refreshed token for ${this.tokens.email}`);
+      } catch (err) {
+        debug("oauth", `Failed to persist refreshed token: ${err}`);
+      }
+    }
     return this.tokens;
   }
   /**
@@ -1094,6 +1263,43 @@ var OAuthClient = class {
       token
     );
   }
+  /**
+   * Fetch the authenticated user's profile (email, name, etc.)
+   */
+  async fetchUserInfo() {
+    const token = await this.getAccessToken();
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: "www.googleapis.com",
+        path: "/oauth2/v3/userinfo",
+        method: "GET",
+        headers: {
+          "Authorization": `Bearer ${token}`
+        },
+        timeout: 1e4
+      };
+      const req = https2.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          try {
+            const info = JSON.parse(data);
+            resolve({ email: info.email, name: info.name });
+          } catch {
+            resolve({});
+          }
+        });
+      });
+      req.on("error", () => resolve({}));
+      req.on("timeout", () => {
+        req.destroy();
+        resolve({});
+      });
+      req.end();
+    });
+  }
   // ── HTTP Helpers ────────────────────────────────────────────────
   authenticatedPost(url, body, token) {
     return new Promise((resolve, reject) => {
@@ -1116,6 +1322,10 @@ var OAuthClient = class {
           responseData += chunk;
         });
         res.on("end", () => {
+          if (res.statusCode && (res.statusCode < 200 || res.statusCode >= 300)) {
+            reject(new Error(`HTTP ${res.statusCode}: ${responseData.slice(0, 200)}`));
+            return;
+          }
           try {
             resolve(JSON.parse(responseData));
           } catch {
@@ -1152,6 +1362,10 @@ var OAuthClient = class {
           responseData += chunk;
         });
         res.on("end", () => {
+          if (res.statusCode && (res.statusCode < 200 || res.statusCode >= 300)) {
+            reject(new Error(`HTTP ${res.statusCode}: ${responseData.slice(0, 200)}`));
+            return;
+          }
           try {
             resolve(JSON.parse(responseData));
           } catch {
@@ -1310,82 +1524,12 @@ var QuotaCache = class {
 
 // 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
+import { join as join3 } from "path";
 var db = null;
 function getDb() {
   if (db) return db;
   ensureDirs();
-  const dbPath = join2(getDataDirPath(), "history.db");
+  const dbPath = join3(getDataDirPath(), "history.db");
   db = new Database(dbPath);
   db.pragma("journal_mode = WAL");
   initSchema(db);
@@ -1522,101 +1666,20 @@ function closeStore() {
   }
 }
 
-// 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");
+  let capturedRedirectUri = "http://127.0.0.1:0/callback";
   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.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
         res.end(`
           <html><body style="font-family: sans-serif; text-align: center; padding: 50px;">
             <h1>\u2705 Login successful!</h1>
@@ -1628,7 +1691,7 @@ async function loginAccount() {
       } else {
         const error = url.searchParams.get("error");
         if (error) {
-          res.writeHead(400, { "Content-Type": "text/html" });
+          res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
           res.end(`<h1>Login failed: ${error}</h1>`);
           server.close();
           reject(new AuthError(`OAuth error: ${error}`));
@@ -1641,7 +1704,9 @@ async function loginAccount() {
     server.listen(0, "127.0.0.1", () => {
       const addr = server.address();
       if (typeof addr === "object" && addr) {
+        capturedRedirectUri = `http://127.0.0.1:${addr.port}/callback`;
         debug("auth", `Callback server on port ${addr.port}`);
+        const authUrl = client.getAuthUrl(capturedRedirectUri);
         open(authUrl).catch(() => {
           console.log(`
 Open this URL in your browser:
@@ -1656,8 +1721,19 @@ ${authUrl}
       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";
+  const tokens = await client.exchangeCode(code, capturedRedirectUri);
+  let email = tokens.email;
+  if (!email) {
+    try {
+      const userInfo = await client.fetchUserInfo();
+      email = userInfo.email;
+    } catch (err) {
+      debug("auth", `Failed to fetch user info: ${err}`);
+    }
+  }
+  if (!email) {
+    throw new AuthError("Could not determine user email from Google account");
+  }
   tokens.email = email;
   saveAccountTokens(email, tokens);
   setActiveAccount(email);
@@ -1665,17 +1741,160 @@ ${authUrl}
   return email;
 }
 
+// src/plugins/builtin/notifications.ts
+var NotificationPlugin = class {
+  name = "notifications";
+  version = "1.0.0";
+  notifier = null;
+  notifiedLow = /* @__PURE__ */ new Set();
+  async onInit(ctx) {
+    try {
+      const { default: notifier } = await import("node-notifier");
+      this.notifier = notifier;
+      debug("notifications", "Notification plugin initialized");
+    } catch {
+      debug("notifications", "node-notifier not available, notifications disabled");
+    }
+  }
+  async onQuotaUpdate(snapshot, ctx) {
+    for (const group of snapshot.groups) {
+      for (const bucket of group.buckets) {
+        if (bucket.remainingFraction > 0.8) {
+          this.notifiedLow.delete(`${group.displayName}:${bucket.displayName}`);
+        }
+      }
+    }
+  }
+  async onQuotaLow(group, bucket, remaining, ctx) {
+    const key = `${group}:${bucket}`;
+    if (this.notifiedLow.has(key)) return;
+    const pct = Math.round(remaining * 100);
+    const title = "when-does-my-quota-refresh";
+    const message = `\u26A0\uFE0F Low quota: ${group} \u2014 ${bucket} at ${pct}%`;
+    ctx.log(message);
+    this.notify(title, message);
+    this.notifiedLow.add(key);
+  }
+  async onReset(group, nextReset, ctx) {
+    const title = "when-does-my-quota-refresh";
+    const message = `\u2705 ${group} quota has reset!`;
+    ctx.log(message);
+    this.notify(title, message);
+  }
+  notify(title, message) {
+    if (!this.notifier) return;
+    try {
+      this.notifier.notify({ title, message, timeout: 5 });
+    } catch (err) {
+      debug("notifications", `Notification failed: ${err}`);
+    }
+  }
+};
+
+// src/plugins/index.ts
+var PluginRegistry = class {
+  plugins = [];
+  context;
+  constructor(context) {
+    this.context = {
+      notify: context?.notify || (() => {
+      }),
+      log: context?.log || ((msg) => console.log(msg))
+    };
+  }
+  /**
+   * Register a plugin
+   */
+  async register(plugin) {
+    this.plugins.push(plugin);
+    if (plugin.onInit) {
+      await plugin.onInit(this.context);
+    }
+    debug("plugins", `Registered: ${plugin.name}@${plugin.version}`);
+  }
+  /**
+   * Load built-in plugins
+   */
+  async loadBuiltins() {
+    await this.register(new NotificationPlugin());
+  }
+  /**
+   * Notify all plugins of a quota update
+   */
+  async notifyQuotaUpdate(snapshot) {
+    for (const plugin of this.plugins) {
+      if (plugin.onQuotaUpdate) {
+        try {
+          await plugin.onQuotaUpdate(snapshot, this.context);
+        } catch (err) {
+          debug("plugins", `Error in ${plugin.name}.onQuotaUpdate: ${err}`);
+        }
+      }
+    }
+    for (const group of snapshot.groups) {
+      for (const bucket of group.buckets) {
+        if (bucket.remainingFraction < 0.15) {
+          await this.notifyQuotaLow(group.displayName, bucket.displayName, bucket.remainingFraction);
+        }
+      }
+    }
+  }
+  /**
+   * Notify all plugins of low quota
+   */
+  async notifyQuotaLow(group, bucket, remaining) {
+    for (const plugin of this.plugins) {
+      if (plugin.onQuotaLow) {
+        try {
+          await plugin.onQuotaLow(group, bucket, remaining, this.context);
+        } catch (err) {
+          debug("plugins", `Error in ${plugin.name}.onQuotaLow: ${err}`);
+        }
+      }
+    }
+  }
+  /**
+   * Destroy all plugins
+   */
+  async destroy() {
+    for (const plugin of this.plugins) {
+      if (plugin.onDestroy) {
+        try {
+          await plugin.onDestroy();
+        } catch (err) {
+          debug("plugins", `Error in ${plugin.name}.onDestroy: ${err}`);
+        }
+      }
+    }
+    this.plugins = [];
+  }
+  /**
+   * Get registered plugin names
+   */
+  getNames() {
+    return this.plugins.map((p) => p.name);
+  }
+};
+
 // src/sdk/quota.ts
 var QuotaClient = class {
   registry;
   cache;
+  plugins;
   verbose;
   constructor(options) {
     this.verbose = options?.verbose || false;
-    setVerbose(this.verbose);
+    if (options?.verbose !== void 0) {
+      setVerbose(this.verbose);
+    }
     const config = loadConfig();
     this.registry = new SourceRegistry();
     this.cache = new QuotaCache(options?.cacheTtlMs || config.cacheTtlMs);
+    this.plugins = new PluginRegistry();
+    if (config.notifications) {
+      this.plugins.loadBuiltins().catch(() => {
+      });
+    }
     this.registerOAuthSources();
   }
   /**
@@ -1686,11 +1905,19 @@ var QuotaClient = class {
       return this.fetchAllAccounts(options);
     }
     if (!options?.refresh) {
+      const tokens = getAllAccountTokens();
+      for (const token of tokens) {
+        if (!token.email) continue;
+        const cached = this.cache.get(token.email, options?.source || "auto");
+        if (cached) return cached;
+      }
     }
     const snapshot = await this.registry.fetchQuota(options?.source);
-    if (snapshot.email) {
+    if (snapshot.email && snapshot.email !== "unknown") {
       this.cache.set(snapshot.email, snapshot.method, snapshot);
       storeSnapshot(snapshot);
+      this.plugins.notifyQuotaUpdate(snapshot).catch(() => {
+      });
     }
     return snapshot;
   }