pi-sub-quota 0.1.0 → 0.1.1

package/README.md

@@ -65,7 +65,7 @@ zai-coding-cn  coding plan · Max · active
 
 deepseek  pay as you go · ¥19.67 + ¥1.00 granted · $2.50
 
-kimi-coding  coding plan · Allegretto
+kimi-coding  coding plan · Allegretto · booster ¥100.00/¥200.00
   5h  ▓▓▓▓▓▓▓░░░   30% left   reset 17:10
   7d  ▓░░░░░░░░░   89% left   reset Mon 00:00
 
@@ -79,7 +79,7 @@ The footer shows how much you have used; the panel shows what is left, as a mete
 | Provider | What you see |
 | --- | --- |
 | ZAI / GLM coding plans — `zai-coding-cn`, `zai-coding`, GLM and bigmodel aliases | 5h / 7d usage windows with resets, your plan tier (Lite / Pro / Max) |
-| Kimi — `kimi-coding` | weekly request quota + 5h rate limit, membership tier (Andante / Moderato / Allegretto) |
+| Kimi — `kimi-coding` | 5h / 7d usage windows (+ 30d monthly pool on plans that report one), membership tier (Andante / Moderato / Allegretto) from the account endpoint, and the booster wallet balance (`booster ¥5.00/¥20.00`) once topped up |
 | DeepSeek — `deepseek` | prepaid balance per currency, topped-up + granted split |
 
 Custom providers work without configuration too: detection falls back to the model's base URL host (`bigmodel.cn`, `*.z.ai` with a `/coding` path, `*.kimi.com` / `*.kimi.ai` with a `/coding` path, `*.deepseek.com`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-sub-quota",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Coding-plan quota and prepaid balance in the pi footer, shown only while a subscription provider such as ZAI/GLM, DeepSeek, or Kimi is active",
   "keywords": [
     "pi-package",

package/providers/kimi.ts

@@ -1,17 +1,20 @@
 /**
  * Kimi coding plans: `GET <base>/usages` returns the weekly request quota
- * (top-level `usage`, whose limit maps to the membership tier) plus shorter
- * windows in `limits[]`, such as the 5-hour rate limit. Works with an API
- * key or the OAuth access token pi stores for kimi-coding; `opts.baseUrl`
- * overrides the regional endpoint (api.kimi.com vs api.kimi.ai) for custom
- * providers. Endpoint details follow CodexBar's documented API.
+ * (top-level `usage`) plus shorter windows in `limits[]`, such as the 5-hour
+ * rate limit. `GET <base>/me` reports the account's membership tier
+ * (`user_level_name`); the legacy limit→tier map only backs it up when that
+ * endpoint is unavailable (e.g. API-key auth without account scope).
+ * Works with an API key or the OAuth access token pi stores for kimi-coding;
+ * `opts.baseUrl` overrides the regional endpoint (api.kimi.com vs api.kimi.ai)
+ * for custom providers. Endpoint details follow CodexBar's documented API.
  */
 
 import { clampPercent, fetchJson, hostMatchesApex, urlParts } from "./http.ts";
-import type { FetchOptions, QuotaProvider, QuotaSnapshot, QuotaWindow } from "./types.ts";
+import type { FetchOptions, QuotaBalance, QuotaProvider, QuotaSnapshot, QuotaWindow } from "./types.ts";
 
 const KIMI_USAGE_URL = "https://api.kimi.com/coding/v1/usages";
-/** Kimi membership tiers keyed by weekly request limit (per CodexBar docs). */
+const KIMI_ME_URL = "https://api.kimi.com/coding/v1/me";
+/** Legacy membership tiers keyed by weekly request limit (per CodexBar docs); newer plans report other limits, so `/me` is the source of truth. */
 const KIMI_TIERS: Record<string, string> = { "1024": "andante", "2048": "moderato", "7168": "allegretto" };
 const KIMI_PROVIDER_IDS = new Set(["kimi-coding", "kimi"]);
 
@@ -25,12 +28,45 @@ interface KimiUsagePool {
 interface KimiUsagesResponse {
 	usage?: KimiUsagePool;
 	limits?: { window?: { duration?: number; timeUnit?: string }; detail?: KimiUsagePool }[];
+	/** Ratio-based pools: fraction used + ISO reset, repeating 5h/7d and adding the monthly quota. */
+	usages?: KimiRatioPools;
+	/** Pay-as-you-go overage wallet; absent until the account activates it. */
+	booster_wallet?: KimiBoosterWallet;
+}
+
+interface KimiRatioPool {
+	used_ratio?: number | string;
+	reset_time?: string;
+}
+interface KimiRatioPools {
+	limit_5h?: KimiRatioPool;
+	limit_7d?: KimiRatioPool;
+	/** The plan's 30-day quota; `limit_month_code` (the coding share of it) is a breakdown detail, not a window. */
+	limit_month_total?: KimiRatioPool;
+}
+
+/** Money amount as documented by Kimi's own CLI: cents in `priceInCents`. */
+interface KimiMoney {
+	currency?: string;
+	priceInCents?: string;
+}
+interface KimiBoosterBalance {
+	type?: string;
+	amount?: string | number;
+	amountLeft?: string | number;
+}
+interface KimiBoosterWallet {
+	balance?: KimiBoosterBalance;
+	monthlyChargeLimit?: KimiMoney;
+	monthlyUsed?: KimiMoney;
 }
 
 function kimiPercent(pool: KimiUsagePool): number {
 	const limit = Number(pool.limit);
-	const used = Number(pool.used);
-	if (!Number.isFinite(limit) || limit <= 0 || !Number.isFinite(used) || used < 0) return 0;
+	if (!Number.isFinite(limit) || limit <= 0) return 0;
+	// Newer plans omit `used` and report `remaining` instead.
+	const used = pool.used !== undefined ? Number(pool.used) : limit - Number(pool.remaining);
+	if (!Number.isFinite(used) || used < 0) return 0;
 	return clampPercent((used / limit) * 100);
 }
 
@@ -57,22 +93,97 @@ function kimiWindowLabel(minutes: number): string {
 	return `${Math.round(minutes / 60)}h`;
 }
 
-/** Build the usages URL from a custom base, ignoring any query or fragment. */
-function kimiUsagesUrl(baseUrl: string): string {
+/**
+ * The `usages` ratio pools, keyed with their window length in minutes
+ * (monthly ≈ 30d for ordering). Entries the backend omits are skipped.
+ */
+const KIMI_RATIO_POOLS: { key: keyof KimiRatioPools; minutes: number }[] = [
+	{ key: "limit_5h", minutes: 300 },
+	{ key: "limit_7d", minutes: 10_080 },
+	{ key: "limit_month_total", minutes: 43_200 },
+];
+
+/** A ratio pool as a window; undefined when its ratio is missing or invalid. */
+function kimiRatioWindow(pool: KimiRatioPool | undefined, minutes: number): QuotaWindow | undefined {
+	if (!pool) return undefined;
+	const ratio = Number(pool.used_ratio);
+	if (!Number.isFinite(ratio) || ratio < 0) return undefined;
+	const resetMs = typeof pool.reset_time === "string" ? Date.parse(pool.reset_time) : Number.NaN;
+	return {
+		type: "window",
+		resource: "tokens",
+		label: kimiWindowLabel(minutes),
+		usedPercent: clampPercent(ratio * 100),
+		resetAt: Number.isFinite(resetMs) ? resetMs : undefined,
+		durationMs: minutes * 60_000,
+	};
+}
+
+/** Build an endpoint URL from a custom base, ignoring any query or fragment. */
+function kimiUrl(baseUrl: string | undefined, suffix: string, fallback: string): string {
+	if (!baseUrl) return fallback;
 	try {
 		const url = new URL(baseUrl);
 		url.search = "";
 		url.hash = "";
-		url.pathname = `${url.pathname.replace(/\/+$/, "")}/usages`;
+		url.pathname = `${url.pathname.replace(/\/+$/, "")}${suffix}`;
 		return url.toString();
 	} catch {
 		throw new Error("Kimi quota fetch failed: invalid baseUrl");
 	}
 }
 
+interface KimiMeResponse {
+	user_level_name?: string;
+}
+
+/** Membership tier name from the account endpoint; undefined when absent or malformed. */
+function kimiPlanLevel(body: unknown): string | undefined {
+	if (typeof body !== "object" || body === null) return undefined;
+	const name = (body as KimiMeResponse).user_level_name;
+	return typeof name === "string" && name.trim() !== "" ? name : undefined;
+}
+
+/** Booster amounts are fixed-point: value / 1e6 = cents (per Kimi's CLI). */
+const KIMI_BOOSTER_SCALE = 1_000_000;
+
+/** Positive fixed-point amount to cents; undefined for missing, invalid, or empty values. */
+function kimiBoosterCents(value: string | number | undefined): number | undefined {
+	const n = Number(value);
+	return Number.isFinite(n) && n > 0 ? Math.round(n / KIMI_BOOSTER_SCALE) : undefined;
+}
+
+/**
+ * The booster wallet as a balance item, mirroring Kimi's CLI: only a
+ * BOOSTER-typed balance with a positive top-up exists — an inactive wallet
+ * (no `amount`) has nothing to show. `total` is what is left to spend;
+ * `toppedUp` keeps the original amount for context ("¥5.00/¥20.00").
+ */
+function kimiBoosterBalance(wallet: KimiBoosterWallet | undefined): QuotaBalance | undefined {
+	const balance = wallet?.balance;
+	if (balance?.type !== "BOOSTER") return undefined;
+	const toppedUpCents = kimiBoosterCents(balance.amount);
+	if (toppedUpCents === undefined) return undefined;
+	const currency = wallet?.monthlyChargeLimit?.currency ?? wallet?.monthlyUsed?.currency;
+	const symbol = currency === "USD" ? "$" : currency === "CNY" || currency === undefined ? "¥" : currency;
+	return {
+		type: "balance",
+		symbol,
+		total: (kimiBoosterCents(balance.amountLeft) ?? 0) / 100,
+		granted: 0,
+		toppedUp: toppedUpCents / 100,
+		label: "booster",
+	};
+}
+
 /** Fetch Kimi coding-plan usage: weekly quota plus rate-limit windows. */
 export async function fetchKimiQuota(apiKey: string, opts: FetchOptions = {}): Promise<QuotaSnapshot> {
-	const url = opts.baseUrl ? kimiUsagesUrl(opts.baseUrl) : KIMI_USAGE_URL;
+	const url = kimiUrl(opts.baseUrl, "/usages", KIMI_USAGE_URL);
+	// The account call runs alongside the usage call; failing it (auth without
+	// account scope, transient 5xx) only drops the tier name, never the windows.
+	const meBody = fetchJson(kimiUrl(opts.baseUrl, "/me", KIMI_ME_URL), apiKey, opts)
+		.then(kimiPlanLevel)
+		.catch(() => undefined);
 	const body = (await fetchJson(url, apiKey, opts)) as KimiUsagesResponse;
 	const toWindow = (pool: KimiUsagePool, label: string, durationMs: number): QuotaWindow => ({
 		type: "window",
@@ -91,15 +202,24 @@ export async function fetchKimiQuota(apiKey: string, opts: FetchOptions = {}): P
 		if (minutes === undefined || !entry?.detail) continue;
 		windows.push(toWindow(entry.detail, kimiWindowLabel(minutes), minutes * 60_000));
 	}
+	// Ratio pools only fill durations the count-based windows did not cover:
+	// 5h/7d repeat there with exact counts, so in practice this adds the
+	// monthly quota on plans that have one.
+	for (const { key, minutes } of KIMI_RATIO_POOLS) {
+		if (windows.some((window) => window.durationMs === minutes * 60_000)) continue;
+		const window = kimiRatioWindow(body?.usages?.[key], minutes);
+		if (window) windows.push(window);
+	}
 	if (windows.length === 0) throw new Error("Kimi usage response had no usage windows");
 	// Shortest window first: the 5-hour rate limit always reads before the weekly
 	// quota, even when the weekly reset happens to come sooner.
 	windows.sort((a, b) => (a.durationMs ?? Number.MAX_SAFE_INTEGER) - (b.durationMs ?? Number.MAX_SAFE_INTEGER));
+	const booster = kimiBoosterBalance(body?.booster_wallet);
 	return {
 		kind: "kimi",
 		fetchedAt: (opts.now ?? Date.now)(),
-		items: windows,
-		planLevel: KIMI_TIERS[String(weeklyLimit)],
+		items: booster ? [...windows, booster] : windows,
+		planLevel: (await meBody) ?? KIMI_TIERS[String(weeklyLimit)],
 	};
 }
 

package/providers/types.ts

@@ -39,10 +39,14 @@ export interface QuotaBalance {
 	type: "balance";
 	/** Currency symbol, e.g. "¥" or "$". */
 	symbol: string;
-	/** Total balance (topped up + granted), in the account currency. */
+	/** Spendable amount right now (topped up + granted, minus what depleting wallets already spent). */
 	total: number;
 	/** Granted (promotional) part of the balance; 0 when there is none. */
 	granted: number;
+	/** Original top-up of a depleting wallet (e.g. Kimi's booster); `total` then reads as remaining/toppedUp. */
+	toppedUp?: number;
+	/** Short qualifier for the panel header, e.g. "booster". */
+	label?: string;
 }
 
 /** One displayable quota item; a snapshot is an ordered list of these. */

package/view.ts

@@ -135,10 +135,15 @@ export function formatQuota(snapshot: QuotaSnapshot, now: number, opts?: { stale
  * balance is money, so nothing is rounded. With `detail` and a granted part
  * of at least one cent, topped-up and granted amounts sit side by side,
  * each with its currency symbol ("¥18.67+¥1.00") so multi-currency accounts
- * stay readable; otherwise the exact total ("¥19.67").
+ * stay readable; otherwise the exact total ("¥19.67"). A depleting wallet
+ * with a known top-up shows both amounts in every mode ("¥5.00/¥20.00"),
+ * since the remaining money only reads against what was paid in.
  */
 export function formatBalanceCompact(balance: QuotaBalance, opts?: { detail?: boolean }): string {
 	const cents = (value: number) => value.toFixed(2);
+	if (balance.toppedUp !== undefined) {
+		return `${balance.symbol}${cents(balance.total)}/${balance.symbol}${cents(balance.toppedUp)}`;
+	}
 	if (!opts?.detail || balance.granted < 0.01) return `${balance.symbol}${cents(balance.total)}`;
 	return `${balance.symbol}${cents(balance.total - balance.granted)}+${balance.symbol}${cents(balance.granted)}`;
 }
@@ -264,12 +269,18 @@ export interface QuotaPanelRow {
 	note?: string;
 }
 
-/** Exact balance for the panel header: "¥19.67 + ¥1.00 granted" or "¥19.67". */
+/**
+ * Exact balance for the panel header: "¥19.67 + ¥1.00 granted", "¥19.67",
+ * or "booster ¥5.00/¥20.00" for a depleting wallet (its label tells the
+ * two apart from a plain prepaid balance).
+ */
 function formatBalancePanel(balance: QuotaBalance): string {
+	const label = balance.label ? `${balance.label} ` : "";
 	// Same one-cent threshold as formatBalanceCompact, so footer and panel
 	// always agree on whether a granted part is shown at all.
+	if (balance.toppedUp !== undefined) return `${label}${formatBalanceCompact(balance)}`;
 	const granted = balance.granted >= 0.01 ? ` + ${balance.symbol}${balance.granted.toFixed(2)} granted` : "";
-	return `${balance.symbol}${balance.total.toFixed(2)}${granted}`;
+	return `${label}${balance.symbol}${balance.total.toFixed(2)}${granted}`;
 }
 
 /**