opencode-usage-plugin 0.0.2-dev4 → 0.0.2-dev5

package/dist/index.js

@@ -1,671 +1,991 @@
-// src/index.ts
-import { tool } from "@opencode-ai/plugin";
-
-// src/providers/common/logger.ts
-var maskSecret = (secret) => {
-  if (!secret || typeof secret !== "string" || secret.length <= 8) {
-    return "***";
-  }
-  return `${secret.slice(0, 4)}...${secret.slice(-4)}`;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var noOpLogger = {
-  debug: async () => {
-  },
-  info: async () => {
-  },
-  warn: async () => {
-  },
-  error: async () => {
-  }
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var createLogger = (client) => {
-  const service = "opencode-usage";
-  return {
-    debug: async (message, extra) => {
-      await client.app.log({
-        service,
-        level: "debug",
-        message,
-        ...extra ?? {}
-      });
-    },
-    info: async (message, extra) => {
-      await client.app.log({
-        service,
-        level: "info",
-        message,
-        ...extra ?? {}
-      });
-    },
-    warn: async (message, extra) => {
-      await client.app.log({
-        service,
-        level: "warn",
-        message,
-        ...extra ?? {}
-      });
-    },
-    error: async (message, extra) => {
-      await client.app.log({
-        service,
-        level: "error",
-        message,
-        ...extra ?? {}
-      });
-    }
-  };
-};
-var noopLogger = noOpLogger;
 
-// src/providers/common/time.ts
-var calculateResetAfterSeconds = (resetAt, now = Date.now()) => {
-  if (!resetAt) {
-    return null;
-  }
-  const diffMs = resetAt - now;
-  if (diffMs <= 0) {
-    return 0;
+// src/providers/common/logger.ts
+var logger_exports = {};
+__export(logger_exports, {
+  createLogger: () => createLogger,
+  maskSecret: () => maskSecret,
+  noopLogger: () => noopLogger
+});
+var maskSecret, noOpLogger, createLogger, noopLogger;
+var init_logger = __esm({
+  "src/providers/common/logger.ts"() {
+    "use strict";
+    maskSecret = (secret) => {
+      if (!secret || typeof secret !== "string" || secret.length <= 8) {
+        return "***";
+      }
+      return `${secret.slice(0, 4)}...${secret.slice(-4)}`;
+    };
+    noOpLogger = {
+      debug: async () => {
+      },
+      info: async () => {
+      },
+      warn: async () => {
+      },
+      error: async () => {
+      }
+    };
+    createLogger = (client) => {
+      const service = "opencode-usage";
+      return {
+        debug: async (message, extra) => {
+          await client.app.log({
+            service,
+            level: "debug",
+            message,
+            ...extra ?? {}
+          });
+        },
+        info: async (message, extra) => {
+          await client.app.log({
+            service,
+            level: "info",
+            message,
+            ...extra ?? {}
+          });
+        },
+        warn: async (message, extra) => {
+          await client.app.log({
+            service,
+            level: "warn",
+            message,
+            ...extra ?? {}
+          });
+        },
+        error: async (message, extra) => {
+          await client.app.log({
+            service,
+            level: "error",
+            message,
+            ...extra ?? {}
+          });
+        }
+      };
+    };
+    noopLogger = noOpLogger;
   }
-  return Math.floor(diffMs / 1e3);
-};
-var formatDuration = (seconds) => {
-  if (seconds <= 0) {
-    return "0s";
-  }
-  const weeks = Math.floor(seconds / 604800);
-  const days = Math.floor(seconds % 604800 / 86400);
-  const hours = Math.floor(seconds % 86400 / 3600);
-  const minutes = Math.floor(seconds % 3600 / 60);
-  const secs = seconds % 60;
-  const parts = [];
-  if (weeks > 0) parts.push(`${weeks}w`);
-  if (days > 0) parts.push(`${days}d`);
-  if (hours > 0) parts.push(`${hours}h`);
-  if (minutes > 0) parts.push(`${minutes}m`);
-  if (secs > 0 || parts.length === 0) parts.push(`${secs}s`);
-  return parts.join(" ");
-};
-var formatResetAt = (resetAtMs) => {
-  return new Date(resetAtMs).toLocaleString(void 0, {
-    weekday: "long",
-    year: "numeric",
-    month: "long",
-    day: "numeric",
-    hour: "numeric",
-    minute: "numeric",
-    second: "numeric",
-    timeZoneName: "short"
-  });
-};
+});
 
 // src/providers/common/files.ts
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
-var xdgDataHome = () => process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
-var xdgConfigHome = () => process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
-var AUTH_PATHS = {
-  opencode: () => join(xdgDataHome(), "opencode", "auth.json"),
-  openaiPlugin: () => join(homedir(), ".opencode", "auth", "openai.json"),
-  antigravityConfig: () => join(xdgConfigHome(), "opencode", "antigravity-accounts.json"),
-  antigravityData: () => join(xdgDataHome(), "opencode", "antigravity-accounts.json")
-};
-var readJson = async (filePath, logger) => {
-  try {
-    const content = await readFile(filePath, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    if (logger) {
-      const message = error instanceof Error ? error.message : String(error);
-      await logger.debug(`Auth file not found or invalid: ${filePath}`, { error: message });
-    }
-    return null;
+var xdgDataHome, xdgConfigHome, xdgCacheHome, AUTH_PATHS, readJson, loadOpenCodeAuth;
+var init_files = __esm({
+  "src/providers/common/files.ts"() {
+    "use strict";
+    xdgDataHome = () => process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+    xdgConfigHome = () => process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
+    xdgCacheHome = () => process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
+    AUTH_PATHS = {
+      opencode: () => join(xdgDataHome(), "opencode", "auth.json"),
+      openaiPlugin: () => join(homedir(), ".opencode", "auth", "openai.json"),
+      antigravityConfig: () => join(xdgConfigHome(), "opencode", "antigravity-accounts.json"),
+      antigravityData: () => join(xdgDataHome(), "opencode", "antigravity-accounts.json")
+    };
+    readJson = async (filePath, logger) => {
+      try {
+        const content = await readFile(filePath, "utf-8");
+        return JSON.parse(content);
+      } catch (error) {
+        if (logger) {
+          const message = error instanceof Error ? error.message : String(error);
+          await logger.debug(`Auth file not found or invalid: ${filePath}`, { error: message });
+        }
+        return null;
+      }
+    };
+    loadOpenCodeAuth = async (logger) => {
+      return readJson(AUTH_PATHS.opencode(), logger);
+    };
   }
-};
-var loadOpenCodeAuth = async (logger) => {
-  return readJson(AUTH_PATHS.opencode(), logger);
-};
-
-// src/providers/common/registry.ts
-var PROVIDER_ALIASES = {
-  openai: ["openai", "codex", "chatgpt"],
-  google: ["google", "antigravity"],
-  "zai-coding-plan": ["zai-coding-plan", "zai", "z.ai"]
-};
-var getProviderAliases = (provider) => {
-  return PROVIDER_ALIASES[provider];
-};
+});
 
-// src/providers/google/auth.ts
-var toAuthData = (entry) => {
-  if (!entry) {
-    return null;
-  }
-  if (typeof entry === "string") {
-    return { token: entry };
-  }
-  if (typeof entry === "object") {
-    return entry;
-  }
-  return null;
-};
-var loadOpenCodeAuthEntry = async (logger) => {
-  const auth = await loadOpenCodeAuth(logger);
-  if (!auth) {
-    return null;
-  }
-  for (const alias of getProviderAliases("google")) {
-    const entry = toAuthData(auth[alias]);
-    if (entry) {
-      return entry;
-    }
-  }
-  return null;
-};
-var toAuthContext = (entry) => {
-  if (!entry) {
-    return null;
-  }
-  const accessToken = entry.access ?? entry.token;
-  let refreshToken = entry.refresh;
-  let projectId = void 0;
-  if (refreshToken && refreshToken.includes("|")) {
-    const parts = refreshToken.split("|");
-    refreshToken = parts[0];
-    projectId = parts[1];
-  }
-  if (!accessToken && !refreshToken) {
-    return null;
-  }
-  return {
-    accessToken,
-    refreshToken,
-    expires: entry.expires,
-    projectId
-  };
-};
-var selectAccount = (accounts) => {
-  if (!accounts?.accounts?.length) {
-    return null;
+// src/cache/file.ts
+import { mkdir, readFile as readFile2, rename, unlink, writeFile } from "node:fs/promises";
+var CACHE_DIR, CACHE_PATH, TMP_PATH, ensureCacheDir, readCache, writeCache;
+var init_file = __esm({
+  "src/cache/file.ts"() {
+    "use strict";
+    init_files();
+    CACHE_DIR = () => `${xdgCacheHome()}/opencode/opencode-usage-plugin`;
+    CACHE_PATH = () => `${CACHE_DIR()}/usage.json`;
+    TMP_PATH = () => `${CACHE_PATH()}.tmp`;
+    ensureCacheDir = async () => {
+      try {
+        await mkdir(CACHE_DIR(), { recursive: true });
+      } catch (error) {
+        if (error instanceof Error && "code" in error && error.code !== "EEXIST") {
+          throw error;
+        }
+      }
+    };
+    readCache = async (logger) => {
+      try {
+        const content = await readFile2(CACHE_PATH(), "utf-8");
+        const parsed = JSON.parse(content);
+        if (typeof parsed === "object" && parsed !== null && "schema_version" in parsed && "updated_at" in parsed && "refresh_interval_seconds" in parsed && "providers" in parsed) {
+          return parsed;
+        }
+        await logger?.warn("Invalid cache schema, returning null");
+        return null;
+      } catch (error) {
+        if (logger) {
+          const message = error instanceof Error ? error.message : String(error);
+          await logger.debug("Cache file not found or invalid", { error: message });
+        }
+        return null;
+      }
+    };
+    writeCache = async (cache, logger) => {
+      try {
+        await ensureCacheDir();
+        const content = JSON.stringify(cache, null, 2);
+        await writeFile(TMP_PATH(), content, "utf-8");
+        await rename(TMP_PATH(), CACHE_PATH());
+        await logger?.debug("Cache written successfully", { path: CACHE_PATH() });
+      } catch (error) {
+        await logger?.error("Failed to write cache", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+      }
+    };
   }
-  const candidateIndex = accounts.activeIndex ?? 0;
-  const account = accounts.accounts[candidateIndex] ?? accounts.accounts[0];
-  return account ?? null;
-};
-var loadAuthFromAccounts = async (logger) => {
-  const configAccounts = await readJson(
-    AUTH_PATHS.antigravityConfig(),
-    logger
-  );
-  const account = selectAccount(configAccounts);
-  if (account) {
-    return {
-      refreshToken: account.refreshToken,
-      projectId: account.projectId ?? account.managedProjectId,
-      email: account.email
+});
+
+// src/cache/types.ts
+var SCHEMA_VERSION, REFRESH_INTERVAL_SECONDS, STALE_THRESHOLD_MULTIPLIER;
+var init_types = __esm({
+  "src/cache/types.ts"() {
+    "use strict";
+    SCHEMA_VERSION = 1;
+    REFRESH_INTERVAL_SECONDS = 300;
+    STALE_THRESHOLD_MULTIPLIER = 2;
+  }
+});
+
+// src/cache/reader.ts
+var reader_exports = {};
+__export(reader_exports, {
+  loadCacheForDisplay: () => loadCacheForDisplay
+});
+var loadCacheForDisplay;
+var init_reader = __esm({
+  "src/cache/reader.ts"() {
+    "use strict";
+    init_file();
+    init_types();
+    loadCacheForDisplay = async (logger) => {
+      const cache = await readCache(logger);
+      if (!cache) {
+        await logger.warn("No cache available");
+        return null;
+      }
+      const updatedAt = new Date(cache.updated_at);
+      const now = /* @__PURE__ */ new Date();
+      const staleThresholdMs = REFRESH_INTERVAL_SECONDS * 1e3 * STALE_THRESHOLD_MULTIPLIER;
+      const isStale = now.getTime() - updatedAt.getTime() > staleThresholdMs;
+      if (isStale) {
+        await logger.debug("Cache is stale", {
+          updatedAt: cache.updated_at,
+          staleThresholdSeconds: REFRESH_INTERVAL_SECONDS * STALE_THRESHOLD_MULTIPLIER
+        });
+      }
+      const configuredProviders = {};
+      for (const [providerId, entry] of Object.entries(cache.providers)) {
+        if (entry.configured) {
+          configuredProviders[providerId] = entry;
+        }
+      }
+      return {
+        providers: configuredProviders,
+        updatedAt: cache.updated_at,
+        isStale
+      };
     };
   }
-  const dataAccounts = await readJson(
-    AUTH_PATHS.antigravityData(),
-    logger
-  );
-  const fallbackAccount = selectAccount(dataAccounts);
-  if (!fallbackAccount) {
-    return null;
+});
+
+// src/providers/common/time.ts
+var calculateResetAfterSeconds, formatDuration, formatResetAt;
+var init_time = __esm({
+  "src/providers/common/time.ts"() {
+    "use strict";
+    calculateResetAfterSeconds = (resetAt, now = Date.now()) => {
+      if (!resetAt) {
+        return null;
+      }
+      const diffMs = resetAt - now;
+      if (diffMs <= 0) {
+        return 0;
+      }
+      return Math.floor(diffMs / 1e3);
+    };
+    formatDuration = (seconds) => {
+      if (seconds <= 0) {
+        return "0s";
+      }
+      const weeks = Math.floor(seconds / 604800);
+      const days = Math.floor(seconds % 604800 / 86400);
+      const hours = Math.floor(seconds % 86400 / 3600);
+      const minutes = Math.floor(seconds % 3600 / 60);
+      const secs = seconds % 60;
+      const parts = [];
+      if (weeks > 0) parts.push(`${weeks}w`);
+      if (days > 0) parts.push(`${days}d`);
+      if (hours > 0) parts.push(`${hours}h`);
+      if (minutes > 0) parts.push(`${minutes}m`);
+      if (secs > 0 || parts.length === 0) parts.push(`${secs}s`);
+      return parts.join(" ");
+    };
+    formatResetAt = (resetAtMs) => {
+      return new Date(resetAtMs).toLocaleString(void 0, {
+        weekday: "long",
+        year: "numeric",
+        month: "long",
+        day: "numeric",
+        hour: "numeric",
+        minute: "numeric",
+        second: "numeric",
+        timeZoneName: "short"
+      });
+    };
   }
-  return {
-    refreshToken: fallbackAccount.refreshToken,
-    projectId: fallbackAccount.projectId ?? fallbackAccount.managedProjectId,
-    email: fallbackAccount.email
-  };
-};
-var getGoogleAuth = async (logger) => {
-  const openCodeAuth = await loadOpenCodeAuthEntry(logger);
-  const authContext = toAuthContext(openCodeAuth);
-  if (authContext) {
-    return authContext;
+});
+
+// src/providers/common/registry.ts
+var PROVIDER_ALIASES, getProviderAliases;
+var init_registry = __esm({
+  "src/providers/common/registry.ts"() {
+    "use strict";
+    PROVIDER_ALIASES = {
+      openai: ["openai", "codex", "chatgpt"],
+      google: ["google", "antigravity"],
+      "zai-coding-plan": ["zai-coding-plan", "zai", "z.ai"]
+    };
+    getProviderAliases = (provider) => {
+      return PROVIDER_ALIASES[provider];
+    };
   }
-  return loadAuthFromAccounts(logger);
-};
+});
 
-// src/providers/google/fetch.ts
-var GOOGLE_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
-var GOOGLE_CLIENT_SECRET = "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";
-var DEFAULT_PROJECT_ID = "rising-fact-p41fc";
-var WINDOW_SECONDS = 5 * 60 * 60;
-var ENDPOINTS = [
-  "https://daily-cloudcode-pa.sandbox.googleapis.com",
-  "https://autopush-cloudcode-pa.sandbox.googleapis.com",
-  "https://cloudcode-pa.googleapis.com"
-];
-var HEADERS = {
-  "User-Agent": "antigravity/1.11.5 windows/amd64",
-  "X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1",
-  "Client-Metadata": '{"ideType":"IDE_UNSPECIFIED","platform":"PLATFORM_UNSPECIFIED","pluginType":"GEMINI"}'
-};
-var refreshAccessToken = async (refreshToken, logger) => {
-  try {
-    const response = await fetch("https://oauth2.googleapis.com/token", {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body: new URLSearchParams({
-        client_id: GOOGLE_CLIENT_ID,
-        client_secret: GOOGLE_CLIENT_SECRET,
-        refresh_token: refreshToken,
-        grant_type: "refresh_token"
-      })
-    });
-    if (!response.ok) {
-      await logger.warn("Failed to refresh OAuth token for google", {
-        status: response.status,
-        token: maskSecret(refreshToken)
-      });
+// src/providers/google/auth.ts
+var toAuthData, loadOpenCodeAuthEntry, toAuthContext, selectAccount, loadAuthFromAccounts, getGoogleAuth;
+var init_auth = __esm({
+  "src/providers/google/auth.ts"() {
+    "use strict";
+    init_files();
+    init_registry();
+    toAuthData = (entry) => {
+      if (!entry) {
+        return null;
+      }
+      if (typeof entry === "string") {
+        return { token: entry };
+      }
+      if (typeof entry === "object") {
+        return entry;
+      }
       return null;
-    }
-    return await response.json();
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    await logger.warn(`Token refresh failed for google: ${message}`);
-    return null;
+    };
+    loadOpenCodeAuthEntry = async (logger) => {
+      const auth = await loadOpenCodeAuth(logger);
+      if (!auth) {
+        return null;
+      }
+      for (const alias of getProviderAliases("google")) {
+        const entry = toAuthData(auth[alias]);
+        if (entry) {
+          return entry;
+        }
+      }
+      return null;
+    };
+    toAuthContext = (entry) => {
+      if (!entry) {
+        return null;
+      }
+      const accessToken = entry.access ?? entry.token;
+      let refreshToken = entry.refresh;
+      let projectId = void 0;
+      if (refreshToken && refreshToken.includes("|")) {
+        const parts = refreshToken.split("|");
+        refreshToken = parts[0];
+        projectId = parts[1];
+      }
+      if (!accessToken && !refreshToken) {
+        return null;
+      }
+      return {
+        accessToken,
+        refreshToken,
+        expires: entry.expires,
+        projectId
+      };
+    };
+    selectAccount = (accounts) => {
+      if (!accounts?.accounts?.length) {
+        return null;
+      }
+      const candidateIndex = accounts.activeIndex ?? 0;
+      const account = accounts.accounts[candidateIndex] ?? accounts.accounts[0];
+      return account ?? null;
+    };
+    loadAuthFromAccounts = async (logger) => {
+      const configAccounts = await readJson(
+        AUTH_PATHS.antigravityConfig(),
+        logger
+      );
+      const account = selectAccount(configAccounts);
+      if (account) {
+        return {
+          refreshToken: account.refreshToken,
+          projectId: account.projectId ?? account.managedProjectId,
+          email: account.email
+        };
+      }
+      const dataAccounts = await readJson(
+        AUTH_PATHS.antigravityData(),
+        logger
+      );
+      const fallbackAccount = selectAccount(dataAccounts);
+      if (!fallbackAccount) {
+        return null;
+      }
+      return {
+        refreshToken: fallbackAccount.refreshToken,
+        projectId: fallbackAccount.projectId ?? fallbackAccount.managedProjectId,
+        email: fallbackAccount.email
+      };
+    };
+    getGoogleAuth = async (logger) => {
+      const openCodeAuth = await loadOpenCodeAuthEntry(logger);
+      const authContext = toAuthContext(openCodeAuth);
+      if (authContext) {
+        return authContext;
+      }
+      return loadAuthFromAccounts(logger);
+    };
   }
-};
-var fetchModels = async (accessToken, projectId, logger) => {
-  const body = projectId ? { project: projectId } : {};
-  for (const endpoint of ENDPOINTS) {
-    try {
-      const response = await fetch(`${endpoint}/v1internal:fetchAvailableModels`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "Content-Type": "application/json",
-          ...HEADERS
-        },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(15e3)
-      });
-      if (response.ok) {
-        await logger.debug(`Fetched models from ${endpoint}`, { projectId });
+});
+
+// src/providers/google/fetch.ts
+var GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET, DEFAULT_PROJECT_ID, WINDOW_SECONDS, ENDPOINTS, HEADERS, refreshAccessToken, fetchModels, toWindow, buildUsage, resolveAccessToken, fetchGoogleUsage;
+var init_fetch = __esm({
+  "src/providers/google/fetch.ts"() {
+    "use strict";
+    init_logger();
+    init_time();
+    init_auth();
+    GOOGLE_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
+    GOOGLE_CLIENT_SECRET = "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";
+    DEFAULT_PROJECT_ID = "rising-fact-p41fc";
+    WINDOW_SECONDS = 5 * 60 * 60;
+    ENDPOINTS = [
+      "https://daily-cloudcode-pa.sandbox.googleapis.com",
+      "https://autopush-cloudcode-pa.sandbox.googleapis.com",
+      "https://cloudcode-pa.googleapis.com"
+    ];
+    HEADERS = {
+      "User-Agent": "antigravity/1.11.5 windows/amd64",
+      "X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1",
+      "Client-Metadata": '{"ideType":"IDE_UNSPECIFIED","platform":"PLATFORM_UNSPECIFIED","pluginType":"GEMINI"}'
+    };
+    refreshAccessToken = async (refreshToken, logger) => {
+      try {
+        const response = await fetch("https://oauth2.googleapis.com/token", {
+          method: "POST",
+          headers: { "Content-Type": "application/x-www-form-urlencoded" },
+          body: new URLSearchParams({
+            client_id: GOOGLE_CLIENT_ID,
+            client_secret: GOOGLE_CLIENT_SECRET,
+            refresh_token: refreshToken,
+            grant_type: "refresh_token"
+          })
+        });
+        if (!response.ok) {
+          await logger.warn("Failed to refresh OAuth token for google", {
+            status: response.status,
+            token: maskSecret(refreshToken)
+          });
+          return null;
+        }
         return await response.json();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await logger.warn(`Token refresh failed for google: ${message}`);
+        return null;
       }
-    } catch {
-      continue;
-    }
-  }
-  await logger.error("Failed to fetch models from all google endpoints", { projectId });
-  return null;
-};
-var toWindow = (remainingFraction, resetTime) => {
-  const remainingPercent = remainingFraction !== void 0 ? Math.round(remainingFraction * 100) : null;
-  const usedPercent = remainingPercent !== null ? Math.max(0, 100 - remainingPercent) : null;
-  const resetAt = resetTime ? new Date(resetTime).getTime() : null;
-  const resetAfterSeconds = calculateResetAfterSeconds(resetAt);
-  return {
-    usedPercent,
-    remainingPercent,
-    windowSeconds: WINDOW_SECONDS,
-    resetAfterSeconds,
-    resetAt,
-    resetAtFormatted: resetAt ? formatResetAt(resetAt) : null,
-    resetAfterFormatted: resetAfterSeconds !== null ? formatDuration(resetAfterSeconds) : null
-  };
-};
-var buildUsage = (data) => {
-  const models = {};
-  for (const [modelName, modelData] of Object.entries(data.models ?? {})) {
-    const window = toWindow(modelData.quotaInfo?.remainingFraction, modelData.quotaInfo?.resetTime);
-    models[modelName] = {
-      windows: {
-        "5h": window
+    };
+    fetchModels = async (accessToken, projectId, logger) => {
+      const body = projectId ? { project: projectId } : {};
+      for (const endpoint of ENDPOINTS) {
+        try {
+          const response = await fetch(`${endpoint}/v1internal:fetchAvailableModels`, {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${accessToken}`,
+              "Content-Type": "application/json",
+              ...HEADERS
+            },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(15e3)
+          });
+          if (response.ok) {
+            await logger.debug(`Fetched models from ${endpoint}`, { projectId });
+            return await response.json();
+          }
+        } catch {
+          continue;
+        }
       }
+      await logger.error("Failed to fetch models from all google endpoints", { projectId });
+      return null;
     };
-  }
-  return {
-    windows: {},
-    models: Object.keys(models).length ? models : void 0
-  };
-};
-var resolveAccessToken = async (refreshToken, accessToken, expires, logger) => {
-  const now = Date.now();
-  if (accessToken && (!expires || expires > now)) {
-    return accessToken;
-  }
-  if (!refreshToken) {
-    return null;
-  }
-  const refreshed = await refreshAccessToken(refreshToken, logger);
-  return refreshed?.access_token ?? null;
-};
-var fetchGoogleUsage = async (logger = noopLogger) => {
-  const auth = await getGoogleAuth(logger);
-  if (!auth) {
-    await logger.warn("No auth configured for google");
-    return {
-      provider: "google",
-      ok: false,
-      configured: false,
-      error: "Not configured - no accounts found",
-      usage: null
-    };
-  }
-  const accessToken = await resolveAccessToken(
-    auth.refreshToken,
-    auth.accessToken,
-    auth.expires,
-    logger
-  );
-  if (!accessToken) {
-    await logger.warn("Failed to refresh OAuth token for google", { email: auth.email });
-    return {
-      provider: "google",
-      ok: false,
-      configured: true,
-      error: "Failed to refresh OAuth token",
-      usage: null
+    toWindow = (remainingFraction, resetTime) => {
+      const remainingPercent = remainingFraction !== void 0 ? Math.round(remainingFraction * 100) : null;
+      const usedPercent = remainingPercent !== null ? Math.max(0, 100 - remainingPercent) : null;
+      const resetAt = resetTime ? new Date(resetTime).getTime() : null;
+      const resetAfterSeconds = calculateResetAfterSeconds(resetAt);
+      return {
+        usedPercent,
+        remainingPercent,
+        windowSeconds: WINDOW_SECONDS,
+        resetAfterSeconds,
+        resetAt,
+        resetAtFormatted: resetAt ? formatResetAt(resetAt) : null,
+        resetAfterFormatted: resetAfterSeconds !== null ? formatDuration(resetAfterSeconds) : null
+      };
     };
-  }
-  const projectId = auth.projectId ?? DEFAULT_PROJECT_ID;
-  const modelsData = await fetchModels(accessToken, projectId, logger);
-  if (!modelsData) {
-    await logger.error("Failed to fetch models from google API", { projectId });
-    return {
-      provider: "google",
-      ok: false,
-      configured: true,
-      error: "Failed to fetch models from API",
-      usage: null
+    buildUsage = (data) => {
+      const models = {};
+      for (const [modelName, modelData] of Object.entries(data.models ?? {})) {
+        const window = toWindow(modelData.quotaInfo?.remainingFraction, modelData.quotaInfo?.resetTime);
+        models[modelName] = {
+          windows: {
+            "5h": window
+          }
+        };
+      }
+      return {
+        windows: {},
+        models: Object.keys(models).length ? models : void 0
+      };
+    };
+    resolveAccessToken = async (refreshToken, accessToken, expires, logger) => {
+      const now = Date.now();
+      if (accessToken && (!expires || expires > now)) {
+        return accessToken;
+      }
+      if (!refreshToken) {
+        return null;
+      }
+      const refreshed = await refreshAccessToken(refreshToken, logger);
+      return refreshed?.access_token ?? null;
+    };
+    fetchGoogleUsage = async (logger = noopLogger) => {
+      const auth = await getGoogleAuth(logger);
+      if (!auth) {
+        await logger.warn("No auth configured for google");
+        return {
+          provider: "google",
+          ok: false,
+          configured: false,
+          error: "Not configured - no accounts found",
+          usage: null
+        };
+      }
+      const accessToken = await resolveAccessToken(
+        auth.refreshToken,
+        auth.accessToken,
+        auth.expires,
+        logger
+      );
+      if (!accessToken) {
+        await logger.warn("Failed to refresh OAuth token for google", { email: auth.email });
+        return {
+          provider: "google",
+          ok: false,
+          configured: true,
+          error: "Failed to refresh OAuth token",
+          usage: null
+        };
+      }
+      const projectId = auth.projectId ?? DEFAULT_PROJECT_ID;
+      const modelsData = await fetchModels(accessToken, projectId, logger);
+      if (!modelsData) {
+        await logger.error("Failed to fetch models from google API", { projectId });
+        return {
+          provider: "google",
+          ok: false,
+          configured: true,
+          error: "Failed to fetch models from API",
+          usage: null
+        };
+      }
+      await logger.info("google usage fetched successfully");
+      return {
+        provider: "google",
+        ok: true,
+        configured: true,
+        usage: buildUsage(modelsData)
+      };
     };
   }
-  await logger.info("google usage fetched successfully");
-  return {
-    provider: "google",
-    ok: true,
-    configured: true,
-    usage: buildUsage(modelsData)
-  };
-};
+});
 
 // src/providers/openai/auth.ts
-var toAuthData2 = (entry) => {
-  if (!entry) {
-    return null;
-  }
-  if (typeof entry === "string") {
-    return { token: entry };
-  }
-  if (typeof entry === "object") {
-    return entry;
-  }
-  return null;
-};
-var hasAccessToken = (auth) => {
-  return Boolean(auth?.access || auth?.token);
-};
-var loadOpenCodeAuthEntry2 = async (logger) => {
-  const auth = await loadOpenCodeAuth(logger);
-  if (!auth) {
-    return null;
-  }
-  for (const alias of getProviderAliases("openai")) {
-    const entry = toAuthData2(auth[alias]);
-    if (entry && hasAccessToken(entry)) {
-      return entry;
-    }
-  }
-  return null;
-};
-var getOpenaiAuth = async (logger) => {
-  const openCodeAuth = await loadOpenCodeAuthEntry2(logger);
-  if (openCodeAuth && hasAccessToken(openCodeAuth)) {
-    return openCodeAuth;
-  }
-  const pluginAuth = await readJson(AUTH_PATHS.openaiPlugin(), logger);
-  if (pluginAuth && hasAccessToken(pluginAuth)) {
-    return pluginAuth;
+var toAuthData2, hasAccessToken, loadOpenCodeAuthEntry2, getOpenaiAuth;
+var init_auth2 = __esm({
+  "src/providers/openai/auth.ts"() {
+    "use strict";
+    init_files();
+    init_registry();
+    toAuthData2 = (entry) => {
+      if (!entry) {
+        return null;
+      }
+      if (typeof entry === "string") {
+        return { token: entry };
+      }
+      if (typeof entry === "object") {
+        return entry;
+      }
+      return null;
+    };
+    hasAccessToken = (auth) => {
+      return Boolean(auth?.access || auth?.token);
+    };
+    loadOpenCodeAuthEntry2 = async (logger) => {
+      const auth = await loadOpenCodeAuth(logger);
+      if (!auth) {
+        return null;
+      }
+      for (const alias of getProviderAliases("openai")) {
+        const entry = toAuthData2(auth[alias]);
+        if (entry && hasAccessToken(entry)) {
+          return entry;
+        }
+      }
+      return null;
+    };
+    getOpenaiAuth = async (logger) => {
+      const openCodeAuth = await loadOpenCodeAuthEntry2(logger);
+      if (openCodeAuth && hasAccessToken(openCodeAuth)) {
+        return openCodeAuth;
+      }
+      const pluginAuth = await readJson(AUTH_PATHS.openaiPlugin(), logger);
+      if (pluginAuth && hasAccessToken(pluginAuth)) {
+        return pluginAuth;
+      }
+      return null;
+    };
   }
-  return null;
-};
+});
 
 // src/providers/openai/fetch.ts
-var toWindow2 = (window) => {
-  if (!window) {
-    return null;
-  }
-  const usedPercent = window.used_percent;
-  const resetAt = window.reset_at ? window.reset_at * 1e3 : null;
-  const resetAfterSeconds = window.reset_after_seconds ?? calculateResetAfterSeconds(resetAt);
-  return {
-    usedPercent,
-    remainingPercent: Math.max(0, 100 - usedPercent),
-    windowSeconds: window.limit_window_seconds ?? null,
-    resetAfterSeconds,
-    resetAt,
-    resetAtFormatted: resetAt ? formatResetAt(resetAt) : null,
-    resetAfterFormatted: resetAfterSeconds !== null ? formatDuration(resetAfterSeconds) : null
-  };
-};
-var fetchOpenaiUsage = async (logger = noopLogger) => {
-  const auth = await getOpenaiAuth(logger);
-  if (!auth) {
-    await logger.warn("No auth configured for openai");
-    return {
-      provider: "openai",
-      ok: false,
-      configured: false,
-      error: "Not configured - no OAuth token found",
-      usage: null
-    };
-  }
-  const accessToken = auth.access ?? auth.token;
-  if (!accessToken) {
-    await logger.warn("Auth configured but access token missing for openai");
-    return {
-      provider: "openai",
-      ok: false,
-      configured: false,
-      error: "Not configured - access token missing",
-      usage: null
-    };
-  }
-  try {
-    const response = await fetch("https://chatgpt.com/backend-api/wham/usage", {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-        "Content-Type": "application/json"
-      }
-    });
-    if (!response.ok) {
-      await logger.error(`API error ${response.status} for openai`, {
-        token: maskSecret(accessToken)
-      });
+var toWindow2, fetchOpenaiUsage;
+var init_fetch2 = __esm({
+  "src/providers/openai/fetch.ts"() {
+    "use strict";
+    init_logger();
+    init_time();
+    init_auth2();
+    toWindow2 = (window) => {
+      if (!window) {
+        return null;
+      }
+      const usedPercent = window.used_percent;
+      const resetAt = window.reset_at ? window.reset_at * 1e3 : null;
+      const resetAfterSeconds = window.reset_after_seconds ?? calculateResetAfterSeconds(resetAt);
       return {
-        provider: "openai",
-        ok: false,
-        configured: true,
-        error: `API error: ${response.status}`,
-        usage: null
+        usedPercent,
+        remainingPercent: Math.max(0, 100 - usedPercent),
+        windowSeconds: window.limit_window_seconds ?? null,
+        resetAfterSeconds,
+        resetAt,
+        resetAtFormatted: resetAt ? formatResetAt(resetAt) : null,
+        resetAfterFormatted: resetAfterSeconds !== null ? formatDuration(resetAfterSeconds) : null
       };
-    }
-    const payload = await response.json();
-    const primary = toWindow2(payload.rate_limit.primary_window);
-    const secondary = toWindow2(payload.rate_limit.secondary_window);
-    const windows = {};
-    if (primary) {
-      windows["5h"] = primary;
-    }
-    if (secondary) {
-      windows["weekly"] = secondary;
-    }
-    const usage = {
-      windows
     };
-    await logger.info("openai usage fetched successfully");
-    return {
-      provider: "openai",
-      ok: true,
-      configured: true,
-      usage
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    await logger.error(`Request failed for openai: ${message}`);
-    return {
-      provider: "openai",
-      ok: false,
-      configured: true,
-      error: `Request failed: ${message}`,
-      usage: null
+    fetchOpenaiUsage = async (logger = noopLogger) => {
+      const auth = await getOpenaiAuth(logger);
+      if (!auth) {
+        await logger.warn("No auth configured for openai");
+        return {
+          provider: "openai",
+          ok: false,
+          configured: false,
+          error: "Not configured - no OAuth token found",
+          usage: null
+        };
+      }
+      const accessToken = auth.access ?? auth.token;
+      if (!accessToken) {
+        await logger.warn("Auth configured but access token missing for openai");
+        return {
+          provider: "openai",
+          ok: false,
+          configured: false,
+          error: "Not configured - access token missing",
+          usage: null
+        };
+      }
+      try {
+        const response = await fetch("https://chatgpt.com/backend-api/wham/usage", {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            "Content-Type": "application/json"
+          }
+        });
+        if (!response.ok) {
+          await logger.error(`API error ${response.status} for openai`, {
+            token: maskSecret(accessToken)
+          });
+          return {
+            provider: "openai",
+            ok: false,
+            configured: true,
+            error: `API error: ${response.status}`,
+            usage: null
+          };
+        }
+        const payload = await response.json();
+        const primary = toWindow2(payload.rate_limit.primary_window);
+        const secondary = toWindow2(payload.rate_limit.secondary_window);
+        const windows = {};
+        if (primary) {
+          windows["5h"] = primary;
+        }
+        if (secondary) {
+          windows["weekly"] = secondary;
+        }
+        const usage = {
+          windows
+        };
+        await logger.info("openai usage fetched successfully");
+        return {
+          provider: "openai",
+          ok: true,
+          configured: true,
+          usage
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await logger.error(`Request failed for openai: ${message}`);
+        return {
+          provider: "openai",
+          ok: false,
+          configured: true,
+          error: `Request failed: ${message}`,
+          usage: null
+        };
+      }
     };
   }
-};
+});
 
 // src/providers/zai-coding-plan/auth.ts
-var resolveAuthValue = (entry) => {
-  if (!entry) {
-    return null;
-  }
-  if (typeof entry === "string") {
-    return entry;
-  }
-  if (typeof entry === "object") {
-    return entry.api_key ?? entry.token ?? entry.key ?? null;
-  }
-  return null;
-};
-var getZaiApiKey = async (logger) => {
-  if (process.env.ZAI_API_KEY) {
-    return process.env.ZAI_API_KEY;
-  }
-  const auth = await loadOpenCodeAuth(logger);
-  if (!auth) {
-    return null;
-  }
-  for (const alias of getProviderAliases("zai-coding-plan")) {
-    const value = resolveAuthValue(auth[alias]);
-    if (value) {
-      return value;
-    }
+var resolveAuthValue, getZaiApiKey;
+var init_auth3 = __esm({
+  "src/providers/zai-coding-plan/auth.ts"() {
+    "use strict";
+    init_files();
+    init_registry();
+    resolveAuthValue = (entry) => {
+      if (!entry) {
+        return null;
+      }
+      if (typeof entry === "string") {
+        return entry;
+      }
+      if (typeof entry === "object") {
+        return entry.api_key ?? entry.token ?? entry.key ?? null;
+      }
+      return null;
+    };
+    getZaiApiKey = async (logger) => {
+      if (process.env.ZAI_API_KEY) {
+        return process.env.ZAI_API_KEY;
+      }
+      const auth = await loadOpenCodeAuth(logger);
+      if (!auth) {
+        return null;
+      }
+      for (const alias of getProviderAliases("zai-coding-plan")) {
+        const value = resolveAuthValue(auth[alias]);
+        if (value) {
+          return value;
+        }
+      }
+      return null;
+    };
   }
-  return null;
-};
+});
 
 // src/providers/zai-coding-plan/fetch.ts
-var normalizeTimestamp = (value) => {
-  return value < 1e12 ? value * 1e3 : value;
-};
-var TOKEN_WINDOW_SECONDS = {
-  3: 3600
-};
-var resolveWindowSeconds = (limit) => {
-  if (!limit) {
-    return null;
-  }
-  if (!limit.number) {
-    return null;
-  }
-  const unitSeconds = TOKEN_WINDOW_SECONDS[limit.unit];
-  if (!unitSeconds) {
-    return null;
+var normalizeTimestamp, TOKEN_WINDOW_SECONDS, resolveWindowSeconds, resolveWindowLabel, toWindow3, fetchZaiUsage;
+var init_fetch3 = __esm({
+  "src/providers/zai-coding-plan/fetch.ts"() {
+    "use strict";
+    init_logger();
+    init_time();
+    init_auth3();
+    normalizeTimestamp = (value) => {
+      return value < 1e12 ? value * 1e3 : value;
+    };
+    TOKEN_WINDOW_SECONDS = {
+      3: 3600
+    };
+    resolveWindowSeconds = (limit) => {
+      if (!limit) {
+        return null;
+      }
+      if (!limit.number) {
+        return null;
+      }
+      const unitSeconds = TOKEN_WINDOW_SECONDS[limit.unit];
+      if (!unitSeconds) {
+        return null;
+      }
+      return unitSeconds * limit.number;
+    };
+    resolveWindowLabel = (windowSeconds) => {
+      if (!windowSeconds) {
+        return "tokens";
+      }
+      if (windowSeconds % 86400 === 0) {
+        const days = windowSeconds / 86400;
+        return days === 7 ? "weekly" : `${days}d`;
+      }
+      if (windowSeconds % 3600 === 0) {
+        return `${windowSeconds / 3600}h`;
+      }
+      return `${windowSeconds}s`;
+    };
+    toWindow3 = (limit) => {
+      if (!limit) {
+        return null;
+      }
+      const usedPercent = limit.percentage ?? null;
+      const remainingPercent = usedPercent !== null ? Math.max(0, 100 - usedPercent) : null;
+      const resetAt = limit.nextResetTime ? normalizeTimestamp(limit.nextResetTime) : null;
+      const resetAfterSeconds = calculateResetAfterSeconds(resetAt);
+      return {
+        usedPercent,
+        remainingPercent,
+        windowSeconds: resolveWindowSeconds(limit),
+        resetAfterSeconds,
+        resetAt,
+        resetAtFormatted: resetAt ? formatResetAt(resetAt) : null,
+        resetAfterFormatted: resetAfterSeconds !== null ? formatDuration(resetAfterSeconds) : null
+      };
+    };
+    fetchZaiUsage = async (logger = noopLogger) => {
+      const apiKey = await getZaiApiKey(logger);
+      if (!apiKey) {
+        await logger.warn("No auth configured for zai-coding-plan");
+        return {
+          provider: "zai-coding-plan",
+          ok: false,
+          configured: false,
+          error: "Not configured - no API key found",
+          usage: null
+        };
+      }
+      try {
+        const response = await fetch("https://api.z.ai/api/monitor/usage/quota/limit", {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json"
+          }
+        });
+        if (!response.ok) {
+          await logger.error(`API error ${response.status} for zai-coding-plan`, {
+            token: maskSecret(apiKey)
+          });
+          return {
+            provider: "zai-coding-plan",
+            ok: false,
+            configured: true,
+            error: `API error: ${response.status}`,
+            usage: null
+          };
+        }
+        const payload = await response.json();
+        const limits = payload.data?.limits ?? [];
+        const tokensLimit = limits.find((limit) => limit.type === "TOKENS_LIMIT");
+        const windows = {};
+        const window = toWindow3(tokensLimit);
+        if (window) {
+          const label = resolveWindowLabel(window.windowSeconds);
+          windows[label] = window;
+        }
+        const usage = {
+          windows
+        };
+        await logger.info("zai-coding-plan usage fetched successfully");
+        return {
+          provider: "zai-coding-plan",
+          ok: true,
+          configured: true,
+          usage
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await logger.error(`Request failed for zai-coding-plan: ${message}`);
+        return {
+          provider: "zai-coding-plan",
+          ok: false,
+          configured: true,
+          error: `Request failed: ${message}`,
+          usage: null
+        };
+      }
+    };
   }
-  return unitSeconds * limit.number;
-};
-var resolveWindowLabel = (windowSeconds) => {
-  if (!windowSeconds) {
-    return "tokens";
+});
+
+// src/types/provider.ts
+var PROVIDERS;
+var init_provider = __esm({
+  "src/types/provider.ts"() {
+    "use strict";
+    PROVIDERS = ["openai", "google", "zai-coding-plan"];
   }
-  if (windowSeconds % 86400 === 0) {
-    const days = windowSeconds / 86400;
-    return days === 7 ? "weekly" : `${days}d`;
+});
+
+// src/types/dashboard.ts
+var init_dashboard = __esm({
+  "src/types/dashboard.ts"() {
+    "use strict";
   }
-  if (windowSeconds % 3600 === 0) {
-    return `${windowSeconds / 3600}h`;
+});
+
+// src/types/index.ts
+var init_types2 = __esm({
+  "src/types/index.ts"() {
+    "use strict";
+    init_provider();
+    init_dashboard();
+  }
+});
+
+// src/cache/fetcher.ts
+var fetchUsage, fetchAllProviders;
+var init_fetcher = __esm({
+  "src/cache/fetcher.ts"() {
+    "use strict";
+    init_fetch();
+    init_fetch2();
+    init_fetch3();
+    init_types2();
+    init_file();
+    init_types();
+    fetchUsage = async (provider, logger) => {
+      switch (provider) {
+        case "openai":
+          return fetchOpenaiUsage(logger);
+        case "google":
+          return fetchGoogleUsage(logger);
+        case "zai-coding-plan":
+          return fetchZaiUsage(logger);
+      }
+    };
+    fetchAllProviders = async (logger) => {
+      await logger.info("Fetching usage for all providers");
+      const existingCache = await readCache(logger);
+      const results = await Promise.all(PROVIDERS.map((provider) => fetchUsage(provider, logger)));
+      const providers = {};
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const result of results) {
+        const providerId = result.provider;
+        const wasConfigured = existingCache?.providers[providerId]?.configured ?? false;
+        providers[providerId] = {
+          supported: true,
+          configured: result.configured,
+          last_attempt_at: now,
+          last_success_at: result.ok ? now : null,
+          data: result.ok ? result.usage : null,
+          error: result.ok ? null : result.error ?? null
+        };
+        if (!result.configured && wasConfigured) {
+          providers[providerId].data = null;
+          await logger.debug(`Wiped data for ${providerId} (no longer configured)`);
+        }
+      }
+      const cache = {
+        schema_version: SCHEMA_VERSION,
+        updated_at: now,
+        refresh_interval_seconds: REFRESH_INTERVAL_SECONDS,
+        providers
+      };
+      await writeCache(cache, logger);
+      return cache;
+    };
   }
-  return `${windowSeconds}s`;
-};
-var toWindow3 = (limit) => {
-  if (!limit) {
-    return null;
-  }
-  const usedPercent = limit.percentage ?? null;
-  const remainingPercent = usedPercent !== null ? Math.max(0, 100 - usedPercent) : null;
-  const resetAt = limit.nextResetTime ? normalizeTimestamp(limit.nextResetTime) : null;
-  const resetAfterSeconds = calculateResetAfterSeconds(resetAt);
-  return {
-    usedPercent,
-    remainingPercent,
-    windowSeconds: resolveWindowSeconds(limit),
-    resetAfterSeconds,
-    resetAt,
-    resetAtFormatted: resetAt ? formatResetAt(resetAt) : null,
-    resetAfterFormatted: resetAfterSeconds !== null ? formatDuration(resetAfterSeconds) : null
-  };
-};
-var fetchZaiUsage = async (logger = noopLogger) => {
-  const apiKey = await getZaiApiKey(logger);
-  if (!apiKey) {
-    await logger.warn("No auth configured for zai-coding-plan");
-    return {
-      provider: "zai-coding-plan",
-      ok: false,
-      configured: false,
-      error: "Not configured - no API key found",
-      usage: null
-    };
-  }
-  try {
-    const response = await fetch("https://api.z.ai/api/monitor/usage/quota/limit", {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json"
-      }
-    });
-    if (!response.ok) {
-      await logger.error(`API error ${response.status} for zai-coding-plan`, {
-        token: maskSecret(apiKey)
-      });
-      return {
-        provider: "zai-coding-plan",
-        ok: false,
-        configured: true,
-        error: `API error: ${response.status}`,
-        usage: null
+});
+
+// src/cache/worker.ts
+var worker_exports = {};
+__export(worker_exports, {
+  isWorkerRunning: () => isWorkerRunning,
+  startWorker: () => startWorker,
+  stopWorker: () => stopWorker
+});
+var intervalId, startWorker, stopWorker, isWorkerRunning;
+var init_worker = __esm({
+  "src/cache/worker.ts"() {
+    "use strict";
+    init_fetcher();
+    init_types();
+    intervalId = null;
+    startWorker = (logger) => {
+      if (intervalId !== null) {
+        logger.warn("Worker already started");
+        return;
+      }
+      const refreshLoop = async () => {
+        try {
+          await fetchAllProviders(logger);
+        } catch (error) {
+          await logger.error("Worker refresh failed", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
       };
-    }
-    const payload = await response.json();
-    const limits = payload.data?.limits ?? [];
-    const tokensLimit = limits.find((limit) => limit.type === "TOKENS_LIMIT");
-    const windows = {};
-    const window = toWindow3(tokensLimit);
-    if (window) {
-      const label = resolveWindowLabel(window.windowSeconds);
-      windows[label] = window;
-    }
-    const usage = {
-      windows
+      void refreshLoop();
+      intervalId = globalThis.setInterval(refreshLoop, REFRESH_INTERVAL_SECONDS * 1e3);
+      void logger.info(`Worker started, refreshing every ${REFRESH_INTERVAL_SECONDS}s`);
     };
-    await logger.info("zai-coding-plan usage fetched successfully");
-    return {
-      provider: "zai-coding-plan",
-      ok: true,
-      configured: true,
-      usage
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    await logger.error(`Request failed for zai-coding-plan: ${message}`);
-    return {
-      provider: "zai-coding-plan",
-      ok: false,
-      configured: true,
-      error: `Request failed: ${message}`,
-      usage: null
+    stopWorker = (logger) => {
+      if (intervalId === null) {
+        return;
+      }
+      globalThis.clearInterval(intervalId);
+      intervalId = null;
+      void logger.info("Worker stopped");
     };
+    isWorkerRunning = () => intervalId !== null;
   }
-};
+});
 
-// src/types/provider.ts
-var PROVIDERS = ["openai", "google", "zai-coding-plan"];
+// src/index.ts
+init_logger();
+import { tool } from "@opencode-ai/plugin";
 
 // src/toast/filter.ts
 var FLAGSHIP_PATTERNS = [
@@ -689,7 +1009,7 @@ var filterFlagshipModels = (models) => {
   return filtered;
 };
 
-// src/table/format.ts
+// src/dashboard/format.ts
 var getStatus = (remainingPercent) => {
   if (remainingPercent === null) {
     return { emoji: "\u26AA", text: "N/A" };
@@ -733,7 +1053,16 @@ var formatWindow = (key, window) => {
     resetsIn: window.resetAfterFormatted ?? "N/A"
   };
 };
-var formatDashboardData = (results) => {
+var formatDashboardData = (input) => {
+  if (input === null) {
+    return { providers: [] };
+  }
+  if (!("providers" in input)) {
+    return formatDashboardDataFromResults(input);
+  }
+  return formatDashboardDataFromCache(input);
+};
+var formatDashboardDataFromResults = (results) => {
   const providers = [];
   for (const result of results) {
     if (!result.usage) {
@@ -755,15 +1084,23 @@ var formatDashboardData = (results) => {
       });
     }
     if (usage.models) {
+      const modelSections = [];
       for (const [modelName, modelUsage] of Object.entries(usage.models)) {
         const modelWindowEntries = Object.entries(modelUsage.windows);
         if (modelWindowEntries.length > 0) {
-          sections.push({
+          modelSections.push({
             title: modelName,
             windows: modelWindowEntries.map(([key, win]) => formatWindow(key, win))
           });
         }
       }
+      if (modelSections.length > 0) {
+        sections.push({
+          title: "Model Usage",
+          windows: [],
+          sections: modelSections
+        });
+      }
     }
     if (sections.length > 0) {
       providers.push({
@@ -774,9 +1111,64 @@ var formatDashboardData = (results) => {
   }
   return { providers };
 };
-var formatDashboardString = (data) => {
+var formatDashboardDataFromCache = (displayCache) => {
+  const providers = [];
+  for (const [providerId, entry] of Object.entries(displayCache.providers)) {
+    if (!entry.data) {
+      continue;
+    }
+    const sections = [];
+    let usage = entry.data;
+    if (providerId === "google" && usage.models) {
+      usage = {
+        ...usage,
+        models: filterFlagshipModels(usage.models)
+      };
+    }
+    const globalWindows = Object.entries(usage.windows);
+    if (globalWindows.length > 0) {
+      sections.push({
+        title: "Overall Usage",
+        windows: globalWindows.map(([key, win]) => formatWindow(key, win))
+      });
+    }
+    if (usage.models) {
+      const modelSections = [];
+      for (const [modelName, modelUsage] of Object.entries(usage.models)) {
+        const modelWindowEntries = Object.entries(modelUsage.windows);
+        if (modelWindowEntries.length > 0) {
+          modelSections.push({
+            title: modelName,
+            windows: modelWindowEntries.map(([key, win]) => formatWindow(key, win))
+          });
+        }
+      }
+      if (modelSections.length > 0) {
+        sections.push({
+          title: "Model Usage",
+          windows: [],
+          sections: modelSections
+        });
+      }
+    }
+    if (sections.length > 0) {
+      providers.push({
+        name: providerId.toUpperCase().replace(/-/g, " "),
+        sections
+      });
+    }
+  }
+  return { providers };
+};
+var formatDashboardString = (data, updatedAt, isStale) => {
   if (data.providers.length === 0) {
-    return "No usage data available";
+    let result2 = "No usage data available";
+    if (updatedAt) {
+      result2 += `
+
+Updated at: ${updatedAt}`;
+    }
+    return result2;
   }
   const lines = [];
   const HEADER_WIDTH = 65;
@@ -794,104 +1186,171 @@ var formatDashboardString = (data) => {
         const pipe = isLastWindow ? "  " : "\u2502 ";
         lines.push(`  ${branch} ${window.label}`);
         const percentStr = window.usedPercent !== null ? `${Math.round(window.usedPercent)}%` : "N/A";
-        lines.push(`  ${pipe} ${renderBar(window.usedPercent)}  ${percentStr}`);
         lines.push(
-          `  ${pipe} Status ${window.status} ${window.statusText} \u2022 Resets in ${window.resetsIn}`
+          `  ${pipe} ${renderBar(window.usedPercent)}  ${percentStr} \u2022 Resets in ${window.resetsIn}`
         );
         if (!isLastWindow) {
           lines.push(`  ${pipe}`);
         }
       }
+      if (section.sections) {
+        for (let k = 0; k < section.sections.length; k++) {
+          const subsection = section.sections[k];
+          const isLastSubsection = k === section.sections.length - 1;
+          const branch = isLastSubsection ? "\u2514\u2500" : "\u251C\u2500";
+          const pipe = isLastSubsection ? "  " : "\u2502 ";
+          lines.push(`  ${branch} ${subsection.title}`);
+          for (let m = 0; m < subsection.windows.length; m++) {
+            const window = subsection.windows[m];
+            const isLastWindow = m === subsection.windows.length - 1;
+            const subBranch = isLastWindow ? "\u2514\u2500" : "\u251C\u2500";
+            lines.push(`  ${pipe}  ${subBranch} ${window.label}`);
+            const percentStr = window.usedPercent !== null ? `${Math.round(window.usedPercent)}%` : "N/A";
+            const subPipe = isLastWindow ? "  " : "\u2502 ";
+            lines.push(
+              `  ${pipe}  ${subPipe} ${renderBar(window.usedPercent)}  ${percentStr} \u2022 Resets in ${window.resetsIn}`
+            );
+            if (!isLastWindow) {
+              lines.push(`  ${pipe}  ${subPipe}`);
+            }
+          }
+          if (!isLastSubsection) {
+            lines.push(`  ${pipe}`);
+          }
+        }
+      }
       lines.push("");
     }
   }
-  return lines.join("\n").trim();
+  let result = lines.join("\n").trim();
+  if (updatedAt) {
+    result += `
+
+Updated at: ${updatedAt}`;
+  }
+  if (isStale) {
+    result += " (STALE)";
+  }
+  return result;
 };
 
 // src/toast/format.ts
-var formatProviderLine = (provider, usage) => {
+var getStatus2 = (remainingPercent) => {
+  if (remainingPercent === null) return "\u26AA";
+  if (remainingPercent < 10) return "\u{1F534}";
+  if (remainingPercent < 30) return "\u{1F7E1}";
+  return "\u{1F7E2}";
+};
+var formatWindowLine = (name, window, isModel = false) => {
+  const used = window.usedPercent !== null ? Math.round(window.usedPercent) : 0;
+  const reset = window.resetAfterFormatted ?? "N/A";
+  const remaining = window.remainingPercent ?? null;
+  const emoji = isModel ? "" : `${getStatus2(remaining)} `;
+  const indent = isModel ? "  " : "";
+  return `${indent}${emoji}${name.padEnd(isModel ? 13 : 10)} ${used}% \u2022 ${reset}`;
+};
+var formatProviderSection = (provider, usage) => {
   if (!usage) {
-    return `${provider}: Not configured`;
+    return [`\u26AA ${provider}: Not configured`];
   }
+  const lines = [];
   const globalWindows = Object.values(usage.windows);
   if (globalWindows.length > 0) {
-    const window = globalWindows[0];
-    const used = window.usedPercent ?? 0;
-    const reset = window.resetAfterFormatted ?? "N/A";
-    return `${provider}: ${used}% used \u2022 resets in ${reset}`;
+    lines.push(formatWindowLine(provider, globalWindows[0]));
+  } else {
+    lines.push(`\u26AA ${provider}: No usage data`);
   }
   if (usage.models) {
-    const models = Object.entries(usage.models);
-    if (models.length === 1) {
-      const [modelName, modelData] = models[0];
-      const window = Object.values(modelData.windows)[0];
-      const used = window.usedPercent ?? 0;
-      const reset = window.resetAfterFormatted ?? "N/A";
-      return `${provider}: ${modelName} ${used}% \u2022 resets in ${reset}`;
-    }
-    if (models.length > 1) {
-      const parts = [];
-      for (const [modelName, modelData] of models) {
-        const window = Object.values(modelData.windows)[0];
-        const used = window.usedPercent ?? 0;
-        parts.push(`${modelName} ${used}%`);
+    for (const [modelName, modelData] of Object.entries(usage.models)) {
+      const modelWindow = Object.values(modelData.windows)[0];
+      if (modelWindow) {
+        lines.push(formatWindowLine(modelName, modelWindow, true));
       }
-      return `${provider}: ${parts.join(", ")}`;
     }
   }
-  return `${provider}: No usage data`;
+  return lines;
 };
-var formatUsageToast = async (results, logger) => {
+var formatUsageToast = async (input, logger) => {
+  if (!input) {
+    return {
+      title: "\u{1F4CA} Usage",
+      message: "No providers configured",
+      variant: "info"
+    };
+  }
+  const displayCache = "providers" in input ? input : null;
+  const results = "providers" in input ? null : input;
   const lines = [];
-  for (const result of results) {
-    if (!result.usage) {
-      await logger?.debug(`Provider ${result.provider} not configured, skipping`);
-      continue;
+  const contentLines = [];
+  const DIVIDER = "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500";
+  let updatedAt = "";
+  let isStale = false;
+  if (displayCache) {
+    updatedAt = displayCache.updatedAt;
+    isStale = displayCache.isStale;
+    for (const [providerId, entry] of Object.entries(displayCache.providers)) {
+      if (!entry.data) continue;
+      let usage = entry.data;
+      if (providerId === "google" && usage?.models) {
+        usage = {
+          ...usage,
+          models: filterFlagshipModels(usage.models)
+        };
+      }
+      contentLines.push(...formatProviderSection(providerId, usage));
     }
-    let usage = result.usage;
-    if (result.provider === "google" && usage?.models) {
-      usage = {
-        ...usage,
-        models: filterFlagshipModels(usage.models)
-      };
+    if (Object.values(displayCache.providers).some((e) => e.error !== null)) {
+      contentLines.push("\u26A0\uFE0F Some providers failed");
+    }
+  } else if (results) {
+    const now = /* @__PURE__ */ new Date();
+    updatedAt = `${now.getHours().toString().padStart(2, "0")}:${now.getMinutes().toString().padStart(2, "0")}`;
+    for (const result of results) {
+      if (!result.usage) {
+        await logger?.debug(`Provider ${result.provider} not configured, skipping`);
+        continue;
+      }
+      let usage = result.usage;
+      if (result.provider === "google" && usage?.models) {
+        usage = {
+          ...usage,
+          models: filterFlagshipModels(usage.models)
+        };
+      }
+      contentLines.push(...formatProviderSection(result.provider, usage));
     }
-    const line = formatProviderLine(result.provider, usage);
-    lines.push(line);
   }
-  if (lines.length === 0) {
+  if (contentLines.length === 0) {
     return {
-      title: "Usage",
+      title: "\u{1F4CA} Usage",
       message: "No providers configured",
       variant: "info"
     };
   }
+  lines.push(DIVIDER);
+  lines.push(...contentLines);
+  lines.push(DIVIDER);
+  let footer = `Updated: ${updatedAt}`;
+  if (isStale) footer += " (stale)";
+  lines.push(footer);
   return {
-    title: "Usage",
+    title: "\u{1F4CA} Usage",
     message: lines.join("\n"),
     variant: "info"
   };
 };
 
 // src/index.ts
-var fetchUsage = async (provider, logger) => {
-  switch (provider) {
-    case "openai":
-      return fetchOpenaiUsage(logger);
-    case "google":
-      return fetchGoogleUsage(logger);
-    case "zai-coding-plan":
-      return fetchZaiUsage(logger);
-  }
-};
 var UsagePlugin = async ({ client }) => {
   const logger = createLogger(client);
   const usageToastTool = tool({
     description: "Show subscription usage as toast for OpenAI, Google, and z.ai providers",
     args: {},
     async execute() {
-      await logger.info("Fetching usage for all providers");
-      const results = await Promise.all(PROVIDERS.map((provider) => fetchUsage(provider, logger)));
-      const toast = await formatUsageToast(results, logger);
+      const { loadCacheForDisplay: loadCacheForDisplay2 } = await Promise.resolve().then(() => (init_reader(), reader_exports));
+      await logger.info("Loading usage from cache");
+      const displayCache = await loadCacheForDisplay2(logger);
+      const toast = await formatUsageToast(displayCache, logger);
       await client.tui.showToast({
         body: {
           title: toast.title,
@@ -906,10 +1365,14 @@ var UsagePlugin = async ({ client }) => {
     description: "Get subscription usage data for OpenAI, Google, and z.ai providers as a formatted table",
     args: {},
     async execute() {
-      await logger.info("Fetching usage for all providers");
-      const results = await Promise.all(PROVIDERS.map((provider) => fetchUsage(provider, logger)));
-      const dashboardData = formatDashboardData(results);
-      return formatDashboardString(dashboardData);
+      const { loadCacheForDisplay: loadCacheForDisplay2 } = await Promise.resolve().then(() => (init_reader(), reader_exports));
+      await logger.info("Loading usage from cache");
+      const displayCache = await loadCacheForDisplay2(logger);
+      if (!displayCache) {
+        return "No cache available";
+      }
+      const dashboardData = formatDashboardData(displayCache);
+      return formatDashboardString(dashboardData, displayCache.updatedAt, displayCache.isStale);
     }
   });
   return {
@@ -917,6 +1380,12 @@ var UsagePlugin = async ({ client }) => {
       usage_toast: usageToastTool,
       usage_table: usageTableTool
     },
+    async event({ event }) {
+      if (event.type === "server.connected") {
+        const { startWorker: startWorker2 } = await Promise.resolve().then(() => (init_worker(), worker_exports));
+        startWorker2(logger);
+      }
+    },
     async config(config) {
       config.command = config.command ?? {};
       config.command["usage-toast"] = {
@@ -930,6 +1399,22 @@ var UsagePlugin = async ({ client }) => {
     }
   };
 };
+var setupShutdownHandlers = async () => {
+  const { isWorkerRunning: isWorkerRunning2, stopWorker: stopWorker2 } = await Promise.resolve().then(() => (init_worker(), worker_exports));
+  const { createLogger: createLogger2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+  const logger = createLogger2({
+    app: { log: () => Promise.resolve(true) }
+  });
+  const onShutdown = async () => {
+    if (await isWorkerRunning2()) {
+      stopWorker2(logger);
+    }
+  };
+  process.on("SIGINT", onShutdown);
+  process.on("SIGTERM", onShutdown);
+  process.on("exit", onShutdown);
+};
+void setupShutdownHandlers();
 var index_default = UsagePlugin;
 export {
   UsagePlugin,