dsh-subscriptions 0.1.1 → 0.1.3

package/lib/providers/external-usage.js

@@ -1,4 +1,21 @@
 /** Usage readers for subscriptions whose model adapters are built into DSH. */
+function numeric(value) {
+    const n = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+    return typeof n === 'number' && Number.isFinite(n) ? n : undefined;
+}
+function kimiReset(value) {
+    for (const key of ['reset_at', 'resetAt', 'reset_time', 'resetTime']) {
+        const reset = resetTime(value[key]);
+        if (reset !== undefined)
+            return reset;
+    }
+    for (const key of ['reset_in', 'resetIn', 'ttl', 'window']) {
+        const seconds = numeric(value[key]);
+        if (seconds !== undefined && seconds > 0)
+            return Date.now() + seconds * 1000;
+    }
+    return undefined;
+}
 function record(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value)
         ? value
@@ -45,6 +62,9 @@ export async function fetchOpenCodeGoUsage(apiKey, http = fetch, signal) {
             kind,
             ...(scope === undefined ? {} : { scope }),
             usedPercent,
+            // Go's rolling counter is first-use anchored, not per-request sliding.
+            ...(field === 'rolling' ? { fixedWindow: true, windowDurationMs: 18_000_000 }
+                : field === 'weekly' ? { fixedWindow: true, windowDurationMs: 604_800_000 } : {}),
             ...(resetsAt === undefined ? {} : { resetsAt }),
         });
     }
@@ -52,14 +72,53 @@ export async function fetchOpenCodeGoUsage(apiKey, http = fetch, signal) {
         throw new Error('OpenCode Go usage response has no valid windows');
     return { supported: true, windows, plan: 'OpenCode Go' };
 }
-/** Read the Kimi Code plan windows using the same API as the Kimi Code CLI. */
+/** Read official CLI count windows and retain compatibility with older ratio pools. */
 export async function fetchKimiCodeUsage(apiKey, http = fetch, signal) {
     const body = record(await getUsage('https://api.kimi.com/coding/v1/usages', apiKey, http, signal));
     if (body === undefined)
         throw new Error('Kimi Code usage response is not an object');
+    const modern = [];
+    const rows = [
+        ...(record(body.usage) ? [{ detail: body.usage }] : []),
+        ...(Array.isArray(body.limits) ? body.limits : []),
+    ];
+    for (const raw of rows) {
+        const item = record(raw);
+        if (!item)
+            continue;
+        const detail = record(item.detail) ?? item;
+        const limit = numeric(detail.limit);
+        const used = numeric(detail.used) ?? (limit !== undefined && numeric(detail.remaining) !== undefined
+            ? limit - numeric(detail.remaining) : undefined);
+        if (limit === undefined || limit <= 0 || used === undefined)
+            continue;
+        const usedPercent = percent(used / limit * 100);
+        if (usedPercent === undefined)
+            continue;
+        const window = record(item.window) ?? item;
+        const duration = numeric(window.duration ?? item.duration ?? detail.duration);
+        const unit = String(window.timeUnit ?? item.timeUnit ?? detail.timeUnit ?? '').toUpperCase();
+        const multiplier = unit.includes('MINUTE') ? 60_000 : unit.includes('HOUR') ? 3_600_000
+            : unit.includes('DAY') ? 86_400_000 : unit.includes('SECOND') ? 1000 : undefined;
+        const durationMs = duration === undefined || duration <= 0 || multiplier === undefined
+            ? undefined : duration * multiplier;
+        const kind = durationMs === 18_000_000 ? 'session' : durationMs === 604_800_000 ? 'weekly' : 'other';
+        const resetsAt = kimiReset(detail);
+        const scope = detail.name ?? detail.title ?? item.name ?? item.title;
+        modern.push({ kind, usedPercent,
+            ...(typeof scope === 'string' ? { scope } : {}),
+            ...(resetsAt === undefined ? {} : { resetsAt }),
+            ...(durationMs === undefined ? {} : { windowDurationMs: durationMs }),
+            // Legacy weekly plans reset as whole seven-day buckets; five-hour semantics
+            // are documented as rolling, so no fixed-window assertion is made there.
+            ...(kind === 'weekly' ? { fixedWindow: true } : {}),
+        });
+    }
+    if (modern.length)
+        return { supported: true, windows: modern, plan: 'Kimi Code' };
     const usages = record(body.usages);
     if (usages === undefined)
-        throw new Error('Kimi Code usage response has no usages object');
+        throw new Error('Kimi Code usage response has no valid windows');
     const windows = [];
     for (const [field, kind, scope] of [
         ['limit_5h', 'session', undefined],
@@ -75,6 +134,7 @@ export async function fetchKimiCodeUsage(apiKey, http = fetch, signal) {
             kind,
             ...(scope === undefined ? {} : { scope }),
             usedPercent: ratio * 100,
+            ...(field === 'limit_7d' ? { fixedWindow: true, windowDurationMs: 604_800_000 } : {}),
             ...(resetsAt === undefined ? {} : { resetsAt }),
         });
     }

package/lib/providers/grok.js

@@ -272,7 +272,9 @@ export async function fetchGrokUsage(session, fetchFn = hostFetch, signal) {
         const usedPercent = typeof config.creditUsagePercent === 'number' && Number.isFinite(config.creditUsagePercent)
             ? config.creditUsagePercent
             : 0;
-        windows.push({ kind, usedPercent, ...resetsAt === undefined ? {} : { resetsAt } });
+        const startsAt = grokResetsAt(config.currentPeriod?.start);
+        windows.push({ kind, usedPercent, ...resetsAt === undefined ? {} : { resetsAt },
+            ...startsAt === undefined ? {} : { startsAt } });
     }
     else if (typeof config.monthlyLimit?.val === 'number' && config.monthlyLimit.val > 0) {
         const used = typeof config.used?.val === 'number' ? config.used.val : 0;

package/lib/providers/minimax-usage.d.ts

@@ -0,0 +1,24 @@
+import type { ProviderUsage } from './common.js';
+/**
+ * Read MiniMax subscription quota (M Plan and Token Plan), not the balance API
+ * that `sk-api-*` pay-as-you-go keys use.
+ *
+ * Each `model_remains` row can yield an interval window and a weekly window.
+ * A window needs a finite share: the explicit `*_remaining_percent` (the weekly
+ * one scaled by `weekly_boost_permille`), else the legacy counts. Time-based
+ * plans report zero counts beside the percentage for standard models, so the
+ * percentage stands on its own and a zero total does not hide the window.
+ * Windows that cannot be a finite bar are omitted rather than approximated:
+ * status 3 (unlimited, or no quota in the plan), a weekly pool boosted past
+ * 100% remaining, a percentage outside 0-100, and a row with neither a
+ * percentage nor positive counts. Start and end times are kept only when both
+ * are valid millisecond bounds.
+ * @param key - subscription key for the region; never copied into a result or error.
+ * @param region - `global` or `cn`, which selects the fixed quota host.
+ * @param http - fetch implementation (injectable for tests).
+ * @param signal - caller cancellation from the RPC transport.
+ * @returns the finite windows in the order the API lists them.
+ * @throws when the key is pay-as-you-go, the endpoint or its business status
+ *   fails, the body has no `model_remains`, or no window is a finite bar.
+ */
+export declare function fetchMiniMaxUsage(key: string, region: 'global' | 'cn', http?: typeof fetch, signal?: AbortSignal): Promise<ProviderUsage>;

package/lib/providers/minimax-usage.js

@@ -0,0 +1,85 @@
+/**
+ * Used percentage from the legacy counts, read as the official CLI does when no
+ * explicit percentage exists: the count is the quota remaining. Undefined
+ * unless the total is a positive finite number, so a zero total never yields a
+ * bar.
+ */
+function usedFromCounts(total, count) {
+    return typeof total === 'number' && Number.isFinite(total) && total > 0 && typeof count === 'number'
+        ? (1 - count / total) * 100
+        : undefined;
+}
+/**
+ * Read MiniMax subscription quota (M Plan and Token Plan), not the balance API
+ * that `sk-api-*` pay-as-you-go keys use.
+ *
+ * Each `model_remains` row can yield an interval window and a weekly window.
+ * A window needs a finite share: the explicit `*_remaining_percent` (the weekly
+ * one scaled by `weekly_boost_permille`), else the legacy counts. Time-based
+ * plans report zero counts beside the percentage for standard models, so the
+ * percentage stands on its own and a zero total does not hide the window.
+ * Windows that cannot be a finite bar are omitted rather than approximated:
+ * status 3 (unlimited, or no quota in the plan), a weekly pool boosted past
+ * 100% remaining, a percentage outside 0-100, and a row with neither a
+ * percentage nor positive counts. Start and end times are kept only when both
+ * are valid millisecond bounds.
+ * @param key - subscription key for the region; never copied into a result or error.
+ * @param region - `global` or `cn`, which selects the fixed quota host.
+ * @param http - fetch implementation (injectable for tests).
+ * @param signal - caller cancellation from the RPC transport.
+ * @returns the finite windows in the order the API lists them.
+ * @throws when the key is pay-as-you-go, the endpoint or its business status
+ *   fails, the body has no `model_remains`, or no window is a finite bar.
+ */
+export async function fetchMiniMaxUsage(key, region, http = fetch, signal) {
+    if (key.startsWith('sk-api-'))
+        throw new Error('MiniMax requires a subscription key, not a pay-as-you-go key');
+    const response = await http(`https://www.minimax.${region === 'cn' ? 'cn' : 'io'}/v1/token_plan/remains`, {
+        headers: { authorization: `Bearer ${key}`, 'content-type': 'application/json' },
+        ...(signal === undefined ? {} : { signal }),
+    });
+    if (!response.ok)
+        throw new Error(`MiniMax usage endpoint returned HTTP ${response.status}`);
+    const body = await response.json();
+    if ((body?.base_resp?.status_code !== undefined && body.base_resp.status_code !== 0) || !Array.isArray(body?.model_remains)) {
+        throw new Error('MiniMax usage response failed or has no quota records');
+    }
+    const windows = [];
+    for (const raw of body.model_remains) {
+        if (raw === null || typeof raw !== 'object')
+            continue;
+        const row = raw;
+        if (typeof row.model_name !== 'string')
+            continue;
+        for (const [prefix, startKey, endKey, fallback] of [
+            ['current_interval', 'start_time', 'end_time', 'session'],
+            ['current_weekly', 'weekly_start_time', 'weekly_end_time', 'weekly'],
+        ]) {
+            const status = row[`${prefix}_status`];
+            if (status === 3)
+                continue; // Unlimited pools cannot have a finite percentage.
+            const remaining = row[`${prefix}_remaining_percent`];
+            const boost = prefix === 'current_weekly' ? row.weekly_boost_permille ?? 1000 : 1000;
+            if (typeof boost !== 'number' || !Number.isFinite(boost) || boost <= 0)
+                continue;
+            // An explicit percentage needs no counts: time-based plans send zero
+            // counts beside it. Official CLI compatibility: without a percentage, the
+            // legacy counts are the quota remaining.
+            const usedPercent = typeof remaining === 'number' ? 100 - remaining * boost / 1000
+                : usedFromCounts(row[`${prefix}_total_count`], row[`${prefix}_usage_count`]);
+            if (usedPercent === undefined || !Number.isFinite(usedPercent) || usedPercent < 0 || usedPercent > 100)
+                continue;
+            const start = row[startKey];
+            const end = row[endKey];
+            const validBounds = typeof start === 'number' && Number.isFinite(start) && start > 0
+                && typeof end === 'number' && Number.isFinite(end) && end > start;
+            windows.push({ kind: fallback === 'session' && validBounds && end - start !== 18_000_000 ? 'other' : fallback,
+                scope: row.model_name, usedPercent,
+                ...(validBounds ? { startsAt: start, resetsAt: end } : {}),
+            });
+        }
+    }
+    if (!windows.length)
+        throw new Error('MiniMax has no supported finite quota windows');
+    return { supported: true, plan: 'MiniMax', windows };
+}

package/lib/providers/pool-usage.js

@@ -107,7 +107,7 @@ export class PoolUsageTracker {
                 // every display surface — this is what was previously showing, so
                 // keep showing it (even through a forced refresh: retrying past the
                 // cooldown is exactly the retry storm `cooldownMs` exists to avoid).
-                return entry.lastSnapshot;
+                return { ...entry.lastSnapshot, stale: true };
             }
             else {
                 throw entry.error;
@@ -122,7 +122,7 @@ export class PoolUsageTracker {
             // snapshot was on record before it ran onto the new failure entry.
             const failed = this.entries.get(key);
             if (failed?.snapshot === undefined && failed?.lastSnapshot !== undefined)
-                return failed.lastSnapshot;
+                return { ...failed.lastSnapshot, stale: true };
             throw error;
         }
     }
@@ -155,8 +155,10 @@ export class PoolUsageTracker {
             // consecutive failure, even though nothing newer ever replaced it.
             const prior = this.entries.get(key);
             const lastSnapshot = prior?.snapshot ?? prior?.lastSnapshot;
-            pending = fetcher().then((snapshot) => {
-                this.entries.set(key, { snapshot, at: Date.now() });
+            pending = fetcher().then((value) => {
+                const at = Date.now();
+                const snapshot = { ...value, observedAt: at, stale: false };
+                this.entries.set(key, { snapshot, at });
                 return snapshot;
             }, (error) => {
                 if (!isMissingOrInvalidCredential(error)) {

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "DSH Subscriptions",
+    "description": "Unified subscription providers and usage dashboard for DeepSeek Harness"
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "订阅中心",
+    "description": "将 ChatGPT、Claude、Grok 等订阅制模型接入 DeepSeek Harness，附带用量看板"
+  }
+}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "dsh-subscriptions",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Unified subscription providers and usage dashboard for DeepSeek Harness",
+  "icon": "./icon.svg",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -43,12 +44,15 @@
       "types": "./vendor/cursor/index.d.ts",
       "default": "./vendor/cursor/index.js"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
   },
   "files": [
     "lib",
     "vendor/cursor",
-    "cordis.patch.yml"
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg"
   ],
   "dsh": {
     "bundle": {