pi-ui-extend 0.1.1

package/dist/app/model-usage-status.js

@@ -0,0 +1,749 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { formatCompactProgressBar } from "../context-progress-bar.js";
+const OPENAI_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const ZAI_QUOTA_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
+const ZHIPU_QUOTA_URL = "https://bigmodel.cn/api/monitor/usage/quota/limit";
+const GOOGLE_QUOTA_API_URL = "https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels";
+const GOOGLE_TOKEN_REFRESH_URL = "https://oauth2.googleapis.com/token";
+const REQUEST_TIMEOUT_MS = 10_000;
+const DAY_SECONDS = 86_400;
+const HOUR_SECONDS = 3_600;
+const DEFAULT_ANTIGRAVITY_PROJECT_ID = "rising-fact-p41fc";
+const GOOGLE_CLIENT_ID = process.env.PIX_ANTIGRAVITY_GOOGLE_CLIENT_ID ?? process.env.ANTIGRAVITY_GOOGLE_CLIENT_ID ?? "";
+const GOOGLE_CLIENT_SECRET = process.env.PIX_ANTIGRAVITY_GOOGLE_CLIENT_SECRET ?? process.env.ANTIGRAVITY_GOOGLE_CLIENT_SECRET ?? "";
+const OPENAI_QUOTA_PROVIDERS = new Set(["openai", "openai-codex"]);
+const ZHIPU_QUOTA_PROVIDERS = new Set(["zai", "zhipuai-coding-plan"]);
+const ANTIGRAVITY_QUOTA_PROVIDERS = new Set(["antigravity", "google-antigravity"]);
+export function modelUsageDescriptor(model) {
+    if (!model)
+        return undefined;
+    const provider = model.provider.toLowerCase();
+    if (OPENAI_QUOTA_PROVIDERS.has(provider)) {
+        return { kind: "openai", modelKey: `${model.provider}/${model.id}` };
+    }
+    if (ZHIPU_QUOTA_PROVIDERS.has(provider)) {
+        return { kind: "zhipu", modelKey: `${model.provider}/${model.id}` };
+    }
+    if (ANTIGRAVITY_QUOTA_PROVIDERS.has(provider)) {
+        const quotaModelKey = resolveAntigravityQuotaModelKey(model);
+        const account = readActiveAntigravityQuotaAccount();
+        if (!quotaModelKey || !account)
+            return undefined;
+        return {
+            kind: "google-antigravity",
+            modelKey: `${model.provider}/${model.id}@${account.cacheKey}`,
+            quotaModelKey,
+            account,
+        };
+    }
+    return undefined;
+}
+export async function queryModelUsageStatus(descriptor) {
+    switch (descriptor.kind) {
+        case "openai":
+            return await queryOpenAIModelUsage(descriptor.modelKey);
+        case "zhipu":
+            return await queryZhipuModelUsage(descriptor.modelKey);
+        case "google-antigravity":
+            return await queryGoogleAntigravityModelUsage(descriptor);
+    }
+}
+export async function queryAccountUsageReport(now = Date.now()) {
+    const [openai, zai, googleAccounts] = await Promise.all([
+        queryOpenAIAccountUsage(now),
+        queryZaiAccountUsage(now),
+        queryGoogleAntigravityAccountUsage(now),
+    ]);
+    return {
+        ...(openai ? { openai } : {}),
+        ...(zai ? { zai } : {}),
+        googleAccounts,
+        generatedAt: now,
+    };
+}
+export function formatAccountUsageReport(report, now = report.generatedAt) {
+    const lines = [];
+    if (report.openai) {
+        lines.push("OpenAI Account Quota", "", `Account:        ${report.openai.account}${report.openai.planType ? ` (${report.openai.planType})` : ""}`, "");
+        if (report.openai.error)
+            lines.push(`Unavailable: ${report.openai.error}`);
+        else {
+            for (const window of report.openai.windows)
+                lines.push(...formatProviderWindow(window, now, 30));
+            if (report.openai.limitReached)
+                lines.push("", "⚠️ Rate limit reached!");
+            for (const limit of report.openai.additionalLimits ?? []) {
+                lines.push(`Additional limit: ${limit.name}`);
+                if (limit.meteredFeature)
+                    lines.push(`Metered feature:  ${limit.meteredFeature}`);
+                lines.push("");
+                for (const window of limit.windows)
+                    lines.push(...formatProviderWindow(window, now, 30));
+                if (limit.limitReached)
+                    lines.push("", "⚠️ Rate limit reached!");
+            }
+        }
+        lines.push("");
+    }
+    if (report.zai) {
+        lines.push("Z.ai Account Quota", "", `Account:        ${report.zai.account} (Z.ai)`, "");
+        if (report.zai.error)
+            lines.push(`Unavailable: ${report.zai.error}`);
+        else {
+            for (const window of report.zai.windows)
+                lines.push(...formatProviderWindow(window, now, 30));
+            if (report.zai.mcp) {
+                lines.push("MCP monthly quota");
+                lines.push(`${formatQuotaBar(report.zai.mcp.remainingPercent, 30)} ${report.zai.mcp.remainingPercent}% remaining`);
+                if (report.zai.mcp.used !== undefined && report.zai.mcp.limit !== undefined) {
+                    lines.push(`Used: ${report.zai.mcp.used.toLocaleString()} / ${report.zai.mcp.limit.toLocaleString()}`);
+                }
+            }
+        }
+        lines.push("");
+    }
+    if (report.googleAccounts.length > 0) {
+        lines.push("Google Cloud Account Quota", "");
+        for (const account of report.googleAccounts) {
+            lines.push(account.account, "");
+            if (account.error)
+                lines.push(`Unavailable: ${account.error}`);
+            else {
+                for (const window of account.windows) {
+                    lines.push(`${window.label.padEnd(14)} ${formatDurationShort(window.resetAt, now).padEnd(7)} ${formatQuotaBar(window.remainingPercent, 20)} ${window.remainingPercent}%`);
+                }
+                if (account.limitReached)
+                    lines.push("", "⚠️ Rate limit reached!");
+            }
+            lines.push("");
+        }
+    }
+    return lines.join("\n").trimEnd();
+}
+export function formatModelUsageStatusLabel(status, now = Date.now()) {
+    if (!status)
+        return "";
+    const parts = [];
+    if (status.hourly)
+        parts.push(formatUsageWindow("H", status.hourly, now));
+    if (status.weekly)
+        parts.push(formatUsageWindow("W", status.weekly, now));
+    const limitsLabel = parts.join(" • ");
+    return status.accountEmail && limitsLabel ? `${status.accountEmail} ${limitsLabel}` : limitsLabel;
+}
+export function modelUsageRemainingPercent(status) {
+    if (!status)
+        return undefined;
+    const values = [];
+    if (status.weekly)
+        values.push(status.weekly.remainingPercent);
+    if (status.hourly)
+        values.push(status.hourly.remainingPercent);
+    return values.length > 0 ? Math.min(...values) : undefined;
+}
+export function openAIUsageStatusFromResponse(data, modelKey, now = Date.now()) {
+    const rateLimit = selectOpenAIRateLimitForModel(data, modelKey);
+    if (!rateLimit)
+        return undefined;
+    const windows = [rateLimit.primary_window, rateLimit.secondary_window].filter(isRateLimitWindow);
+    const weekly = selectWeeklyWindow(windows);
+    const hourly = selectHourlyWindow(windows);
+    if (!weekly && !hourly)
+        return undefined;
+    return {
+        modelKey,
+        provider: "openai",
+        updatedAt: now,
+        ...(weekly ? { weekly: modelUsageWindow(weekly, now) } : {}),
+        ...(hourly ? { hourly: modelUsageWindow(hourly, now) } : {}),
+    };
+}
+async function queryOpenAIModelUsage(modelKey) {
+    const authData = await readOpenAIAuth();
+    if (!authData || authData.type !== "oauth" || !authData.access)
+        return undefined;
+    if (isExpired(authData))
+        return undefined;
+    const usage = await fetchOpenAIUsage(authData.access);
+    return openAIUsageStatusFromResponse(usage, modelKey);
+}
+async function queryOpenAIAccountUsage(now) {
+    const authData = await readOpenAIAuth();
+    if (!authData || authData.type !== "oauth" || !authData.access)
+        return undefined;
+    if (isExpired(authData))
+        return {
+            account: accountLabelFromOpenAIAuth(authData),
+            windows: [],
+            limitReached: false,
+            error: "OAuth token is expired",
+        };
+    try {
+        const usage = await fetchOpenAIUsage(authData.access);
+        const windows = [usage.rate_limit?.primary_window, usage.rate_limit?.secondary_window]
+            .filter(isRateLimitWindow)
+            .map((window) => accountWindowFromRateLimit(window, now));
+        const additionalLimits = (usage.additional_rate_limits ?? [])
+            .filter((limit) => !!limit.rate_limit)
+            .map((limit) => ({
+            name: limit.limit_name,
+            ...(limit.metered_feature ? { meteredFeature: limit.metered_feature } : {}),
+            windows: [limit.rate_limit.primary_window, limit.rate_limit.secondary_window]
+                .filter(isRateLimitWindow)
+                .map((window) => accountWindowFromRateLimit(window, now)),
+            limitReached: limit.rate_limit.limit_reached === true,
+        }));
+        return {
+            account: accountLabelFromOpenAIAuth(authData),
+            ...(usage.plan_type ? { planType: usage.plan_type } : {}),
+            windows,
+            limitReached: usage.rate_limit?.limit_reached === true,
+            ...(additionalLimits.length > 0 ? { additionalLimits } : {}),
+        };
+    }
+    catch (error) {
+        return {
+            account: accountLabelFromOpenAIAuth(authData),
+            windows: [],
+            limitReached: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function readOpenAIAuth() {
+    const authData = await readOpenCodeAuth();
+    const piAuth = await readPiAuth();
+    const piOpenAI = piAuth["openai-codex"];
+    if ((!authData.openai || isExpired(authData.openai)) && piOpenAI?.type === "oauth" && piOpenAI.access) {
+        const credential = {
+            type: "oauth",
+            access: piOpenAI.access,
+        };
+        if (piOpenAI.refresh)
+            credential.refresh = piOpenAI.refresh;
+        if (typeof piOpenAI.expires === "number")
+            credential.expires = piOpenAI.expires;
+        if (piOpenAI.email)
+            credential.email = piOpenAI.email;
+        authData.openai = credential;
+    }
+    return authData.openai;
+}
+function accountLabelFromOpenAIAuth(authData) {
+    return authData.email || (authData.access ? openAIAccountEmailFromJwt(authData.access) : undefined) || "OpenAI";
+}
+async function readOpenCodeAuth() {
+    try {
+        const content = await readFile(join(homedir(), ".local/share/opencode/auth.json"), "utf8");
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+async function readPiAuth() {
+    try {
+        const content = await readFile(join(getAgentDir(), "auth.json"), "utf8");
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+function isExpired(credential) {
+    return typeof credential?.expires === "number" && credential.expires < Date.now();
+}
+export function zhipuUsageStatusFromResponse(data, modelKey, now = Date.now()) {
+    if (!data.success || data.code !== 200)
+        return undefined;
+    const tokensLimit = data.data.limits.find((l) => l.type === "TOKENS_LIMIT");
+    if (!tokensLimit)
+        return undefined;
+    const remainingPercent = clampPercent(100 - Math.round(tokensLimit.percentage));
+    const resetAt = typeof tokensLimit.nextResetTime === "number" && tokensLimit.nextResetTime > now
+        ? tokensLimit.nextResetTime
+        : now + 5 * HOUR_SECONDS * 1000;
+    return {
+        modelKey,
+        provider: "zhipu",
+        updatedAt: now,
+        hourly: {
+            remainingPercent,
+            resetAt,
+            windowSeconds: 5 * HOUR_SECONDS,
+        },
+    };
+}
+async function queryZhipuModelUsage(modelKey) {
+    const apiKey = await readZhipuApiKey();
+    if (!apiKey)
+        return undefined;
+    const response = await fetchZhipuQuota(apiKey, modelKey.startsWith("zhipuai") ? ZHIPU_QUOTA_URL : ZAI_QUOTA_URL);
+    return zhipuUsageStatusFromResponse(response, modelKey);
+}
+async function queryZaiAccountUsage(now) {
+    const apiKey = await readZhipuApiKey();
+    if (!apiKey)
+        return undefined;
+    try {
+        const response = await fetchZhipuQuota(apiKey, ZAI_QUOTA_URL);
+        if (!response.success || response.code !== 200) {
+            return { account: maskCredential(apiKey), windows: [], error: response.msg || "quota request failed" };
+        }
+        const tokenLimits = response.data.limits
+            .filter((limit) => limit.type === "TOKENS_LIMIT")
+            .map((limit) => ({
+            label: "5-hour token limit",
+            remainingPercent: clampPercent(100 - Math.round(limit.percentage)),
+            resetAt: typeof limit.nextResetTime === "number" && limit.nextResetTime > now ? limit.nextResetTime : now + 5 * HOUR_SECONDS * 1000,
+            windowSeconds: 5 * HOUR_SECONDS,
+        }));
+        const mcpLimit = response.data.limits.find((limit) => /MCP/iu.test(limit.type));
+        return {
+            account: maskCredential(apiKey),
+            windows: tokenLimits,
+            ...(mcpLimit ? {
+                mcp: {
+                    label: "MCP monthly quota",
+                    remainingPercent: clampPercent(100 - Math.round(mcpLimit.percentage)),
+                    resetAt: typeof mcpLimit.nextResetTime === "number" && mcpLimit.nextResetTime > now ? mcpLimit.nextResetTime : now,
+                    windowSeconds: 30 * DAY_SECONDS,
+                    used: mcpLimit.usage,
+                    limit: mcpLimit.currentValue,
+                },
+            } : {}),
+        };
+    }
+    catch (error) {
+        return {
+            account: maskCredential(apiKey),
+            windows: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function readZhipuApiKey() {
+    const piAuth = await readPiAuth();
+    const zaiCredential = piAuth.zai;
+    if (zaiCredential?.key && (zaiCredential.type === "api" || zaiCredential.type === "api_key")) {
+        return zaiCredential.key;
+    }
+    const opencodeAuth = await readOpenCodeAuth();
+    const zaiPlan = opencodeAuth["zai-coding-plan"];
+    if (zaiPlan?.key)
+        return zaiPlan.key;
+    const zhipuPlan = opencodeAuth["zhipuai-coding-plan"];
+    if (zhipuPlan?.key)
+        return zhipuPlan.key;
+    return undefined;
+}
+async function fetchZhipuQuota(apiKey, url) {
+    const response = await fetchWithTimeout(url, {
+        headers: {
+            Authorization: apiKey,
+            "Content-Type": "application/json",
+            "User-Agent": "pi-ui-extend/0.1.0",
+        },
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Zhipu quota request failed (${response.status}): ${errorText}`);
+    }
+    return response.json();
+}
+// ---------------------------------------------------------------------------
+// Google Antigravity quota
+// ---------------------------------------------------------------------------
+export function resolveAntigravityQuotaModelKey(model) {
+    const source = `${model.id} ${model.name ?? ""}`.toLowerCase();
+    const normalized = source.replace(/[_\s]+/gu, "-");
+    if (normalized.includes("claude") && normalized.includes("opus") && normalized.includes("thinking")) {
+        return "claude-opus-4-6-thinking";
+    }
+    if (normalized.includes("claude") && normalized.includes("sonnet"))
+        return "claude-sonnet-4-6";
+    if (normalized.includes("gemini-2.5-flash") || /\bg2[.-]?5-flash\b/u.test(normalized))
+        return "gemini-2.5-flash";
+    if (normalized.includes("gemini-3-flash") || /\bg3-flash\b/u.test(normalized))
+        return "gemini-3-flash";
+    if (normalized.includes("gemini-3") && normalized.includes("flash"))
+        return "gemini-3-flash";
+    if (normalized.includes("gemini-3") && normalized.includes("pro"))
+        return "gemini-3.1-pro-low";
+    if (/\bg3(?:-pro)?\b/u.test(normalized))
+        return "gemini-3.1-pro-low";
+    return undefined;
+}
+export function googleAntigravityUsageStatusFromResponse(data, descriptor, now = Date.now()) {
+    const quotaInfo = data.models[descriptor.quotaModelKey]?.quotaInfo;
+    if (!quotaInfo || !Number.isFinite(quotaInfo.remainingFraction))
+        return undefined;
+    const resetAt = parseResetTime(quotaInfo.resetTime, now);
+    const window = {
+        remainingPercent: clampPercent(Math.round((quotaInfo.remainingFraction ?? 0) * 100)),
+        resetAt,
+        windowSeconds: Math.max(0, Math.round((resetAt - now) / 1000)),
+    };
+    const weekly = window.windowSeconds >= DAY_SECONDS ? window : undefined;
+    const hourly = weekly ? undefined : window;
+    return {
+        modelKey: descriptor.modelKey,
+        provider: "google-antigravity",
+        updatedAt: now,
+        ...(descriptor.account.email ? { accountEmail: descriptor.account.email } : {}),
+        ...(weekly ? { weekly } : {}),
+        ...(hourly ? { hourly } : {}),
+    };
+}
+async function queryGoogleAntigravityModelUsage(descriptor) {
+    const { access_token } = await refreshGoogleAccessToken(descriptor.account.refreshToken);
+    const response = await fetchGoogleAntigravityQuota(access_token, descriptor.account.projectId);
+    return googleAntigravityUsageStatusFromResponse(response, descriptor);
+}
+const GOOGLE_ACCOUNT_QUOTA_WINDOWS = [
+    { label: "Claude Opus", quotaModelKey: "claude-opus-4-6-thinking" },
+    { label: "Claude Sonnet", quotaModelKey: "claude-sonnet-4-6" },
+    { label: "G2.5 Flash", quotaModelKey: "gemini-2.5-flash" },
+    { label: "G3 Flash", quotaModelKey: "gemini-3-flash" },
+    { label: "G3 Pro", quotaModelKey: "gemini-3.1-pro-low" },
+];
+async function queryGoogleAntigravityAccountUsage(now) {
+    const accounts = readAllAntigravityQuotaAccounts();
+    const results = await Promise.all(accounts.map(async (account) => {
+        const accountLabel = account.email ?? maskCredential(account.refreshToken);
+        try {
+            const { access_token } = await refreshGoogleAccessToken(account.refreshToken);
+            const response = await fetchGoogleAntigravityQuota(access_token, account.projectId);
+            const windows = GOOGLE_ACCOUNT_QUOTA_WINDOWS.map((window) => googleAccountWindowFromResponse(response, window.label, window.quotaModelKey, now))
+                .filter((window) => window !== undefined);
+            return {
+                account: accountLabel,
+                windows,
+                limitReached: windows.some((window) => window.remainingPercent <= 0),
+            };
+        }
+        catch (error) {
+            return {
+                account: accountLabel,
+                windows: [],
+                limitReached: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }));
+    return results;
+}
+function readActiveAntigravityQuotaAccount() {
+    const accounts = readAllAntigravityQuotaAccounts();
+    const credential = readPiAuthSync().antigravity;
+    return accounts[clampAccountIndex(credential?.activeIndex, accounts.length)];
+}
+function readAllAntigravityQuotaAccounts() {
+    const credential = readPiAuthSync().antigravity;
+    if (!credential)
+        return [];
+    const accounts = storedAntigravityAccounts(credential);
+    if (accounts.length > 0) {
+        return accounts.map((account, accountIndex) => antigravityQuotaAccount(account, {
+            ...(credential.email ? { fallbackEmail: credential.email } : {}),
+            accountIndex,
+            accountCount: accounts.length,
+        })).filter((account) => account !== undefined);
+    }
+    const fallbackAccount = antigravityAccountFromCredential(credential);
+    const account = fallbackAccount ? antigravityQuotaAccount(fallbackAccount, {
+        ...(credential.email ? { fallbackEmail: credential.email } : {}),
+    }) : undefined;
+    return account ? [account] : [];
+}
+function readPiAuthSync() {
+    try {
+        return JSON.parse(readFileSync(join(getAgentDir(), "auth.json"), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function storedAntigravityAccounts(credential) {
+    return Array.isArray(credential.accounts)
+        ? credential.accounts.filter((account) => account.enabled !== false && !!account.refreshToken)
+        : [];
+}
+function antigravityAccountFromCredential(credential) {
+    if (credential.type !== "oauth" || !credential.refresh)
+        return undefined;
+    const refresh = splitAntigravityRefresh(credential.refresh);
+    if (!refresh.refreshToken)
+        return undefined;
+    return {
+        refreshToken: refresh.refreshToken,
+        projectId: refresh.projectId || refresh.managedProjectId || DEFAULT_ANTIGRAVITY_PROJECT_ID,
+        enabled: true,
+        ...(credential.email ? { email: credential.email } : {}),
+        ...(refresh.managedProjectId ? { managedProjectId: refresh.managedProjectId } : {}),
+    };
+}
+function antigravityQuotaAccount(account, options = {}) {
+    const refreshToken = account.refreshToken;
+    if (!refreshToken)
+        return undefined;
+    const email = account.email || options.fallbackEmail;
+    const projectId = account.projectId || account.managedProjectId || DEFAULT_ANTIGRAVITY_PROJECT_ID;
+    return {
+        refreshToken,
+        projectId,
+        cacheKey: email ? email.toLowerCase() : shortHash(refreshToken),
+        ...(email ? { email } : {}),
+        ...(typeof options.accountIndex === "number" ? { accountIndex: options.accountIndex } : {}),
+        ...(typeof options.accountCount === "number" ? { accountCount: options.accountCount } : {}),
+    };
+}
+function splitAntigravityRefresh(refresh) {
+    const [refreshToken = "", projectId = "", managedProjectId = ""] = refresh.split("|");
+    return {
+        refreshToken: refreshToken || refresh,
+        ...(projectId ? { projectId } : {}),
+        ...(managedProjectId ? { managedProjectId } : {}),
+    };
+}
+function clampAccountIndex(index, accountCount) {
+    if (!Number.isInteger(index) || accountCount <= 0)
+        return 0;
+    return Math.max(0, Math.min(index, accountCount - 1));
+}
+function shortHash(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+async function refreshGoogleAccessToken(refreshToken) {
+    if (!GOOGLE_CLIENT_ID || !GOOGLE_CLIENT_SECRET) {
+        throw new Error("Antigravity Google OAuth credentials are not configured; set PIX_ANTIGRAVITY_GOOGLE_CLIENT_ID and PIX_ANTIGRAVITY_GOOGLE_CLIENT_SECRET.");
+    }
+    const response = await fetchWithTimeout(GOOGLE_TOKEN_REFRESH_URL, {
+        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) {
+        const errorText = await response.text();
+        throw new Error(`Google token refresh failed (${response.status}): ${errorText}`);
+    }
+    return response.json();
+}
+async function fetchGoogleAntigravityQuota(accessToken, projectId) {
+    const response = await fetchWithTimeout(GOOGLE_QUOTA_API_URL, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${accessToken}`,
+            "User-Agent": "antigravity/1.18.3 darwin/arm64",
+        },
+        body: JSON.stringify({ project: projectId }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Google quota request failed (${response.status}): ${errorText}`);
+    }
+    return response.json();
+}
+function parseResetTime(value, now) {
+    if (!value)
+        return now;
+    const resetAt = Date.parse(value);
+    return Number.isFinite(resetAt) && resetAt > now ? resetAt : now;
+}
+async function fetchOpenAIUsage(accessToken) {
+    const headers = {
+        Authorization: `Bearer ${accessToken}`,
+        "User-Agent": "pi-ui-extend/0.1.0",
+    };
+    const accountId = getAccountIdFromJwt(accessToken);
+    if (accountId)
+        headers["ChatGPT-Account-Id"] = accountId;
+    const response = await fetchWithTimeout(OPENAI_USAGE_URL, { headers });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`OpenAI usage request failed (${response.status}): ${errorText}`);
+    }
+    return response.json();
+}
+async function fetchWithTimeout(url, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+        return await fetch(url, {
+            ...options,
+            signal: controller.signal,
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            throw new Error(`Request timeout (${Math.round(REQUEST_TIMEOUT_MS / 1000)}s)`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+function getAccountIdFromJwt(token) {
+    const payload = parseJwt(token);
+    return payload?.["https://api.openai.com/auth"]?.chatgpt_account_id;
+}
+function openAIAccountEmailFromJwt(token) {
+    const payload = parseJwt(token);
+    return payload?.email || payload?.["https://api.openai.com/auth"]?.email;
+}
+function parseJwt(token) {
+    try {
+        const parts = token.split(".");
+        const payloadPart = parts[1];
+        if (parts.length !== 3 || !payloadPart)
+            return undefined;
+        const payloadJson = base64UrlDecode(payloadPart);
+        return JSON.parse(payloadJson);
+    }
+    catch {
+        return undefined;
+    }
+}
+function base64UrlDecode(input) {
+    const base64 = input.replace(/-/gu, "+").replace(/_/gu, "/");
+    const padLength = (4 - (base64.length % 4)) % 4;
+    return Buffer.from(`${base64}${"=".repeat(padLength)}`, "base64").toString("utf8");
+}
+function isRateLimitWindow(value) {
+    return value !== null && value !== undefined
+        && Number.isFinite(value.used_percent)
+        && Number.isFinite(value.limit_window_seconds)
+        && Number.isFinite(value.reset_after_seconds);
+}
+function selectOpenAIRateLimitForModel(data, modelKey) {
+    const additionalLimit = (data.additional_rate_limits ?? []).find((limit) => {
+        if (!limit.rate_limit)
+            return false;
+        return openAIModelMatchesAdditionalLimit(modelKey, limit);
+    });
+    return additionalLimit?.rate_limit ?? data.rate_limit;
+}
+function openAIModelMatchesAdditionalLimit(modelKey, limit) {
+    const normalizedModel = normalizeOpenAILimitName(modelKey.split("/").at(-1) ?? modelKey);
+    const normalizedLimitName = normalizeOpenAILimitName(limit.limit_name);
+    const normalizedMeteredFeature = limit.metered_feature ? normalizeOpenAILimitName(limit.metered_feature) : "";
+    return (!!normalizedLimitName && (normalizedModel.includes(normalizedLimitName) || normalizedLimitName.includes(normalizedModel)))
+        || (!!normalizedMeteredFeature && (normalizedModel.includes(normalizedMeteredFeature) || normalizedMeteredFeature.includes(normalizedModel)));
+}
+function normalizeOpenAILimitName(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/gu, "");
+}
+function selectWeeklyWindow(windows) {
+    return windows
+        .filter((window) => window.limit_window_seconds >= 6 * DAY_SECONDS)
+        .sort((a, b) => b.limit_window_seconds - a.limit_window_seconds)[0];
+}
+function selectHourlyWindow(windows) {
+    return windows
+        .filter((window) => window.limit_window_seconds <= 6 * HOUR_SECONDS)
+        .sort((a, b) => a.limit_window_seconds - b.limit_window_seconds)[0];
+}
+function modelUsageWindow(window, now) {
+    return {
+        remainingPercent: clampPercent(Math.round(100 - window.used_percent)),
+        resetAt: now + Math.max(0, Math.round(window.reset_after_seconds)) * 1000,
+        windowSeconds: Math.max(0, Math.round(window.limit_window_seconds)),
+    };
+}
+function accountWindowFromRateLimit(window, now) {
+    const windowSeconds = Math.max(0, Math.round(window.limit_window_seconds));
+    return {
+        label: accountWindowLabel(windowSeconds),
+        remainingPercent: clampPercent(Math.round(100 - window.used_percent)),
+        resetAt: now + Math.max(0, Math.round(window.reset_after_seconds)) * 1000,
+        windowSeconds,
+    };
+}
+function googleAccountWindowFromResponse(data, label, quotaModelKey, now) {
+    const quotaInfo = data.models[quotaModelKey]?.quotaInfo;
+    if (!quotaInfo || !Number.isFinite(quotaInfo.remainingFraction))
+        return undefined;
+    const resetAt = parseResetTime(quotaInfo.resetTime, now);
+    return {
+        label,
+        remainingPercent: clampPercent(Math.round((quotaInfo.remainingFraction ?? 0) * 100)),
+        resetAt,
+        windowSeconds: Math.max(0, Math.round((resetAt - now) / 1000)),
+    };
+}
+function clampPercent(percent) {
+    return Math.max(0, Math.min(100, percent));
+}
+function accountWindowLabel(windowSeconds) {
+    if (windowSeconds >= 6 * DAY_SECONDS)
+        return `${Math.round(windowSeconds / DAY_SECONDS)}-day limit`;
+    if (windowSeconds >= HOUR_SECONDS)
+        return `${Math.round(windowSeconds / HOUR_SECONDS)}-hour limit`;
+    return `${Math.max(1, Math.round(windowSeconds / 60))}-minute limit`;
+}
+function formatProviderWindow(window, now, width) {
+    return [
+        window.label,
+        `${formatQuotaBar(window.remainingPercent, width)} ${window.remainingPercent}% remaining`,
+        `Resets in: ${formatDurationLong(window.resetAt, now)}`,
+        "",
+    ];
+}
+function formatQuotaBar(percent, width) {
+    const filled = Math.max(0, Math.min(width, Math.round((percent / 100) * width)));
+    return `${"█".repeat(filled)}${"░".repeat(width - filled)}`;
+}
+function formatDurationLong(resetAt, now) {
+    const totalMinutes = Math.max(0, Math.ceil((resetAt - now) / 60_000));
+    const days = Math.floor(totalMinutes / 1440);
+    const hours = Math.floor((totalMinutes % 1440) / 60);
+    const minutes = totalMinutes % 60;
+    if (days > 0)
+        return `${days}d ${hours}h ${minutes}m`;
+    if (hours > 0)
+        return `${hours}h ${minutes}m`;
+    return `${minutes}m`;
+}
+function formatDurationShort(resetAt, now) {
+    const totalMinutes = Math.max(0, Math.ceil((resetAt - now) / 60_000));
+    const days = Math.floor(totalMinutes / 1440);
+    const hours = Math.floor((totalMinutes % 1440) / 60);
+    const minutes = totalMinutes % 60;
+    if (days > 0)
+        return `${days}d ${hours}h`;
+    if (hours > 0)
+        return `${hours}h ${minutes}m`;
+    return `${minutes}m`;
+}
+function maskCredential(value) {
+    const visible = value.trim();
+    if (visible.length <= 8)
+        return visible ? "****" : "unknown";
+    return `${visible.slice(0, 4)}****${visible.slice(-4)}`;
+}
+function formatUsageWindow(_prefix, window, now) {
+    return `${window.remainingPercent}% ${formatCompactProgressBar(window.remainingPercent)} ${formatResetCountdown(window.resetAt, now)}`;
+}
+function formatResetCountdown(resetAt, now) {
+    const totalMinutes = Math.max(0, Math.ceil((resetAt - now) / 60_000));
+    const days = Math.floor(totalMinutes / 1440);
+    const hours = Math.floor((totalMinutes % 1440) / 60);
+    const minutes = totalMinutes % 60;
+    if (days > 0)
+        return `${days}d${hours}h`;
+    if (hours > 0)
+        return `${hours}h${minutes}m`;
+    return `${minutes}m`;
+}