termdock 1.4.39 → 1.4.41

package/dist/server/quota/providers/claude.js

@@ -0,0 +1,125 @@
+/**
+ * Claude / Anthropic subscription quota provider.
+ *
+ * Calls `GET https://api.anthropic.com/api/oauth/usage` with the OAuth
+ * Bearer token discovered from OpenCode auth.json or Claude settings.json.
+ * Returns per-window percentages (5h, 7d, Sonnet, Opus, Fable).
+ */
+import { discoverClaudeTokens } from '../tokenDiscovery.js';
+const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
+async function fetchWithAuth(token) {
+    const headers = {
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        'User-Agent': 'termdock/1.0',
+        'anthropic-beta': 'oauth-2025-04-20',
+    };
+    const res = await fetch(USAGE_URL, { headers, signal: AbortSignal.timeout(10_000) });
+    if (res.status === 401)
+        throw new Error('Claude: token expired');
+    if (res.status === 429)
+        throw new Error('Claude: rate limited');
+    if (!res.ok)
+        throw new Error(`Claude: HTTP ${res.status}`);
+    return res.json();
+}
+export async function fetchClaudeQuota() {
+    const tokens = discoverClaudeTokens();
+    const result = {
+        slug: 'claude',
+        displayName: 'Claude',
+        usagePercent: 0,
+        windows: [],
+        fetchedAt: Date.now(),
+    };
+    if (tokens.length === 0) {
+        result.error = 'No Claude token found';
+        return result;
+    }
+    let usageData = null;
+    let lastError = '';
+    for (const t of tokens) {
+        try {
+            usageData = await fetchWithAuth(t.token);
+            break;
+        }
+        catch (e) {
+            lastError = e instanceof Error ? e.message : String(e);
+        }
+    }
+    if (!usageData) {
+        result.error = lastError || 'Failed to fetch Claude usage';
+        return result;
+    }
+    const windows = [];
+    let worstPercent = 0;
+    // 5-hour burst window
+    if (usageData.five_hour) {
+        const pct = usageData.five_hour.utilization;
+        windows.push({
+            label: '5-hour',
+            percent: pct,
+            resetAt: usageData.five_hour.resets_at,
+            windowLabel: '5h',
+        });
+        if (pct > worstPercent)
+            worstPercent = pct;
+    }
+    // 7-day rolling window (main quota)
+    if (usageData.seven_day) {
+        const pct = usageData.seven_day.utilization;
+        windows.push({
+            label: '7-day',
+            percent: pct,
+            resetAt: usageData.seven_day.resets_at,
+            windowLabel: '7d',
+        });
+        if (pct > worstPercent)
+            worstPercent = pct;
+    }
+    // Sonnet sub-quota
+    if (usageData.seven_day_sonnet) {
+        const pct = usageData.seven_day_sonnet.utilization;
+        windows.push({
+            label: 'Sonnet',
+            percent: pct,
+            resetAt: usageData.seven_day_sonnet.resets_at,
+            windowLabel: '7d',
+        });
+    }
+    // Opus sub-quota
+    if (usageData.seven_day_opus) {
+        windows.push({
+            label: 'Opus',
+            percent: usageData.seven_day_opus.utilization,
+            resetAt: usageData.seven_day_opus.resets_at,
+            windowLabel: '7d',
+        });
+    }
+    // Fable weekly (from limits array)
+    if (usageData.limits) {
+        const fable = usageData.limits.find((l) => l.kind === 'weekly_scoped' &&
+            l.scope?.model?.display_name?.toLowerCase() === 'fable');
+        if (fable?.percent !== undefined) {
+            windows.push({
+                label: 'Fable',
+                percent: fable.percent,
+                resetAt: fable.resets_at,
+                windowLabel: '7d',
+            });
+        }
+    }
+    result.windows = windows;
+    result.usagePercent = Math.round(worstPercent);
+    result.remaining = Math.max(0, 100 - worstPercent);
+    result.entitlement = 100;
+    // Use the 7-day reset as the primary
+    if (usageData.seven_day?.resets_at) {
+        result.resetAt = usageData.seven_day.resets_at;
+    }
+    return result;
+}
+export function isClaudeAvailable() {
+    return discoverClaudeTokens().length > 0;
+}

package/dist/server/quota/providers/codex.js

@@ -0,0 +1,175 @@
+/**
+ * Codex / OpenAI subscription quota provider.
+ *
+ * Quota sources (tried in order):
+ * 1. chatgpt.com/backend-api/wham/usage — ChatGPT Plus/Pro web subscription
+ * 2. api.openai.com/v1/organization/usage — API platform billing
+ *
+ * Tokens discovered from: ~/.codex/auth.json > OpenCode auth.json > env vars.
+ */
+import { discoverCodexTokens } from '../tokenDiscovery.js';
+const WHAM_URL = 'https://chatgpt.com/backend-api/wham/usage';
+const API_BILLING_URL = 'https://api.openai.com/v1/organization/usage';
+const ORG_LIST_URL = 'https://api.openai.com/v1/organizations';
+async function fetchWham(token) {
+    const res = await fetch(WHAM_URL, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: 'application/json',
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
+        },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!res.ok)
+        return null;
+    return res.json();
+}
+async function fetchApiBilling(token) {
+    let orgId = '';
+    try {
+        const orgRes = await fetch(ORG_LIST_URL, {
+            headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' },
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (orgRes.ok) {
+            const orgs = await orgRes.json();
+            orgId = orgs.data?.[0]?.id || '';
+        }
+    }
+    catch { /* optional */ }
+    const res = await fetch(API_BILLING_URL, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: 'application/json',
+            ...(orgId ? { 'OpenAI-Organization': orgId } : {}),
+        },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!res.ok)
+        return null;
+    const data = await res.json();
+    return data.data?.[0]?.usage_tokens ?? null;
+}
+// ── Helpers ──
+function unixToISO(ts) {
+    if (!ts)
+        return undefined;
+    return new Date(ts * 1000).toISOString();
+}
+function windowLabelFromSeconds(seconds) {
+    if (!seconds)
+        return '';
+    if (seconds <= 3600)
+        return 'Hourly';
+    if (seconds <= 86400)
+        return 'Daily';
+    if (seconds <= 604800)
+        return 'Weekly';
+    return 'Monthly';
+}
+function collectWindows(rateLimit, prefix = '') {
+    const results = [];
+    const add = (label, w) => {
+        if (!w)
+            return;
+        results.push({
+            label: prefix ? `${prefix} ${label}` : label,
+            percent: w.used_percent,
+            resetAt: unixToISO(w.reset_at),
+            windowLabel: windowLabelFromSeconds(w.limit_window_seconds),
+        });
+    };
+    add('Primary', rateLimit?.primary_window);
+    add('Secondary', rateLimit?.secondary_window);
+    return results;
+}
+// ── Main fetch ──
+export async function fetchCodexQuota() {
+    const tokens = discoverCodexTokens();
+    const result = {
+        slug: 'codex',
+        displayName: 'Codex',
+        usagePercent: 0,
+        windows: [],
+        fetchedAt: Date.now(),
+    };
+    if (tokens.length === 0) {
+        result.error = 'No token found';
+        return result;
+    }
+    for (const t of tokens) {
+        // Strategy 1: wham endpoint (ChatGPT Plus/Pro subscription)
+        try {
+            const wham = await fetchWham(t.token);
+            if (wham) {
+                const windows = [];
+                let worstPct = 0;
+                // Main rate limit
+                windows.push(...collectWindows(wham.rate_limit));
+                // Code review rate limit (separate quota for code review feature)
+                windows.push(...collectWindows(wham.code_review_rate_limit, 'Review'));
+                // Additional rate limits (GPT-5, image gen, etc.)
+                if (wham.additional_rate_limits) {
+                    for (const [kind, rl] of Object.entries(wham.additional_rate_limits)) {
+                        if (rl && (rl.primary_window || rl.secondary_window)) {
+                            windows.push(...collectWindows(rl, kind));
+                        }
+                    }
+                }
+                if (windows.length > 0) {
+                    for (const w of windows) {
+                        if (w.percent > worstPct)
+                            worstPct = w.percent;
+                    }
+                    // Add plan type / credit info as context
+                    if (wham.plan_type) {
+                        const planLabel = wham.plan_type === 'plus' ? 'ChatGPT Plus'
+                            : wham.plan_type === 'pro' ? 'ChatGPT Pro'
+                                : wham.plan_type === 'free' ? 'ChatGPT Free'
+                                    : wham.plan_type;
+                        // Prepend plan as first window entry
+                        windows.unshift({
+                            label: planLabel,
+                            percent: 0,
+                            windowLabel: wham.credits?.unlimited ? 'unlimited' : undefined,
+                        });
+                    }
+                    result.windows = windows;
+                    result.usagePercent = Math.round(worstPct);
+                    result.remaining = Math.max(0, 100 - worstPct);
+                    result.entitlement = 100;
+                    // Use primary reset time
+                    if (wham.rate_limit?.primary_window?.reset_at) {
+                        result.resetAt = unixToISO(wham.rate_limit.primary_window.reset_at);
+                    }
+                    return result;
+                }
+            }
+        }
+        catch {
+            // Fall through to next strategy
+        }
+        // Strategy 2: API billing endpoint
+        try {
+            const usageTokens = await fetchApiBilling(t.token);
+            if (usageTokens !== null) {
+                result.windows = [{
+                        label: 'API Usage',
+                        percent: 0,
+                        windowLabel: usageTokens >= 1_000_000
+                            ? `${(usageTokens / 1_000_000).toFixed(1)}M tokens`
+                            : `${usageTokens.toLocaleString()} tokens`,
+                    }];
+                return result;
+            }
+        }
+        catch {
+            // Continue
+        }
+    }
+    result.error = 'Unable to fetch Codex quota. If you use ChatGPT Plus, login via Codex CLI (`codex login`).';
+    return result;
+}
+export function isCodexAvailable() {
+    return discoverCodexTokens().length > 0;
+}

package/dist/server/quota/providers/copilot.js

@@ -0,0 +1,125 @@
+/**
+ * GitHub Copilot subscription quota provider.
+ *
+ * Copilot's usage API is internal (not publicly documented). We attempt
+ * multiple endpoints that the Copilot extension and CLI use.
+ */
+import { discoverCopilotTokens } from '../tokenDiscovery.js';
+const COPILOT_CHAT_USAGE = 'https://api.github.com/copilot/usage';
+const COPILOT_QUOTA = 'https://api.github.com/user/copilot/quotas';
+async function fetchWithAuth(token) {
+    const headers = {
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/json',
+        'User-Agent': 'termdock/1.0',
+        'X-GitHub-Api-Version': '2022-11-28',
+    };
+    // Try the quotas endpoint first
+    for (const url of [COPILOT_QUOTA, COPILOT_CHAT_USAGE]) {
+        try {
+            const res = await fetch(url, {
+                headers,
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (res.ok) {
+                return res.json();
+            }
+            if (res.status === 401)
+                throw new Error('Copilot: token expired');
+            if (res.status === 403)
+                continue; // might not have copilot access
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.startsWith('Copilot:'))
+                throw e;
+        }
+    }
+    return null;
+}
+export async function fetchCopilotQuota() {
+    const tokens = discoverCopilotTokens();
+    const result = {
+        slug: 'copilot',
+        displayName: 'GitHub Copilot',
+        usagePercent: 0,
+        windows: [],
+        fetchedAt: Date.now(),
+    };
+    if (tokens.length === 0) {
+        result.error = 'No GitHub Copilot token found';
+        return result;
+    }
+    let data = null;
+    let lastError = '';
+    for (const t of tokens) {
+        try {
+            data = await fetchWithAuth(t.token);
+            if (data)
+                break;
+        }
+        catch (e) {
+            lastError = e instanceof Error ? e.message : String(e);
+        }
+    }
+    if (!data) {
+        result.error = lastError || 'Failed to fetch Copilot usage';
+        return result;
+    }
+    const windows = [];
+    let worstPercent = 0;
+    let totalRemaining = 0;
+    let totalEntitlement = 0;
+    if (data.chat) {
+        const used = data.chat.used || 0;
+        const limit = data.chat.limit || 0;
+        if (limit > 0) {
+            const pct = (used / limit) * 100;
+            windows.push({
+                label: 'Chat',
+                percent: Math.round(pct * 10) / 10,
+                windowLabel: 'monthly',
+            });
+            if (pct > worstPercent)
+                worstPercent = pct;
+            totalRemaining += Math.max(0, limit - used);
+            totalEntitlement += limit;
+        }
+    }
+    if (data.completions) {
+        const used = data.completions.used || 0;
+        const limit = data.completions.limit || 0;
+        if (limit > 0) {
+            const pct = (used / limit) * 100;
+            windows.push({
+                label: 'Completions',
+                percent: Math.round(pct * 10) / 10,
+                windowLabel: 'monthly',
+            });
+            if (pct > worstPercent)
+                worstPercent = pct;
+            totalRemaining += Math.max(0, limit - used);
+            totalEntitlement += limit;
+        }
+    }
+    if (data.overage) {
+        if (data.overage.cost !== undefined) {
+            windows.push({
+                label: 'Overage',
+                percent: 0,
+                windowLabel: `$${data.overage.cost.toFixed(2)}`,
+            });
+        }
+    }
+    if (windows.length === 0) {
+        result.error = 'Copilot API returned no usage data';
+        return result;
+    }
+    result.windows = windows;
+    result.usagePercent = Math.round(worstPercent);
+    result.remaining = totalRemaining || undefined;
+    result.entitlement = totalEntitlement || undefined;
+    return result;
+}
+export function isCopilotAvailable() {
+    return discoverCopilotTokens().length > 0;
+}

package/dist/server/quota/providers/gemini.js

@@ -0,0 +1,52 @@
+/**
+ * Gemini CLI subscription quota provider.
+ *
+ * Attempts Google Cloud / Gemini API usage endpoint.
+ */
+import { discoverGeminiTokens } from '../tokenDiscovery.js';
+const USAGE_URL = 'https://generativelanguage.googleapis.com/v1beta/openai/usage';
+async function fetchWithAuth(token) {
+    const res = await fetch(USAGE_URL, {
+        headers: {
+            'x-goog-api-key': token,
+            Accept: 'application/json',
+            'User-Agent': 'termdock/1.0',
+        },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (res.status === 401 || res.status === 403)
+        throw new Error('Gemini: unauthorized');
+    if (!res.ok)
+        throw new Error(`Gemini: HTTP ${res.status}`);
+    return res.json();
+}
+export async function fetchGeminiQuota() {
+    const tokens = discoverGeminiTokens();
+    const result = {
+        slug: 'gemini',
+        displayName: 'Gemini',
+        usagePercent: 0,
+        windows: [],
+        fetchedAt: Date.now(),
+    };
+    if (tokens.length === 0) {
+        result.error = 'No Gemini API key found';
+        return result;
+    }
+    // Gemini free-tier quotas are rate-limit based, not percentage-based.
+    // The API key alone confirms the user has access.
+    // For now show a simple "active" indicator; real quota needs OAuth.
+    try {
+        await fetchWithAuth(tokens[0].token);
+        result.windows = [{ label: 'API', percent: 0, windowLabel: 'active' }];
+        result.remaining = undefined;
+        result.entitlement = undefined;
+    }
+    catch (e) {
+        result.error = e instanceof Error ? e.message : 'Gemini fetch failed';
+    }
+    return result;
+}
+export function isGeminiAvailable() {
+    return discoverGeminiTokens().length > 0;
+}

package/dist/server/quota/providers/grok.js

@@ -0,0 +1,76 @@
+/**
+ * Grok (xAI) subscription quota provider.
+ */
+import { discoverGrokTokens } from '../tokenDiscovery.js';
+const USAGE_URL = 'https://api.x.ai/v1/usage';
+async function fetchWithAuth(token) {
+    const res = await fetch(USAGE_URL, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: 'application/json',
+            'User-Agent': 'termdock/1.0',
+        },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (res.status === 401)
+        throw new Error('Grok: token expired');
+    if (!res.ok)
+        throw new Error(`Grok: HTTP ${res.status}`);
+    return res.json();
+}
+export async function fetchGrokQuota() {
+    const tokens = discoverGrokTokens();
+    const result = {
+        slug: 'grok',
+        displayName: 'Grok',
+        usagePercent: 0,
+        windows: [],
+        fetchedAt: Date.now(),
+    };
+    if (tokens.length === 0) {
+        result.error = 'No Grok API key found';
+        return result;
+    }
+    let data = null;
+    let lastError = '';
+    for (const t of tokens) {
+        try {
+            data = await fetchWithAuth(t.token);
+            break;
+        }
+        catch (e) {
+            lastError = e instanceof Error ? e.message : String(e);
+        }
+    }
+    if (!data?.usage) {
+        result.error = lastError || 'No Grok usage data';
+        return result;
+    }
+    const windows = [];
+    const usage = data.usage;
+    if (usage.monthly_percent !== undefined) {
+        windows.push({
+            label: 'Monthly',
+            percent: usage.monthly_percent,
+            resetAt: usage.monthly_reset,
+            windowLabel: 'monthly',
+        });
+    }
+    if (usage.model_breakdown) {
+        for (const [model, pct] of Object.entries(usage.model_breakdown)) {
+            windows.push({
+                label: model,
+                percent: pct,
+                windowLabel: 'model',
+            });
+        }
+    }
+    result.windows = windows;
+    result.usagePercent = Math.round(windows.length > 0 ? usage.monthly_percent || 0 : 0);
+    result.remaining = Math.max(0, 100 - result.usagePercent);
+    result.entitlement = 100;
+    return result;
+}
+export function isGrokAvailable() {
+    return discoverGrokTokens().length > 0;
+}

package/dist/server/quota/providers/kimi.js

@@ -0,0 +1,113 @@
+/**
+ * Kimi (Moonshot) subscription quota provider.
+ *
+ * Calls `GET https://api.kimi.com/coding/v1/usages` with the API key
+ * discovered from env or kimi-code config.
+ */
+import { discoverKimiTokens } from '../tokenDiscovery.js';
+const USAGE_URL = 'https://api.kimi.com/coding/v1/usages';
+async function fetchWithAuth(token) {
+    const res = await fetch(USAGE_URL, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+            'User-Agent': 'termdock/1.0',
+        },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (res.status === 401)
+        throw new Error('Kimi: token expired');
+    if (!res.ok)
+        throw new Error(`Kimi: HTTP ${res.status}`);
+    return res.json();
+}
+export async function fetchKimiQuota() {
+    const tokens = discoverKimiTokens();
+    const result = {
+        slug: 'kimi',
+        displayName: 'Kimi',
+        usagePercent: 0,
+        windows: [],
+        fetchedAt: Date.now(),
+    };
+    if (tokens.length === 0) {
+        result.error = 'No Kimi API key found';
+        return result;
+    }
+    let data = null;
+    let lastError = '';
+    for (const t of tokens) {
+        try {
+            data = await fetchWithAuth(t.token);
+            break;
+        }
+        catch (e) {
+            lastError = e instanceof Error ? e.message : String(e);
+        }
+    }
+    if (!data) {
+        result.error = lastError || 'Failed to fetch Kimi usage';
+        return result;
+    }
+    const windows = [];
+    let worstPercent = 0;
+    // Main usage
+    const usage = data.usage;
+    if (usage) {
+        const limit = parseInt(usage.limit || '0', 10);
+        const used = parseInt(usage.used || '0', 10);
+        const remaining = parseInt(usage.remaining || '0', 10);
+        if (limit > 0) {
+            const pct = (used / limit) * 100;
+            windows.push({
+                label: 'Token',
+                percent: Math.round(pct * 10) / 10,
+                resetAt: usage.resetTime,
+                windowLabel: 'total',
+            });
+            if (pct > worstPercent)
+                worstPercent = pct;
+            result.remaining = remaining;
+            result.entitlement = limit;
+        }
+    }
+    // Per-window limits
+    if (data.limits) {
+        for (const limit of data.limits) {
+            if (limit.detail) {
+                const d = limit.detail;
+                const detailLimit = parseInt(d.limit || '0', 10);
+                const detailUsed = parseInt(d.used || '0', 10);
+                if (detailLimit > 0) {
+                    const pct = (detailUsed / detailLimit) * 100;
+                    const w = limit.window;
+                    const label = w
+                        ? `${w.duration || ''}${w.timeUnit || ''}`.replace(/^(\d+)([a-z])/, '$1$2')
+                        : 'Window';
+                    windows.push({
+                        label,
+                        percent: Math.round(pct * 10) / 10,
+                        resetAt: d.resetTime,
+                        windowLabel: label,
+                    });
+                }
+            }
+        }
+    }
+    if (windows.length === 0) {
+        result.error = 'Kimi API returned no usage data';
+        return result;
+    }
+    result.windows = windows;
+    result.usagePercent = Math.round(worstPercent);
+    if (!result.entitlement) {
+        result.usagePercent = Math.round(worstPercent);
+        result.remaining = Math.max(0, 100 - worstPercent);
+        result.entitlement = 100;
+    }
+    return result;
+}
+export function isKimiAvailable() {
+    return discoverKimiTokens().length > 0;
+}