@intent-systems/nexus 2026.1.5-3

package/dist/infra/provider-usage.fetch.claude.js

@@ -0,0 +1,129 @@
+import { fetchJson } from "./provider-usage.fetch.shared.js";
+import { clampPercent, PROVIDER_LABELS } from "./provider-usage.shared.js";
+function resolveClaudeWebSessionKey() {
+    const direct = process.env.CLAUDE_AI_SESSION_KEY?.trim() ?? process.env.CLAUDE_WEB_SESSION_KEY?.trim();
+    if (direct?.startsWith("sk-ant-"))
+        return direct;
+    const cookieHeader = process.env.CLAUDE_WEB_COOKIE?.trim();
+    if (!cookieHeader)
+        return undefined;
+    const stripped = cookieHeader.replace(/^cookie:\\s*/i, "");
+    const match = stripped.match(/(?:^|;\\s*)sessionKey=([^;\\s]+)/i);
+    const value = match?.[1]?.trim();
+    return value?.startsWith("sk-ant-") ? value : undefined;
+}
+async function fetchClaudeWebUsage(sessionKey, timeoutMs, fetchFn) {
+    const headers = {
+        Cookie: `sessionKey=${sessionKey}`,
+        Accept: "application/json",
+    };
+    const orgRes = await fetchJson("https://claude.ai/api/organizations", { headers }, timeoutMs, fetchFn);
+    if (!orgRes.ok)
+        return null;
+    const orgs = (await orgRes.json());
+    const orgId = orgs?.[0]?.uuid?.trim();
+    if (!orgId)
+        return null;
+    const usageRes = await fetchJson(`https://claude.ai/api/organizations/${orgId}/usage`, { headers }, timeoutMs, fetchFn);
+    if (!usageRes.ok)
+        return null;
+    const data = (await usageRes.json());
+    const windows = [];
+    if (data.five_hour?.utilization !== undefined) {
+        windows.push({
+            label: "5h",
+            usedPercent: clampPercent(data.five_hour.utilization),
+            resetAt: data.five_hour.resets_at ? new Date(data.five_hour.resets_at).getTime() : undefined,
+        });
+    }
+    if (data.seven_day?.utilization !== undefined) {
+        windows.push({
+            label: "Week",
+            usedPercent: clampPercent(data.seven_day.utilization),
+            resetAt: data.seven_day.resets_at ? new Date(data.seven_day.resets_at).getTime() : undefined,
+        });
+    }
+    const modelWindow = data.seven_day_sonnet || data.seven_day_opus;
+    if (modelWindow?.utilization !== undefined) {
+        windows.push({
+            label: data.seven_day_sonnet ? "Sonnet" : "Opus",
+            usedPercent: clampPercent(modelWindow.utilization),
+        });
+    }
+    if (windows.length === 0)
+        return null;
+    return {
+        provider: "anthropic",
+        displayName: PROVIDER_LABELS.anthropic,
+        windows,
+    };
+}
+export async function fetchClaudeUsage(token, timeoutMs, fetchFn) {
+    const res = await fetchJson("https://api.anthropic.com/api/oauth/usage", {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "User-Agent": "nexus",
+            Accept: "application/json",
+            "anthropic-version": "2023-06-01",
+            "anthropic-beta": "oauth-2025-04-20",
+        },
+    }, timeoutMs, fetchFn);
+    if (!res.ok) {
+        let message;
+        try {
+            const data = (await res.json());
+            const raw = data?.error?.message;
+            if (typeof raw === "string" && raw.trim())
+                message = raw.trim();
+        }
+        catch {
+            // ignore parse errors
+        }
+        // Claude CLI setup-token yields tokens that can be used for inference, but may not
+        // include user:profile scope required by the OAuth usage endpoint. When a claude.ai
+        // browser sessionKey is available, fall back to the web API.
+        if (res.status === 403 && message?.includes("scope requirement user:profile")) {
+            const sessionKey = resolveClaudeWebSessionKey();
+            if (sessionKey) {
+                const web = await fetchClaudeWebUsage(sessionKey, timeoutMs, fetchFn);
+                if (web)
+                    return web;
+            }
+        }
+        const suffix = message ? `: ${message}` : "";
+        return {
+            provider: "anthropic",
+            displayName: PROVIDER_LABELS.anthropic,
+            windows: [],
+            error: `HTTP ${res.status}${suffix}`,
+        };
+    }
+    const data = (await res.json());
+    const windows = [];
+    if (data.five_hour?.utilization !== undefined) {
+        windows.push({
+            label: "5h",
+            usedPercent: clampPercent(data.five_hour.utilization),
+            resetAt: data.five_hour.resets_at ? new Date(data.five_hour.resets_at).getTime() : undefined,
+        });
+    }
+    if (data.seven_day?.utilization !== undefined) {
+        windows.push({
+            label: "Week",
+            usedPercent: clampPercent(data.seven_day.utilization),
+            resetAt: data.seven_day.resets_at ? new Date(data.seven_day.resets_at).getTime() : undefined,
+        });
+    }
+    const modelWindow = data.seven_day_sonnet || data.seven_day_opus;
+    if (modelWindow?.utilization !== undefined) {
+        windows.push({
+            label: data.seven_day_sonnet ? "Sonnet" : "Opus",
+            usedPercent: clampPercent(modelWindow.utilization),
+        });
+    }
+    return {
+        provider: "anthropic",
+        displayName: PROVIDER_LABELS.anthropic,
+        windows,
+    };
+}

package/dist/infra/provider-usage.fetch.codex.js

@@ -0,0 +1,62 @@
+import { fetchJson } from "./provider-usage.fetch.shared.js";
+import { clampPercent, PROVIDER_LABELS } from "./provider-usage.shared.js";
+export async function fetchCodexUsage(token, accountId, timeoutMs, fetchFn) {
+    const headers = {
+        Authorization: `Bearer ${token}`,
+        "User-Agent": "CodexBar",
+        Accept: "application/json",
+    };
+    if (accountId)
+        headers["ChatGPT-Account-Id"] = accountId;
+    const res = await fetchJson("https://chatgpt.com/backend-api/wham/usage", { method: "GET", headers }, timeoutMs, fetchFn);
+    if (res.status === 401 || res.status === 403) {
+        return {
+            provider: "openai-codex",
+            displayName: PROVIDER_LABELS["openai-codex"],
+            windows: [],
+            error: "Token expired",
+        };
+    }
+    if (!res.ok) {
+        return {
+            provider: "openai-codex",
+            displayName: PROVIDER_LABELS["openai-codex"],
+            windows: [],
+            error: `HTTP ${res.status}`,
+        };
+    }
+    const data = (await res.json());
+    const windows = [];
+    if (data.rate_limit?.primary_window) {
+        const pw = data.rate_limit.primary_window;
+        const windowHours = Math.round((pw.limit_window_seconds || 10800) / 3600);
+        windows.push({
+            label: `${windowHours}h`,
+            usedPercent: clampPercent(pw.used_percent || 0),
+            resetAt: pw.reset_at ? pw.reset_at * 1000 : undefined,
+        });
+    }
+    if (data.rate_limit?.secondary_window) {
+        const sw = data.rate_limit.secondary_window;
+        const windowHours = Math.round((sw.limit_window_seconds || 86400) / 3600);
+        const label = windowHours >= 24 ? "Day" : `${windowHours}h`;
+        windows.push({
+            label,
+            usedPercent: clampPercent(sw.used_percent || 0),
+            resetAt: sw.reset_at ? sw.reset_at * 1000 : undefined,
+        });
+    }
+    let plan = data.plan_type;
+    if (data.credits?.balance !== undefined && data.credits.balance !== null) {
+        const balance = typeof data.credits.balance === "number"
+            ? data.credits.balance
+            : parseFloat(data.credits.balance) || 0;
+        plan = plan ? `${plan} ($${balance.toFixed(2)})` : `$${balance.toFixed(2)}`;
+    }
+    return {
+        provider: "openai-codex",
+        displayName: PROVIDER_LABELS["openai-codex"],
+        windows,
+        plan,
+    };
+}

package/dist/infra/provider-usage.fetch.copilot.js

@@ -0,0 +1,42 @@
+import { fetchJson } from "./provider-usage.fetch.shared.js";
+import { clampPercent, PROVIDER_LABELS } from "./provider-usage.shared.js";
+export async function fetchCopilotUsage(token, timeoutMs, fetchFn) {
+    const res = await fetchJson("https://api.github.com/copilot_internal/user", {
+        headers: {
+            Authorization: `token ${token}`,
+            "Editor-Version": "vscode/1.96.2",
+            "User-Agent": "GitHubCopilotChat/0.26.7",
+            "X-Github-Api-Version": "2025-04-01",
+        },
+    }, timeoutMs, fetchFn);
+    if (!res.ok) {
+        return {
+            provider: "github-copilot",
+            displayName: PROVIDER_LABELS["github-copilot"],
+            windows: [],
+            error: `HTTP ${res.status}`,
+        };
+    }
+    const data = (await res.json());
+    const windows = [];
+    if (data.quota_snapshots?.premium_interactions) {
+        const remaining = data.quota_snapshots.premium_interactions.percent_remaining;
+        windows.push({
+            label: "Premium",
+            usedPercent: clampPercent(100 - (remaining ?? 0)),
+        });
+    }
+    if (data.quota_snapshots?.chat) {
+        const remaining = data.quota_snapshots.chat.percent_remaining;
+        windows.push({
+            label: "Chat",
+            usedPercent: clampPercent(100 - (remaining ?? 0)),
+        });
+    }
+    return {
+        provider: "github-copilot",
+        displayName: PROVIDER_LABELS["github-copilot"],
+        windows,
+        plan: data.copilot_plan,
+    };
+}

package/dist/infra/provider-usage.fetch.gemini.js

@@ -0,0 +1,57 @@
+import { fetchJson } from "./provider-usage.fetch.shared.js";
+import { clampPercent, PROVIDER_LABELS } from "./provider-usage.shared.js";
+export async function fetchGeminiUsage(token, timeoutMs, fetchFn, provider) {
+    const res = await fetchJson("https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota", {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+        },
+        body: "{}",
+    }, timeoutMs, fetchFn);
+    if (!res.ok) {
+        return {
+            provider,
+            displayName: PROVIDER_LABELS[provider],
+            windows: [],
+            error: `HTTP ${res.status}`,
+        };
+    }
+    const data = (await res.json());
+    const quotas = {};
+    for (const bucket of data.buckets || []) {
+        const model = bucket.modelId || "unknown";
+        const frac = bucket.remainingFraction ?? 1;
+        if (!quotas[model] || frac < quotas[model])
+            quotas[model] = frac;
+    }
+    const windows = [];
+    let proMin = 1;
+    let flashMin = 1;
+    let hasPro = false;
+    let hasFlash = false;
+    for (const [model, frac] of Object.entries(quotas)) {
+        const lower = model.toLowerCase();
+        if (lower.includes("pro")) {
+            hasPro = true;
+            if (frac < proMin)
+                proMin = frac;
+        }
+        if (lower.includes("flash")) {
+            hasFlash = true;
+            if (frac < flashMin)
+                flashMin = frac;
+        }
+    }
+    if (hasPro)
+        windows.push({
+            label: "Pro",
+            usedPercent: clampPercent((1 - proMin) * 100),
+        });
+    if (hasFlash)
+        windows.push({
+            label: "Flash",
+            usedPercent: clampPercent((1 - flashMin) * 100),
+        });
+    return { provider, displayName: PROVIDER_LABELS[provider], windows };
+}

package/dist/infra/provider-usage.fetch.js

@@ -0,0 +1,6 @@
+export { fetchClaudeUsage } from "./provider-usage.fetch.claude.js";
+export { fetchCodexUsage } from "./provider-usage.fetch.codex.js";
+export { fetchCopilotUsage } from "./provider-usage.fetch.copilot.js";
+export { fetchGeminiUsage } from "./provider-usage.fetch.gemini.js";
+export { fetchMinimaxUsage } from "./provider-usage.fetch.minimax.js";
+export { fetchZaiUsage } from "./provider-usage.fetch.zai.js";

package/dist/infra/provider-usage.fetch.minimax.js

@@ -0,0 +1,214 @@
+import { fetchJson } from "./provider-usage.fetch.shared.js";
+import { clampPercent, PROVIDER_LABELS } from "./provider-usage.shared.js";
+const RESET_KEYS = [
+    "reset_at",
+    "resetAt",
+    "reset_time",
+    "resetTime",
+    "expires_at",
+    "expiresAt",
+    "expire_at",
+    "expireAt",
+    "end_time",
+    "endTime",
+    "window_end",
+    "windowEnd",
+];
+const PERCENT_KEYS = [
+    "used_percent",
+    "usedPercent",
+    "usage_percent",
+    "usagePercent",
+    "used_rate",
+    "usage_rate",
+    "used_ratio",
+    "usage_ratio",
+    "usedRatio",
+    "usageRatio",
+];
+const USED_KEYS = [
+    "used",
+    "usage",
+    "used_amount",
+    "usedAmount",
+    "used_tokens",
+    "usedTokens",
+    "used_quota",
+    "usedQuota",
+    "used_times",
+    "usedTimes",
+    "consumed",
+];
+const TOTAL_KEYS = [
+    "total",
+    "total_amount",
+    "totalAmount",
+    "total_tokens",
+    "totalTokens",
+    "total_quota",
+    "totalQuota",
+    "total_times",
+    "totalTimes",
+    "limit",
+    "quota",
+    "quota_limit",
+    "quotaLimit",
+    "max",
+];
+const REMAINING_KEYS = [
+    "remain",
+    "remaining",
+    "remain_amount",
+    "remainingAmount",
+    "remaining_amount",
+    "remain_tokens",
+    "remainingTokens",
+    "remaining_tokens",
+    "remain_quota",
+    "remainingQuota",
+    "remaining_quota",
+    "remain_times",
+    "remainingTimes",
+    "remaining_times",
+    "left",
+];
+const PLAN_KEYS = ["plan", "plan_name", "planName", "product", "tier"];
+const WINDOW_HOUR_KEYS = [
+    "window_hours",
+    "windowHours",
+    "duration_hours",
+    "durationHours",
+    "hours",
+];
+const WINDOW_MINUTE_KEYS = [
+    "window_minutes",
+    "windowMinutes",
+    "duration_minutes",
+    "durationMinutes",
+    "minutes",
+];
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function pickNumber(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "number" && Number.isFinite(value))
+            return value;
+        if (typeof value === "string") {
+            const parsed = Number.parseFloat(value);
+            if (Number.isFinite(parsed))
+                return parsed;
+        }
+    }
+    return undefined;
+}
+function pickString(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+function parseEpoch(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        if (value < 1e12)
+            return Math.floor(value * 1000);
+        return Math.floor(value);
+    }
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Date.parse(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function deriveWindowLabel(payload) {
+    const hours = pickNumber(payload, WINDOW_HOUR_KEYS);
+    if (hours && Number.isFinite(hours))
+        return `${hours}h`;
+    const minutes = pickNumber(payload, WINDOW_MINUTE_KEYS);
+    if (minutes && Number.isFinite(minutes))
+        return `${minutes}m`;
+    return "5h";
+}
+function deriveUsedPercent(payload) {
+    const percentRaw = pickNumber(payload, PERCENT_KEYS);
+    if (percentRaw !== undefined) {
+        const normalized = percentRaw <= 1 ? percentRaw * 100 : percentRaw;
+        return clampPercent(normalized);
+    }
+    const total = pickNumber(payload, TOTAL_KEYS);
+    if (!total || total <= 0)
+        return null;
+    let used = pickNumber(payload, USED_KEYS);
+    if (used === undefined) {
+        const remaining = pickNumber(payload, REMAINING_KEYS);
+        if (remaining !== undefined)
+            used = total - remaining;
+    }
+    if (used === undefined || !Number.isFinite(used))
+        return null;
+    return clampPercent((used / total) * 100);
+}
+export async function fetchMinimaxUsage(apiKey, timeoutMs, fetchFn) {
+    const res = await fetchJson("https://api.minimax.io/v1/coding_plan/remains", {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+            "MM-API-Source": "Nexus",
+        },
+    }, timeoutMs, fetchFn);
+    if (!res.ok) {
+        return {
+            provider: "minimax",
+            displayName: PROVIDER_LABELS.minimax,
+            windows: [],
+            error: `HTTP ${res.status}`,
+        };
+    }
+    const data = (await res.json().catch(() => null));
+    if (!isRecord(data)) {
+        return {
+            provider: "minimax",
+            displayName: PROVIDER_LABELS.minimax,
+            windows: [],
+            error: "Invalid JSON",
+        };
+    }
+    const baseResp = isRecord(data.base_resp) ? data.base_resp : undefined;
+    if (baseResp && typeof baseResp.status_code === "number" && baseResp.status_code !== 0) {
+        return {
+            provider: "minimax",
+            displayName: PROVIDER_LABELS.minimax,
+            windows: [],
+            error: baseResp.status_msg?.trim() || "API error",
+        };
+    }
+    const payload = isRecord(data.data) ? data.data : data;
+    const usedPercent = deriveUsedPercent(payload);
+    if (usedPercent === null) {
+        return {
+            provider: "minimax",
+            displayName: PROVIDER_LABELS.minimax,
+            windows: [],
+            error: "Unsupported response shape",
+        };
+    }
+    const resetAt = parseEpoch(pickString(payload, RESET_KEYS)) ?? parseEpoch(pickNumber(payload, RESET_KEYS));
+    const windows = [
+        {
+            label: deriveWindowLabel(payload),
+            usedPercent,
+            resetAt,
+        },
+    ];
+    return {
+        provider: "minimax",
+        displayName: PROVIDER_LABELS.minimax,
+        windows,
+        plan: pickString(payload, PLAN_KEYS),
+    };
+}

package/dist/infra/provider-usage.fetch.shared.js

@@ -0,0 +1,11 @@
+export async function fetchJson(url, init, timeoutMs, fetchFn) {
+    const controller = new AbortController();
+    const timeout = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 10_000;
+    const handle = setTimeout(() => controller.abort(), timeout);
+    try {
+        return await fetchFn(url, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(handle);
+    }
+}

package/dist/infra/provider-usage.fetch.zai.js

@@ -0,0 +1,62 @@
+import { fetchJson } from "./provider-usage.fetch.shared.js";
+import { clampPercent, PROVIDER_LABELS } from "./provider-usage.shared.js";
+export async function fetchZaiUsage(apiKey, timeoutMs, fetchFn) {
+    const res = await fetchJson("https://api.z.ai/api/monitor/usage/quota/limit", {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            Accept: "application/json",
+        },
+    }, timeoutMs, fetchFn);
+    if (!res.ok) {
+        return {
+            provider: "zai",
+            displayName: PROVIDER_LABELS.zai,
+            windows: [],
+            error: `HTTP ${res.status}`,
+        };
+    }
+    const data = (await res.json());
+    if (!data.success || data.code !== 200) {
+        return {
+            provider: "zai",
+            displayName: PROVIDER_LABELS.zai,
+            windows: [],
+            error: data.msg || "API error",
+        };
+    }
+    const windows = [];
+    const limits = data.data?.limits || [];
+    for (const limit of limits) {
+        const percent = clampPercent(limit.percentage || 0);
+        const nextReset = limit.nextResetTime ? new Date(limit.nextResetTime).getTime() : undefined;
+        let windowLabel = "Limit";
+        if (limit.unit === 1)
+            windowLabel = `${limit.number}d`;
+        else if (limit.unit === 3)
+            windowLabel = `${limit.number}h`;
+        else if (limit.unit === 5)
+            windowLabel = `${limit.number}m`;
+        if (limit.type === "TOKENS_LIMIT") {
+            windows.push({
+                label: `Tokens (${windowLabel})`,
+                usedPercent: percent,
+                resetAt: nextReset,
+            });
+        }
+        else if (limit.type === "TIME_LIMIT") {
+            windows.push({
+                label: "Monthly",
+                usedPercent: percent,
+                resetAt: nextReset,
+            });
+        }
+    }
+    const planName = data.data?.planName || data.data?.plan || undefined;
+    return {
+        provider: "zai",
+        displayName: PROVIDER_LABELS.zai,
+        windows,
+        plan: planName,
+    };
+}

package/dist/infra/provider-usage.format.js

@@ -0,0 +1,77 @@
+import { clampPercent } from "./provider-usage.shared.js";
+function formatResetRemaining(targetMs, now) {
+    if (!targetMs)
+        return null;
+    const base = now ?? Date.now();
+    const diffMs = targetMs - base;
+    if (diffMs <= 0)
+        return "now";
+    const diffMins = Math.floor(diffMs / 60000);
+    if (diffMins < 60)
+        return `${diffMins}m`;
+    const hours = Math.floor(diffMins / 60);
+    const mins = diffMins % 60;
+    if (hours < 24)
+        return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
+    const days = Math.floor(hours / 24);
+    if (days < 7)
+        return `${days}d ${hours % 24}h`;
+    return new Intl.DateTimeFormat("en-US", {
+        month: "short",
+        day: "numeric",
+    }).format(new Date(targetMs));
+}
+function pickPrimaryWindow(windows) {
+    if (windows.length === 0)
+        return undefined;
+    return windows.reduce((best, next) => (next.usedPercent > best.usedPercent ? next : best));
+}
+function formatWindowShort(window, now) {
+    const remaining = clampPercent(100 - window.usedPercent);
+    const reset = formatResetRemaining(window.resetAt, now);
+    const resetSuffix = reset ? ` ⏱${reset}` : "";
+    return `${remaining.toFixed(0)}% left (${window.label}${resetSuffix})`;
+}
+export function formatUsageSummaryLine(summary, opts) {
+    const providers = summary.providers
+        .filter((entry) => entry.windows.length > 0 && !entry.error)
+        .slice(0, opts?.maxProviders ?? summary.providers.length);
+    if (providers.length === 0)
+        return null;
+    const parts = providers
+        .map((entry) => {
+        const window = pickPrimaryWindow(entry.windows);
+        if (!window)
+            return null;
+        return `${entry.displayName} ${formatWindowShort(window, opts?.now)}`;
+    })
+        .filter(Boolean);
+    if (parts.length === 0)
+        return null;
+    return `📊 Usage: ${parts.join(" · ")}`;
+}
+export function formatUsageReportLines(summary, opts) {
+    if (summary.providers.length === 0) {
+        return ["Usage: no provider usage available."];
+    }
+    const lines = ["Usage:"];
+    for (const entry of summary.providers) {
+        const planSuffix = entry.plan ? ` (${entry.plan})` : "";
+        if (entry.error) {
+            lines.push(`  ${entry.displayName}${planSuffix}: ${entry.error}`);
+            continue;
+        }
+        if (entry.windows.length === 0) {
+            lines.push(`  ${entry.displayName}${planSuffix}: no data`);
+            continue;
+        }
+        lines.push(`  ${entry.displayName}${planSuffix}`);
+        for (const window of entry.windows) {
+            const remaining = clampPercent(100 - window.usedPercent);
+            const reset = formatResetRemaining(window.resetAt, opts?.now);
+            const resetSuffix = reset ? ` · resets ${reset}` : "";
+            lines.push(`    ${window.label}: ${remaining.toFixed(0)}% left${resetSuffix}`);
+        }
+    }
+    return lines;
+}