cc-usage-bar 0.1.0

package/dist/src/providers/glm.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.glmAdapter = void 0;
+exports.parseGlm = parseGlm;
+const http_1 = require("./http");
+const ENDPOINT = 'https://api.z.ai/api/monitor/usage/quota/limit';
+function parseGlm(body) {
+    if (!body || typeof body !== 'object')
+        return null;
+    const r = body;
+    if (r.success === false)
+        return { error: typeof r.msg === 'string' ? r.msg : 'GLM API error' };
+    const limits = r.data?.limits;
+    if (!Array.isArray(limits))
+        return null;
+    const tokens = limits.find((l) => l && l.type === 'TOKENS_LIMIT');
+    if (!tokens || typeof tokens.percentage !== 'number')
+        return null;
+    const out = {
+        kind: 'subscription',
+        planName: typeof r.data?.level === 'string' ? `GLM ${r.data.level}` : 'GLM',
+        five_hour: {
+            utilization: tokens.percentage,
+            resets_at: typeof tokens.nextResetTime === 'number'
+                ? new Date(tokens.nextResetTime).toISOString()
+                : undefined,
+        },
+    };
+    return out;
+}
+exports.glmAdapter = {
+    id: 'glm',
+    displayName: 'GLM',
+    matches(env) {
+        if (!env.baseUrl)
+            return false;
+        const u = env.baseUrl.toLowerCase();
+        return u.includes('z.ai') || u.includes('bigmodel.cn');
+    },
+    async fetch(env) {
+        if (!env.authToken)
+            return { ok: false, error: 'ANTHROPIC_AUTH_TOKEN not set' };
+        const res = await (0, http_1.httpGetJson)(ENDPOINT, {
+            Authorization: env.authToken,
+            'Content-Type': 'application/json',
+            'Accept-Language': 'en-US,en',
+        });
+        if (res.authFailed)
+            return { ok: false, authFailed: true, error: res.error };
+        if (!res.ok || !res.body)
+            return { ok: false, error: res.error ?? 'request failed' };
+        const parsed = parseGlm(res.body);
+        if (!parsed)
+            return { ok: false, error: 'invalid response shape' };
+        if ('error' in parsed)
+            return { ok: false, error: parsed.error };
+        return { ok: true, data: parsed };
+    },
+};

package/dist/src/providers/http.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_TIMEOUT_MS = void 0;
+exports.httpGetJson = httpGetJson;
+exports.HTTP_TIMEOUT_MS = 2_000;
+async function httpGetJson(url, headers, timeoutMs = exports.HTTP_TIMEOUT_MS) {
+    try {
+        const res = await fetch(url, {
+            method: 'GET',
+            headers: { Accept: 'application/json', ...headers },
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (res.status === 401 || res.status === 403) {
+            return { ok: false, status: res.status, authFailed: true, error: `unauthorized (${res.status})` };
+        }
+        if (!res.ok) {
+            return { ok: false, status: res.status, error: `http ${res.status}` };
+        }
+        const body = (await res.json());
+        return { ok: true, status: res.status, body };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : 'network error';
+        return { ok: false, error: msg };
+    }
+}

package/dist/src/providers/kimi.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kimiAdapter = void 0;
+exports.parseKimi = parseKimi;
+const http_1 = require("./http");
+const ENDPOINT = 'https://api.kimi.com/coding/v1/usages';
+function toIso(t) {
+    if (typeof t === 'number' && Number.isFinite(t)) {
+        const ms = t > 1e12 ? t : t * 1000;
+        return new Date(ms).toISOString();
+    }
+    if (typeof t === 'string' && t)
+        return t;
+    return undefined;
+}
+function tierFrom(t) {
+    if (!t || typeof t.limit !== 'number' || typeof t.remaining !== 'number' || t.limit <= 0)
+        return undefined;
+    const utilization = ((t.limit - t.remaining) / t.limit) * 100;
+    return { utilization, resets_at: toIso(t.resetTime) };
+}
+function parseKimi(body) {
+    if (!body || typeof body !== 'object')
+        return null;
+    const r = body;
+    const out = { kind: 'subscription', planName: 'Kimi' };
+    const fhDetail = Array.isArray(r.limits) && r.limits.length > 0 ? r.limits[0]?.detail : undefined;
+    const fh = tierFrom(fhDetail);
+    if (fh)
+        out.five_hour = fh;
+    const wk = tierFrom(r.usage);
+    if (wk)
+        out.seven_day = wk;
+    if (!out.five_hour && !out.seven_day)
+        return null;
+    return out;
+}
+exports.kimiAdapter = {
+    id: 'kimi',
+    displayName: 'Kimi',
+    matches(env) {
+        return !!env.baseUrl && env.baseUrl.toLowerCase().includes('api.kimi.com');
+    },
+    async fetch(env) {
+        if (!env.authToken)
+            return { ok: false, error: 'ANTHROPIC_AUTH_TOKEN not set' };
+        const res = await (0, http_1.httpGetJson)(ENDPOINT, { Authorization: `Bearer ${env.authToken}` });
+        if (res.authFailed)
+            return { ok: false, authFailed: true, error: res.error };
+        if (!res.ok || !res.body)
+            return { ok: false, error: res.error ?? 'request failed' };
+        const data = parseKimi(res.body);
+        if (!data)
+            return { ok: false, error: 'invalid response shape' };
+        return { ok: true, data };
+    },
+};

package/dist/src/providers/minimax.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minimaxAdapter = void 0;
+exports.parseMinimax = parseMinimax;
+const http_1 = require("./http");
+function tier(total, used, endMs) {
+    if (typeof total !== 'number' || typeof used !== 'number' || total <= 0)
+        return undefined;
+    return {
+        utilization: ((total - (total - used)) / total) * 100,
+        resets_at: typeof endMs === 'number' ? new Date(endMs).toISOString() : undefined,
+    };
+}
+function parseMinimax(body) {
+    if (!body || typeof body !== 'object')
+        return null;
+    const r = body;
+    const code = r.base_resp?.status_code;
+    if (typeof code === 'number' && code !== 0) {
+        return { error: r.base_resp?.status_msg ?? `MiniMax error ${code}` };
+    }
+    const remains = r.model_remains?.[0];
+    if (!remains)
+        return null;
+    const out = { kind: 'subscription', planName: 'MiniMax' };
+    const fh = tier(remains.current_interval_total_count, remains.current_interval_usage_count, remains.end_time);
+    if (fh)
+        out.five_hour = fh;
+    const wk = tier(remains.current_weekly_total_count, remains.current_weekly_usage_count, remains.weekly_end_time);
+    if (wk)
+        out.seven_day = wk;
+    if (!out.five_hour && !out.seven_day)
+        return null;
+    return out;
+}
+exports.minimaxAdapter = {
+    id: 'minimax',
+    displayName: 'MiniMax',
+    matches(env) {
+        if (!env.baseUrl)
+            return false;
+        const u = env.baseUrl.toLowerCase();
+        return u.includes('minimaxi.com') || u.includes('minimax.io');
+    },
+    async fetch(env) {
+        if (!env.authToken)
+            return { ok: false, error: 'ANTHROPIC_AUTH_TOKEN not set' };
+        const u = env.baseUrl?.toLowerCase() ?? '';
+        const domain = u.includes('minimax.io') ? 'api.minimax.io' : 'api.minimaxi.com';
+        const url = `https://${domain}/v1/api/openplatform/coding_plan/remains`;
+        const res = await (0, http_1.httpGetJson)(url, {
+            Authorization: `Bearer ${env.authToken}`,
+            'Content-Type': 'application/json',
+        });
+        if (res.authFailed)
+            return { ok: false, authFailed: true, error: res.error };
+        if (!res.ok || !res.body)
+            return { ok: false, error: res.error ?? 'request failed' };
+        const parsed = parseMinimax(res.body);
+        if (!parsed)
+            return { ok: false, error: 'invalid response shape' };
+        if ('error' in parsed)
+            return { ok: false, error: parsed.error };
+        return { ok: true, data: parsed };
+    },
+};

package/dist/src/providers/novita.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.novitaAdapter = void 0;
+exports.parseNovita = parseNovita;
+const http_1 = require("./http");
+const ENDPOINT = 'https://api.novita.ai/v3/user/balance';
+function parseNovita(body) {
+    if (!body || typeof body !== 'object')
+        return null;
+    const r = body;
+    const raw = r.availableBalance;
+    if (typeof raw !== 'number' || !Number.isFinite(raw))
+        return null;
+    const remaining = raw / 10000;
+    return {
+        kind: 'balance',
+        remaining,
+        unit: 'USD',
+        planName: 'Novita',
+        isValid: remaining > 0,
+        invalidMessage: remaining <= 0 ? 'No balance remaining' : undefined,
+    };
+}
+exports.novitaAdapter = {
+    id: 'novita',
+    displayName: 'Novita',
+    matches(env) {
+        return !!env.baseUrl && env.baseUrl.toLowerCase().includes('api.novita.ai');
+    },
+    async fetch(env) {
+        if (!env.authToken)
+            return { ok: false, error: 'ANTHROPIC_AUTH_TOKEN not set' };
+        const res = await (0, http_1.httpGetJson)(ENDPOINT, { Authorization: `Bearer ${env.authToken}` });
+        if (res.authFailed)
+            return { ok: false, authFailed: true, error: res.error };
+        if (!res.ok || !res.body)
+            return { ok: false, error: res.error ?? 'request failed' };
+        const data = parseNovita(res.body);
+        if (!data)
+            return { ok: false, error: 'invalid response shape' };
+        return { ok: true, data };
+    },
+};

package/dist/src/providers/openrouter.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openrouterAdapter = void 0;
+exports.parseOpenRouter = parseOpenRouter;
+const http_1 = require("./http");
+const ENDPOINT = 'https://openrouter.ai/api/v1/credits';
+function parseOpenRouter(body) {
+    if (!body || typeof body !== 'object')
+        return null;
+    const r = body;
+    const inner = r.data ?? r;
+    const total = typeof inner.total_credits === 'number' ? inner.total_credits : null;
+    const used = typeof inner.total_usage === 'number' ? inner.total_usage : null;
+    if (total === null || used === null)
+        return null;
+    const remaining = total - used;
+    return {
+        kind: 'balance',
+        remaining,
+        total,
+        used,
+        unit: 'USD',
+        planName: 'OpenRouter',
+        isValid: remaining > 0,
+        invalidMessage: remaining <= 0 ? 'No credits remaining' : undefined,
+    };
+}
+exports.openrouterAdapter = {
+    id: 'openrouter',
+    displayName: 'OR',
+    matches(env) {
+        return !!env.baseUrl && env.baseUrl.toLowerCase().includes('openrouter.ai');
+    },
+    async fetch(env) {
+        if (!env.authToken)
+            return { ok: false, error: 'ANTHROPIC_AUTH_TOKEN not set' };
+        const res = await (0, http_1.httpGetJson)(ENDPOINT, { Authorization: `Bearer ${env.authToken}` });
+        if (res.authFailed)
+            return { ok: false, authFailed: true, error: res.error };
+        if (!res.ok || !res.body)
+            return { ok: false, error: res.error ?? 'request failed' };
+        const data = parseOpenRouter(res.body);
+        if (!data)
+            return { ok: false, error: 'invalid response shape' };
+        return { ok: true, data };
+    },
+};

package/dist/src/providers/registry.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_ADAPTERS = void 0;
+exports.selectAdapter = selectAdapter;
+exports.getEnv = getEnv;
+const anthropic_1 = require("./anthropic");
+const kimi_1 = require("./kimi");
+const glm_1 = require("./glm");
+const minimax_1 = require("./minimax");
+const deepseek_1 = require("./deepseek");
+const stepfun_1 = require("./stepfun");
+const siliconflow_1 = require("./siliconflow");
+const openrouter_1 = require("./openrouter");
+const novita_1 = require("./novita");
+const NON_DEFAULT = [
+    kimi_1.kimiAdapter,
+    glm_1.glmAdapter,
+    minimax_1.minimaxAdapter,
+    deepseek_1.deepseekAdapter,
+    stepfun_1.stepfunAdapter,
+    siliconflow_1.siliconflowAdapter,
+    openrouter_1.openrouterAdapter,
+    novita_1.novitaAdapter,
+];
+exports.ALL_ADAPTERS = [...NON_DEFAULT, anthropic_1.anthropicAdapter];
+function selectAdapter(env) {
+    for (const a of NON_DEFAULT) {
+        if (a.matches(env))
+            return a;
+    }
+    if (anthropic_1.anthropicAdapter.matches(env))
+        return anthropic_1.anthropicAdapter;
+    return null;
+}
+function getEnv() {
+    return {
+        baseUrl: process.env.ANTHROPIC_BASE_URL,
+        authToken: process.env.ANTHROPIC_AUTH_TOKEN ?? process.env.ANTHROPIC_API_KEY,
+    };
+}

package/dist/src/providers/siliconflow.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.siliconflowAdapter = void 0;
+exports.parseSiliconFlow = parseSiliconFlow;
+const http_1 = require("./http");
+function toNum(v) {
+    if (typeof v === 'number' && Number.isFinite(v))
+        return v;
+    if (typeof v === 'string') {
+        const n = parseFloat(v);
+        return Number.isFinite(n) ? n : null;
+    }
+    return null;
+}
+function parseSiliconFlow(body) {
+    if (!body || typeof body !== 'object')
+        return null;
+    const r = body;
+    const balance = toNum(r.data?.totalBalance);
+    if (balance === null)
+        return null;
+    return {
+        kind: 'balance',
+        remaining: balance,
+        unit: 'CNY',
+        planName: 'SiliconFlow',
+        isValid: true,
+    };
+}
+exports.siliconflowAdapter = {
+    id: 'siliconflow',
+    displayName: 'SF',
+    matches(env) {
+        if (!env.baseUrl)
+            return false;
+        const u = env.baseUrl.toLowerCase();
+        return u.includes('api.siliconflow.cn') || u.includes('api.siliconflow.com');
+    },
+    async fetch(env) {
+        if (!env.authToken)
+            return { ok: false, error: 'ANTHROPIC_AUTH_TOKEN not set' };
+        const u = env.baseUrl?.toLowerCase() ?? '';
+        const domain = u.includes('siliconflow.com') ? 'api.siliconflow.com' : 'api.siliconflow.cn';
+        const url = `https://${domain}/v1/user/info`;
+        const res = await (0, http_1.httpGetJson)(url, { Authorization: `Bearer ${env.authToken}` });
+        if (res.authFailed)
+            return { ok: false, authFailed: true, error: res.error };
+        if (!res.ok || !res.body)
+            return { ok: false, error: res.error ?? 'request failed' };
+        const data = parseSiliconFlow(res.body);
+        if (!data)
+            return { ok: false, error: 'invalid response shape' };
+        return { ok: true, data };
+    },
+};

package/dist/src/providers/stepfun.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stepfunAdapter = void 0;
+exports.parseStepFun = parseStepFun;
+const http_1 = require("./http");
+const ENDPOINT = 'https://api.stepfun.com/v1/accounts';
+function toNum(v) {
+    if (typeof v === 'number' && Number.isFinite(v))
+        return v;
+    if (typeof v === 'string') {
+        const n = parseFloat(v);
+        return Number.isFinite(n) ? n : null;
+    }
+    return null;
+}
+function parseStepFun(body) {
+    if (!body || typeof body !== 'object')
+        return null;
+    const balance = toNum(body.balance);
+    if (balance === null)
+        return null;
+    return {
+        kind: 'balance',
+        remaining: balance,
+        unit: 'CNY',
+        planName: 'StepFun',
+        isValid: true,
+    };
+}
+exports.stepfunAdapter = {
+    id: 'stepfun',
+    displayName: 'StepFun',
+    matches(env) {
+        if (!env.baseUrl)
+            return false;
+        const u = env.baseUrl.toLowerCase();
+        return u.includes('api.stepfun.com') || u.includes('api.stepfun.ai');
+    },
+    async fetch(env) {
+        if (!env.authToken)
+            return { ok: false, error: 'ANTHROPIC_AUTH_TOKEN not set' };
+        const res = await (0, http_1.httpGetJson)(ENDPOINT, { Authorization: `Bearer ${env.authToken}` });
+        if (res.authFailed)
+            return { ok: false, authFailed: true, error: res.error };
+        if (!res.ok || !res.body)
+            return { ok: false, error: res.error ?? 'request failed' };
+        const data = parseStepFun(res.body);
+        if (!data)
+            return { ok: false, error: 'invalid response shape' };
+        return { ok: true, data };
+    },
+};

package/dist/src/providers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/render.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldUseColor = void 0;
+exports.render = render;
+exports.renderNormalized = renderNormalized;
+const format_1 = require("./format");
+Object.defineProperty(exports, "shouldUseColor", { enumerable: true, get: function () { return format_1.shouldUseColor; } });
+function toFormatOptions(opts) {
+    return {
+        ...format_1.DEFAULT_FORMAT,
+        color: opts.color,
+        showProviderName: opts.showProviderName ?? false,
+    };
+}
+function render(data, opts = { color: true }) {
+    if (!data)
+        return '';
+    const sub = { kind: 'subscription' };
+    if (typeof data.five_hour?.utilization === 'number') {
+        sub.five_hour = { utilization: data.five_hour.utilization, resets_at: data.five_hour.resets_at };
+    }
+    if (typeof data.seven_day?.utilization === 'number') {
+        sub.seven_day = { utilization: data.seven_day.utilization, resets_at: data.seven_day.resets_at };
+    }
+    return (0, format_1.renderUsage)(sub, toFormatOptions(opts));
+}
+function renderNormalized(data, opts = {}) {
+    return (0, format_1.renderUsage)(data, { ...format_1.DEFAULT_FORMAT, ...opts });
+}