coding-usage-bar 0.2.3 → 0.3.1

package/dist/format.d.ts

@@ -1,5 +1,6 @@
 import { BurnAnalysis, StatusIssue, ProviderUsage, UsageWindow, StatusSnapshot } from "./types.js";
 export declare function formatDurationUntil(iso: string, now?: Date): string;
+export declare function formatResetTime(iso: string, now?: Date): string;
 export declare function formatProviderLabel(provider: string): "Claude" | "GLM" | "DeepSeek" | "MiniMax" | "Kimi" | "Codex";
 export declare function formatWindowLabel(window: UsageWindow): "5h" | "7d";
 export declare function usageBar(usedPercent: number, width?: number): string;

package/dist/format.js

@@ -11,6 +11,31 @@ export function formatDurationUntil(iso, now = new Date()) {
     }
     return `${mins}m`;
 }
+// Absolute reset label for surfaces that re-render on a timer (SwiftBar).
+// A countdown changes every minute even when the underlying usage data is
+// unchanged, which forces SwiftBar to rebuild the menu and repaint the menu
+// bar on every refresh. An absolute clock time is a pure function of the
+// reset timestamp, so unchanged data renders to identical bytes and SwiftBar
+// skips the update entirely. `now` only decides "due" and whether the day
+// prefix is needed, both of which change at most once per window/day.
+export function formatResetTime(iso, now = new Date()) {
+    const resetMs = Date.parse(iso);
+    if (!Number.isFinite(resetMs)) {
+        return "due";
+    }
+    if (resetMs <= now.getTime()) {
+        return "due";
+    }
+    const reset = new Date(resetMs);
+    const sameDay = reset.getFullYear() === now.getFullYear()
+        && reset.getMonth() === now.getMonth()
+        && reset.getDate() === now.getDate();
+    const clock = `${String(reset.getHours()).padStart(2, "0")}:${String(reset.getMinutes()).padStart(2, "0")}`;
+    if (sameDay) {
+        return clock;
+    }
+    return `${reset.getMonth() + 1}/${reset.getDate()} ${clock}`;
+}
 function windowLabel(window) {
     return window.name === "five_hour" ? "5h" : "7d";
 }

package/dist/kimi.d.ts

@@ -28,5 +28,6 @@ export declare function usageFromKimiUsages(usages: KimiUsagesResponse, options:
 }): ProviderUsage | null;
 export declare function readClaudeLanesKimiConfig(configFile: string): KimiConfig | null;
 export declare function resolveKimiConfig(config: KimiConfig | undefined, homeDir?: string): KimiConfig;
+export declare function probeKimiAccessFrozen(config: KimiConfig): Promise<boolean>;
 export declare function collectKimiUsage(config: KimiConfig): Promise<ProviderUsage>;
 export {};

package/dist/kimi.js

@@ -16,11 +16,16 @@ function asNumber(value) {
 }
 // Kimi reports limit/used/remaining per window. Prefer the used/limit ratio;
 // when limit is 0 or missing, derive the total from used + remaining instead of
-// falling back to 0% while a real signal exists.
+// falling back to 0% while a real signal exists. Kimi also omits zero-valued
+// fields entirely (proto3 JSON): a fresh window with no usage reports only
+// limit + remaining, so derive used from limit - remaining instead of failing.
 function percentFromDetail(detail) {
     const limit = asNumber(detail.limit);
-    const used = asNumber(detail.used);
+    let used = asNumber(detail.used);
     const remaining = asNumber(detail.remaining);
+    if (used === null && limit !== null && remaining !== null) {
+        used = Math.max(0, limit - remaining);
+    }
     if (limit !== null && limit > 0 && used !== null) {
         return Math.max(0, Math.min(100, (used / limit) * 100));
     }
@@ -132,6 +137,41 @@ export function resolveKimiConfig(config, homeDir = os.homedir()) {
         apiKey: config?.apiKey || lanes?.apiKey,
     };
 }
+// Kimi's monthly billing-cycle quota can freeze all chat access while
+// /v1/usages still reports headroom in the 5h/weekly windows (the monthly
+// number itself is not exposed on any API-key-authenticated endpoint; it only
+// shows up in the logged-in web console). Detect the freeze with a
+// zero-cost probe: the billing-cycle gate runs before model validation, so a
+// chat request naming a nonexistent model returns 403 access_terminated_error
+// when frozen — and a "model not found" error (no inference, no quota use)
+// when healthy.
+const ACCESS_PROBE_MODEL = "coding-usage-bar-access-probe";
+export async function probeKimiAccessFrozen(config) {
+    const baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+    const response = await fetch(`${baseUrl}/v1/chat/completions`, {
+        method: "POST",
+        headers: {
+            "Authorization": `Bearer ${config.apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            model: ACCESS_PROBE_MODEL,
+            max_tokens: 1,
+            messages: [{ role: "user", content: "hi" }],
+        }),
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (response.status !== 403) {
+        return false;
+    }
+    try {
+        const body = (await response.json());
+        return body?.error?.type === "access_terminated_error";
+    }
+    catch {
+        return false;
+    }
+}
 export async function collectKimiUsage(config) {
     if (!config.apiKey) {
         throw new Error("Kimi API key not configured. Edit ~/.coding-usage-bar/config.json to set kimi.apiKey, or configure a kimi.com lane in ~/.config/claude-lanes/config.env.");
@@ -144,5 +184,15 @@ export async function collectKimiUsage(config) {
     if (!usage) {
         throw new Error("Kimi usages response did not contain expected 5h/7d quota data");
     }
+    // The probe must never fail the collection: on network errors the window
+    // data stays valid and simply renders unblocked.
+    try {
+        if (await probeKimiAccessFrozen(config)) {
+            usage.blocked = { reason: "monthly quota exhausted; access frozen until the next billing cycle" };
+        }
+    }
+    catch {
+        // Probe unavailable; keep the usage data as-is.
+    }
     return usage;
 }

package/dist/menubar.d.ts

@@ -14,7 +14,7 @@ export declare function openSwiftBar(): string[];
 export declare function addSwiftBarToLoginItems(options?: {
     dryRun?: boolean;
 }): string[];
-export declare function renderMenuBar(snapshot?: StatusSnapshot, paths?: RuntimePaths): string;
+export declare function renderMenuBar(snapshot?: StatusSnapshot, paths?: RuntimePaths, now?: Date): string;
 export declare function swiftBarStatusItemVisibilityKeys(defaultsOutput: string): string[];
 export declare function installMenuBar(options?: {
     dryRun?: boolean;

package/dist/menubar.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { ensureDir, isFile } from "./fs-util.js";
-import { formatDurationUntil, formatProviderLabel } from "./format.js";
+import { formatProviderLabel, formatResetTime } from "./format.js";
 import { buildPaths } from "./paths.js";
 import { stableNodeExecutable } from "./node-runtime.js";
 import { loadDisplayStatusSnapshot } from "./runtime.js";
@@ -338,7 +338,9 @@ function titleBars(provider) {
         return [{ pct: isAvailable ? 100 : 0, lightColor, darkColor }];
     }
     const state = provider.analysis.state;
-    const [lightColor, darkColor] = STATE_COLOR[state].split(",");
+    // Blocked (Kimi billing-cycle freeze): grey bars say "no access" without
+    // lying about the 5h/7d window numbers.
+    const [lightColor, darkColor] = (provider.usage.blocked ? MUTED_COLOR : STATE_COLOR[state]).split(",");
     const fiveHour = provider.analysis.fiveHour;
     const sevenDay = provider.analysis.sevenDay;
     const bars = [];
@@ -450,10 +452,10 @@ function coloredMeter(usedPercent, fillColor, width = METER_WIDTH) {
     return (filled > 0 ? ansiRGB(fillColor, "█".repeat(filled)) : "")
         + (empty > 0 ? ansiRGB(MUTED_COLOR, "░".repeat(empty)) : "");
 }
-function usageLine(label, usedPercent, resetsAt, color, barImage) {
+function usageLine(label, usedPercent, resetsAt, color, now, barImage) {
     const percent = `${Math.round(usedPercent).toString().padStart(3)}%`;
     if (barImage) {
-        return line(`${label}  ${percent}  reset ${formatDurationUntil(resetsAt)}`, {
+        return line(`${label}  ${percent}  reset ${formatResetTime(resetsAt, now)}`, {
             image: barImage.image,
             width: barImage.width,
             height: barImage.height,
@@ -463,7 +465,7 @@ function usageLine(label, usedPercent, resetsAt, color, barImage) {
         });
     }
     const bar = coloredMeter(usedPercent, color);
-    return line(`${label}  ${bar}  ${ansiRGB(color, percent)}  reset ${formatDurationUntil(resetsAt)}`, {
+    return line(`${label}  ${bar}  ${ansiRGB(color, percent)}  reset ${formatResetTime(resetsAt, now)}`, {
         ansi: true,
         font: ROW_FONT,
         size: 12,
@@ -490,8 +492,8 @@ function titleIconParams() {
     }
     return { sfimage: "flame.fill", sfcolor: RAW_COLOR };
 }
-function maxProviderAge(snapshot) {
-    return Math.max(0, ...snapshot.providers.map((item) => item.meta.ageSeconds));
+function anyProviderStale(snapshot) {
+    return snapshot.providers.some((item) => item.meta.stale);
 }
 function issueLabel(code) {
     if (code === "CLAUDE_INGEST_MISSING") {
@@ -517,7 +519,11 @@ function issueLabel(code) {
     }
     return code.replaceAll("_", " ").toLowerCase();
 }
-export function renderMenuBar(snapshot = loadDisplayStatusSnapshot(), paths = buildPaths()) {
+// `now` only feeds low-frequency decisions (reset due/day prefix). The output
+// must stay byte-identical across renders while the snapshot is unchanged, so
+// SwiftBar's content guard can skip the menu rebuild and menu bar repaint;
+// never render anything derived from wall-clock age or countdowns here.
+export function renderMenuBar(snapshot = loadDisplayStatusSnapshot(), paths = buildPaths(), now = new Date()) {
     const compact = readCompactMode(paths);
     const providers = titleProviders(snapshot);
     const title = providers.map(titleSegment).join(` ${TITLE_SEPARATOR} `);
@@ -571,7 +577,7 @@ export function renderMenuBar(snapshot = loadDisplayStatusSnapshot(), paths = bu
             sfcolor: STATE_COLOR[topState],
             badge: snapshot.profile.toUpperCase(),
         }),
-        muted(`Data age ${maxProviderAge(snapshot)}s`),
+        muted(anyProviderStale(snapshot) ? "Data stale" : "Data fresh"),
         "---",
     ];
     const barDataList = [];
@@ -579,7 +585,7 @@ export function renderMenuBar(snapshot = loadDisplayStatusSnapshot(), paths = bu
         if (item.usage.balance && item.usage.windows.length === 0) {
             continue;
         }
-        const [lc, dc] = STATE_COLOR[item.analysis.state].split(",");
+        const [lc, dc] = (item.usage.blocked ? MUTED_COLOR : STATE_COLOR[item.analysis.state]).split(",");
         const f = windowByName(item, "five_hour");
         const s = windowByName(item, "seven_day");
         if (f) {
@@ -614,17 +620,20 @@ export function renderMenuBar(snapshot = loadDisplayStatusSnapshot(), paths = bu
             lines.push("---");
             continue;
         }
-        lines.push(line(`${formatProviderLabel(item.usage.provider)}  ${STATE_LABEL[item.analysis.state]}`, {
+        lines.push(line(`${formatProviderLabel(item.usage.provider)}  ${item.usage.blocked ? "Blocked" : STATE_LABEL[item.analysis.state]}`, {
             ...providerIconParams(item.usage.provider),
             color: TEXT_COLOR,
             size: 14,
-            badge: providerBadge(item),
+            badge: item.usage.blocked ? "Frozen" : providerBadge(item),
         }));
         if (five) {
-            lines.push(usageLine("5h", five.usedPercent, five.resetsAt, TEXT_COLOR, dropdownBars[barIdx++]));
+            lines.push(usageLine("5h", five.usedPercent, five.resetsAt, TEXT_COLOR, now, dropdownBars[barIdx++]));
         }
         if (seven) {
-            lines.push(usageLine("7d", seven.usedPercent, seven.resetsAt, TEXT_COLOR, dropdownBars[barIdx++]));
+            lines.push(usageLine("7d", seven.usedPercent, seven.resetsAt, TEXT_COLOR, now, dropdownBars[barIdx++]));
+        }
+        if (item.usage.blocked) {
+            lines.push(muted(`Blocked  ${item.usage.blocked.reason}. 5h/7d numbers above still reflect the window quotas.`));
         }
         lines.push(muted(targetLabel(item)));
         lines.push(line(item.analysis.message, { color: MUTED_COLOR, size: 12, length: 84 }));

package/dist/status.js

@@ -12,6 +12,22 @@ function buildProviderMeta(usage, generatedAt, staleAfterSeconds) {
         stale: ageSeconds > staleAfterSeconds,
     };
 }
+// Coarse buckets keep the message stable between renders: an exact age changes
+// every second, which would defeat SwiftBar's unchanged-content guard and force
+// a menu rebuild each refresh while the data itself is unchanged.
+function staleAgeLabel(ageSeconds) {
+    const buckets = [
+        { seconds: 86_400, label: "1d" },
+        { seconds: 43_200, label: "12h" },
+        { seconds: 10_800, label: "3h" },
+        { seconds: 3_600, label: "1h" },
+        { seconds: 1_800, label: "30m" },
+        { seconds: 600, label: "10m" },
+        { seconds: 60, label: "1m" },
+    ];
+    const hit = buckets.find((bucket) => ageSeconds >= bucket.seconds);
+    return hit ? `over ${hit.label}` : "under 1m";
+}
 function staleIssuesFor(providers) {
     return providers
         .filter((provider) => provider.meta.stale)
@@ -19,7 +35,7 @@ function staleIssuesFor(providers) {
         provider: provider.usage.provider,
         severity: "warning",
         code: "USAGE_STALE",
-        message: `${provider.usage.provider} usage is stale; latest observation is ${provider.meta.ageSeconds}s old.`,
+        message: `${provider.usage.provider} usage is stale; latest observation is ${staleAgeLabel(provider.meta.ageSeconds)} old.`,
     }));
 }
 export function createStatusSnapshot(usages, profile, options = {}) {

package/dist/types.d.ts

@@ -19,6 +19,9 @@ export interface ProviderUsage {
         currency: string;
         isAvailable: boolean;
     };
+    blocked?: {
+        reason: string;
+    };
 }
 export interface BurnAnalysis {
     provider: ProviderId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coding-usage-bar",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "macOS menu bar usage monitor for Claude Code, Codex, GLM, DeepSeek, and MiniMax.",
   "author": "hanzhangzzz",
   "license": "MIT",