coding-usage-bar 0.2.2 → 0.3.0

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

@@ -132,6 +132,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 +179,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-render.d.ts

@@ -0,0 +1,67 @@
+export interface TitleSegment {
+    provider: string;
+    bars: Array<{
+        pct: number;
+        lightColor: string;
+        darkColor: string;
+    }>;
+    iconPath: string | null;
+    iconPathDark: string | null;
+}
+export interface TitleVariant {
+    dividerColor: string;
+    dividerAlpha: number;
+    barBgColor: string;
+    barBgAlpha: number;
+}
+export interface TitlePayload {
+    segments: TitleSegment[];
+    scale: number;
+    height: number;
+    minWidth: number;
+    paddingX: number;
+    iconSize: number;
+    iconBarGap: number;
+    segmentGap: number;
+    barWidth: number;
+    barHeight: number;
+    barGap: number;
+    barRadius: number;
+    barMinFill: number;
+    light: TitleVariant;
+    dark: TitleVariant;
+}
+interface RenderedImage {
+    image: string;
+    width: number;
+    height: number;
+}
+export declare function renderTitleImage(payload: TitlePayload): {
+    light: RenderedImage;
+    dark: RenderedImage;
+};
+export interface DropdownPayload {
+    bars: Array<{
+        pct: number;
+        lightColor: string;
+        darkColor: string;
+    }>;
+    scale: number;
+    barWidth: number;
+    barHeight: number;
+    barRadius: number;
+    light: {
+        barBgColor: string;
+        barBgAlpha: number;
+    };
+    dark: {
+        barBgColor: string;
+        barBgAlpha: number;
+    };
+}
+export declare function renderDropdownBars(payload: DropdownPayload): {
+    images: string[];
+    width: number;
+    height: number;
+};
+export {};

package/dist/menubar-render.js

@@ -0,0 +1,255 @@
+import fs from "node:fs";
+import { encodePNG, decodePNG } from "./png.js";
+// Pure-JS reimplementation of the menu bar image rendering that previously ran
+// through `osascript -l JavaScript` + AppKit. Spawning AppKit-linked processes
+// connects to the WindowServer and stalls the whole display for 1-2s on every
+// SwiftBar refresh; drawing the pixels in-process here never touches the
+// WindowServer, so there is zero UI freeze. Geometry, colors and the y-up
+// (bottom-left origin) coordinate system mirror the old AppKit code exactly so
+// the rendered images stay visually identical.
+const SUPERSAMPLE = 4; // 4x4 coverage sampling for anti-aliased rounded corners
+function parseHex(hex) {
+    const v = hex.replace("#", "");
+    return {
+        r: parseInt(v.slice(0, 2), 16) / 255,
+        g: parseInt(v.slice(2, 4), 16) / 255,
+        b: parseInt(v.slice(4, 6), 16) / 255,
+    };
+}
+class Canvas {
+    width;
+    height;
+    data; // straight-alpha RGBA, 0..1
+    constructor(width, height) {
+        this.width = width;
+        this.height = height;
+        this.data = new Float32Array(width * height * 4);
+    }
+    // Source-over compositing of a single pixel using straight alpha.
+    composite(px, py, color, alpha) {
+        if (alpha <= 0 || px < 0 || py < 0 || px >= this.width || py >= this.height) {
+            return;
+        }
+        const idx = (py * this.width + px) * 4;
+        const dr = this.data[idx];
+        const dg = this.data[idx + 1];
+        const db = this.data[idx + 2];
+        const da = this.data[idx + 3];
+        const outA = alpha + da * (1 - alpha);
+        if (outA <= 0) {
+            this.data[idx] = this.data[idx + 1] = this.data[idx + 2] = this.data[idx + 3] = 0;
+            return;
+        }
+        this.data[idx] = (color.r * alpha + dr * da * (1 - alpha)) / outA;
+        this.data[idx + 1] = (color.g * alpha + dg * da * (1 - alpha)) / outA;
+        this.data[idx + 2] = (color.b * alpha + db * da * (1 - alpha)) / outA;
+        this.data[idx + 3] = outA;
+    }
+    // Fill a rounded rectangle expressed in AppKit coordinates (origin bottom-left,
+    // y increases upward). r is clamped to half the smaller side, matching
+    // CGPathCreateWithRoundedRect.
+    fillRoundedRect(ax, ay, aw, ah, radius, color, alpha) {
+        const r = Math.min(radius, aw / 2, ah / 2);
+        const cx = ax + aw / 2;
+        const cy = ay + ah / 2;
+        const halfW = aw / 2 - r;
+        const halfH = ah / 2 - r;
+        const H = this.height;
+        const pxMin = Math.max(0, Math.floor(ax));
+        const pxMax = Math.min(this.width, Math.ceil(ax + aw));
+        const pyMin = Math.max(0, Math.floor(H - (ay + ah)));
+        const pyMax = Math.min(H, Math.ceil(H - ay));
+        for (let py = pyMin; py < pyMax; py++) {
+            for (let px = pxMin; px < pxMax; px++) {
+                let hits = 0;
+                for (let j = 0; j < SUPERSAMPLE; j++) {
+                    for (let i = 0; i < SUPERSAMPLE; i++) {
+                        const sx = px + (i + 0.5) / SUPERSAMPLE;
+                        const sPngY = py + (j + 0.5) / SUPERSAMPLE;
+                        const sy = H - sPngY; // back to AppKit y-up
+                        const qx = Math.abs(sx - cx) - halfW;
+                        const qy = Math.abs(sy - cy) - halfH;
+                        const dxo = Math.max(qx, 0);
+                        const dyo = Math.max(qy, 0);
+                        const dist = Math.sqrt(dxo * dxo + dyo * dyo) + Math.min(Math.max(qx, qy), 0) - r;
+                        if (dist <= 0)
+                            hits++;
+                    }
+                }
+                if (hits > 0) {
+                    this.composite(px, py, color, alpha * (hits / (SUPERSAMPLE * SUPERSAMPLE)));
+                }
+            }
+        }
+    }
+    // Draw an RGBA source image upright into an AppKit-space rect (bottom-left
+    // origin), bilinearly scaled to `size` x `size`. Mirrors NSImage.drawInRect.
+    drawIcon(icon, ax, ay, size) {
+        const H = this.height;
+        const pxMin = Math.max(0, Math.floor(ax));
+        const pxMax = Math.min(this.width, Math.ceil(ax + size));
+        const pyMin = Math.max(0, Math.floor(H - (ay + size)));
+        const pyMax = Math.min(H, Math.ceil(H - ay));
+        const iw = icon.width;
+        const ih = icon.height;
+        for (let py = pyMin; py < pyMax; py++) {
+            for (let px = pxMin; px < pxMax; px++) {
+                const cxA = px + 0.5;
+                const cyA = H - (py + 0.5);
+                const u = (cxA - ax) / size; // 0..1 left -> right
+                const v = (ay + size - cyA) / size; // 0..1 top -> bottom
+                if (u < 0 || u >= 1 || v < 0 || v >= 1)
+                    continue;
+                const sample = bilinear(icon.data, iw, ih, u * iw - 0.5, v * ih - 0.5);
+                if (sample.a > 0) {
+                    this.composite(px, py, { r: sample.r, g: sample.g, b: sample.b }, sample.a);
+                }
+            }
+        }
+    }
+    toPNGBase64() {
+        const out = new Uint8Array(this.width * this.height * 4);
+        for (let i = 0; i < this.width * this.height; i++) {
+            out[i * 4] = Math.round(clamp01(this.data[i * 4]) * 255);
+            out[i * 4 + 1] = Math.round(clamp01(this.data[i * 4 + 1]) * 255);
+            out[i * 4 + 2] = Math.round(clamp01(this.data[i * 4 + 2]) * 255);
+            out[i * 4 + 3] = Math.round(clamp01(this.data[i * 4 + 3]) * 255);
+        }
+        return encodePNG(out, this.width, this.height).toString("base64");
+    }
+}
+function clamp01(v) {
+    return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+function bilinear(data, w, h, fx, fy) {
+    const x0 = Math.floor(fx);
+    const y0 = Math.floor(fy);
+    const tx = fx - x0;
+    const ty = fy - y0;
+    const at = (x, y) => {
+        const cx = x < 0 ? 0 : x >= w ? w - 1 : x;
+        const cy = y < 0 ? 0 : y >= h ? h - 1 : y;
+        const idx = (cy * w + cx) * 4;
+        return {
+            r: data[idx] / 255,
+            g: data[idx + 1] / 255,
+            b: data[idx + 2] / 255,
+            a: data[idx + 3] / 255,
+        };
+    };
+    const c00 = at(x0, y0);
+    const c10 = at(x0 + 1, y0);
+    const c01 = at(x0, y0 + 1);
+    const c11 = at(x0 + 1, y0 + 1);
+    const lerp = (a, b, t) => a + (b - a) * t;
+    return {
+        r: lerp(lerp(c00.r, c10.r, tx), lerp(c01.r, c11.r, tx), ty),
+        g: lerp(lerp(c00.g, c10.g, tx), lerp(c01.g, c11.g, tx), ty),
+        b: lerp(lerp(c00.b, c10.b, tx), lerp(c01.b, c11.b, tx), ty),
+        a: lerp(lerp(c00.a, c10.a, tx), lerp(c01.a, c11.a, tx), ty),
+    };
+}
+const iconCache = new Map();
+function loadIcon(iconPath) {
+    if (iconCache.has(iconPath)) {
+        return iconCache.get(iconPath) ?? null;
+    }
+    let decoded = null;
+    try {
+        decoded = decodePNG(fs.readFileSync(iconPath));
+    }
+    catch {
+        decoded = null;
+    }
+    iconCache.set(iconPath, decoded);
+    return decoded;
+}
+function drawTitle(payload, variant, mode) {
+    const scale = payload.scale || 1;
+    const height = payload.height * scale;
+    const iconSize = payload.iconSize * scale;
+    const paddingX = payload.paddingX * scale;
+    const iconBarGap = payload.iconBarGap * scale;
+    const segmentGap = payload.segmentGap * scale;
+    const barWidth = payload.barWidth * scale;
+    const barHeight = payload.barHeight * scale;
+    const barGap = payload.barGap * scale;
+    const barRadius = payload.barRadius * scale;
+    const barMinFill = (payload.barMinFill || barRadius * 2) * scale;
+    const dividerW = 1 * scale;
+    let width = paddingX * 2;
+    payload.segments.forEach((seg, idx) => {
+        if (idx > 0)
+            width += segmentGap + dividerW + segmentGap;
+        width += (seg.iconPath ? iconSize + iconBarGap : 0) + barWidth;
+    });
+    width = Math.max(payload.minWidth * scale, width);
+    const canvas = new Canvas(Math.round(width), Math.round(height));
+    const dividerColor = parseHex(variant.dividerColor);
+    let x = paddingX;
+    const iconY = Math.floor((height - iconSize) / 2);
+    payload.segments.forEach((seg, idx) => {
+        if (idx > 0) {
+            x += segmentGap;
+            canvas.fillRoundedRect(x, Math.floor(height * 0.2), dividerW, Math.floor(height * 0.6), 0, dividerColor, variant.dividerAlpha);
+            x += dividerW + segmentGap;
+        }
+        const iconFile = mode === "dark" && seg.iconPathDark ? seg.iconPathDark : seg.iconPath;
+        if (iconFile) {
+            const icon = loadIcon(iconFile);
+            if (icon) {
+                canvas.drawIcon(icon, x, iconY, iconSize);
+            }
+            x += iconSize + iconBarGap;
+        }
+        const bars = seg.bars || [];
+        const totalH = bars.length * barHeight + Math.max(0, bars.length - 1) * barGap;
+        let barY = Math.floor((height + totalH) / 2) - barHeight;
+        const barBgColor = parseHex(variant.barBgColor);
+        for (let i = 0; i < bars.length; i++) {
+            canvas.fillRoundedRect(x, barY, barWidth, barHeight, barRadius, barBgColor, variant.barBgAlpha);
+            if (bars[i].pct > 0) {
+                const pct = Math.min(bars[i].pct, 100);
+                const fw = Math.max(barMinFill, Math.round((barWidth * pct) / 100));
+                const fillColor = parseHex(mode === "dark" ? bars[i].darkColor : bars[i].lightColor);
+                canvas.fillRoundedRect(x, barY, fw, barHeight, barRadius, fillColor, 1);
+            }
+            barY -= barHeight + barGap;
+        }
+        x += barWidth;
+    });
+    return {
+        image: canvas.toPNGBase64(),
+        width: Math.ceil(width / scale),
+        height: payload.height,
+    };
+}
+export function renderTitleImage(payload) {
+    return {
+        light: drawTitle(payload, payload.light, "light"),
+        dark: drawTitle(payload, payload.dark, "dark"),
+    };
+}
+function makeBar(bw, bh, br, pct, fill, bgColor, bgAlpha) {
+    const canvas = new Canvas(bw, bh);
+    canvas.fillRoundedRect(0, 0, bw, bh, br, bgColor, bgAlpha);
+    if (pct > 0) {
+        const fw = Math.max(br * 2, Math.round((bw * Math.min(pct, 100)) / 100));
+        canvas.fillRoundedRect(0, 0, fw, bh, br, fill, 1);
+    }
+    return canvas.toPNGBase64();
+}
+export function renderDropdownBars(payload) {
+    const s = payload.scale || 2;
+    const bw = payload.barWidth * s;
+    const bh = payload.barHeight * s;
+    const br = payload.barRadius * s;
+    const lightBg = parseHex(payload.light.barBgColor);
+    const darkBg = parseHex(payload.dark.barBgColor);
+    const images = payload.bars.map((bar) => {
+        const light = makeBar(bw, bh, br, bar.pct, parseHex(bar.lightColor), lightBg, payload.light.barBgAlpha);
+        const dark = makeBar(bw, bh, br, bar.pct, parseHex(bar.darkColor), darkBg, payload.dark.barBgAlpha);
+        return `${light},${dark}`;
+    });
+    return { images, width: payload.barWidth, height: payload.barHeight };
+}

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,10 +3,11 @@ 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";
+import { renderTitleImage, renderDropdownBars } from "./menubar-render.js";
 const MARKER = "coding-usage-bar managed SwiftBar plugin";
 const SWIFTBAR_APP_PATHS = ["/Applications/SwiftBar.app", path.join(process.env.HOME ?? "", "Applications", "SwiftBar.app")];
 const STATE_LABEL = {
@@ -65,154 +66,6 @@ const ASSET_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..
 const imageCache = new Map();
 const TITLE_IMAGE_SCALE = 2;
 const titleImageCache = new Map();
-const TITLE_IMAGE_SCRIPT = `
-ObjC.import('AppKit');
-ObjC.import('CoreGraphics');
-
-function drawImage(payload, variant, mode) {
-  var scale = payload.scale || 1;
-  var height = payload.height * scale;
-  var iconSize = payload.iconSize * scale;
-  var paddingX = payload.paddingX * scale;
-  var iconBarGap = payload.iconBarGap * scale;
-  var segmentGap = payload.segmentGap * scale;
-  var barWidth = payload.barWidth * scale;
-  var barHeight = payload.barHeight * scale;
-  var barGap = payload.barGap * scale;
-  var barRadius = payload.barRadius * scale;
-  var barMinFill = (payload.barMinFill || barRadius * 2) * scale;
-  var dividerW = 1 * scale;
-
-  var width = paddingX * 2;
-  payload.segments.forEach(function(seg, idx) {
-    if (idx > 0) width += segmentGap + dividerW + segmentGap;
-    width += (seg.iconPath ? iconSize + iconBarGap : 0) + barWidth;
-  });
-  width = Math.max(payload.minWidth * scale, width);
-
-  var rep = $.NSBitmapImageRep.alloc.initWithBitmapDataPlanesPixelsWidePixelsHighBitsPerSampleSamplesPerPixelHasAlphaIsPlanarColorSpaceNameBitmapFormatBytesPerRowBitsPerPixel(
-    null, width, height, 8, 4, true, false, $.NSDeviceRGBColorSpace, $.NSBitmapFormatAlphaPremultipliedLast, 0, 0
-  );
-  var nsctx = $.NSGraphicsContext.graphicsContextWithBitmapImageRep(rep);
-  $.NSGraphicsContext.setCurrentContext(nsctx);
-  nsctx.setShouldAntialias(true);
-  nsctx.setImageInterpolation($.NSImageInterpolationHigh);
-  var cg = nsctx.CGContext;
-
-  function setFill(hex, alpha) {
-    var v = hex.replace('#', '');
-    $.CGContextSetRGBFillColor(cg,
-      parseInt(v.slice(0, 2), 16) / 255,
-      parseInt(v.slice(2, 4), 16) / 255,
-      parseInt(v.slice(4, 6), 16) / 255,
-      alpha !== undefined ? alpha : 1);
-  }
-
-  function fillRoundedRect(rx, ry, rw, rh, rr) {
-    var p = $.CGPathCreateWithRoundedRect($.CGRectMake(rx, ry, rw, rh), rr, rr, null);
-    $.CGContextAddPath(cg, p);
-    $.CGContextFillPath(cg);
-  }
-
-  var x = paddingX;
-  var iconY = Math.floor((height - iconSize) / 2);
-
-  payload.segments.forEach(function(seg, idx) {
-    if (idx > 0) {
-      x += segmentGap;
-      setFill(variant.dividerColor, variant.dividerAlpha);
-      $.CGContextFillRect(cg, $.CGRectMake(x, Math.floor(height * 0.2), dividerW, Math.floor(height * 0.6)));
-      x += dividerW + segmentGap;
-    }
-    var iconFile = (mode === 'dark' && seg.iconPathDark) ? seg.iconPathDark : seg.iconPath;
-    if (iconFile) {
-      var icon = $.NSImage.alloc.initWithContentsOfFile($(iconFile));
-      if (icon) {
-        icon.drawInRectFromRectOperationFraction(
-          $.NSMakeRect(x, iconY, iconSize, iconSize),
-          $.NSZeroRect, $.NSCompositingOperationSourceOver, 1
-        );
-      }
-      x += iconSize + iconBarGap;
-    }
-    var bars = seg.bars || [];
-    var totalH = bars.length * barHeight + Math.max(0, bars.length - 1) * barGap;
-    var barY = Math.floor((height + totalH) / 2) - barHeight;
-    for (var i = 0; i < bars.length; i++) {
-      setFill(variant.barBgColor, variant.barBgAlpha);
-      fillRoundedRect(x, barY, barWidth, barHeight, barRadius);
-      if (bars[i].pct > 0) {
-        var pct = Math.min(bars[i].pct, 100);
-        var fw = Math.max(barMinFill, Math.round(barWidth * pct / 100));
-        setFill(bars[i][mode + 'Color'], 1);
-        fillRoundedRect(x, barY, fw, barHeight, barRadius);
-      }
-      barY -= barHeight + barGap;
-    }
-    x += barWidth;
-  });
-
-  var png = rep.representationUsingTypeProperties($.NSBitmapImageFileTypePNG, $.NSDictionary.alloc.init);
-  return {
-    image: ObjC.unwrap(png.base64EncodedStringWithOptions(0)),
-    width: Math.ceil(width / scale),
-    height: payload.height,
-  };
-}
-
-function run(argv) {
-  var payload = JSON.parse(argv[0]);
-  return JSON.stringify({
-    light: drawImage(payload, payload.light, 'light'),
-    dark: drawImage(payload, payload.dark, 'dark'),
-  });
-}
-`;
-const DROPDOWN_BAR_SCRIPT = `
-ObjC.import('AppKit');
-ObjC.import('CoreGraphics');
-
-function parseHex(hex) {
-  var v = hex.replace('#', '');
-  return [parseInt(v.slice(0,2),16)/255, parseInt(v.slice(2,4),16)/255, parseInt(v.slice(4,6),16)/255];
-}
-
-function makeBar(bw, bh, br, pct, fc, bgHex, bgAlpha) {
-  var rep = $.NSBitmapImageRep.alloc.initWithBitmapDataPlanesPixelsWidePixelsHighBitsPerSampleSamplesPerPixelHasAlphaIsPlanarColorSpaceNameBitmapFormatBytesPerRowBitsPerPixel(
-    null, bw, bh, 8, 4, true, false, $.NSDeviceRGBColorSpace, $.NSBitmapFormatAlphaPremultipliedLast, 0, 0);
-  var nsctx = $.NSGraphicsContext.graphicsContextWithBitmapImageRep(rep);
-  $.NSGraphicsContext.setCurrentContext(nsctx);
-  nsctx.setShouldAntialias(true);
-  var cg = nsctx.CGContext;
-  var bg = parseHex(bgHex);
-  $.CGContextSetRGBFillColor(cg, bg[0], bg[1], bg[2], bgAlpha);
-  var bp = $.CGPathCreateWithRoundedRect($.CGRectMake(0,0,bw,bh), br, br, null);
-  $.CGContextAddPath(cg, bp); $.CGContextFillPath(cg);
-  if (pct > 0) {
-    var fw = Math.max(br*2, Math.round(bw * Math.min(pct,100) / 100));
-    $.CGContextSetRGBFillColor(cg, fc[0], fc[1], fc[2], 1);
-    var fp = $.CGPathCreateWithRoundedRect($.CGRectMake(0,0,fw,bh), br, br, null);
-    $.CGContextAddPath(cg, fp); $.CGContextFillPath(cg);
-  }
-  var png = rep.representationUsingTypeProperties($.NSBitmapImageFileTypePNG, $.NSDictionary.alloc.init);
-  return ObjC.unwrap(png.base64EncodedStringWithOptions(0));
-}
-
-function run(argv) {
-  var p = JSON.parse(argv[0]);
-  var s = p.scale || 2;
-  var bw = p.barWidth * s, bh = p.barHeight * s, br = p.barRadius * s;
-  var results = [];
-  for (var i = 0; i < p.bars.length; i++) {
-    var bar = p.bars[i];
-    var lc = parseHex(bar.lightColor), dc = parseHex(bar.darkColor);
-    var li = makeBar(bw, bh, br, bar.pct, lc, p.light.barBgColor, p.light.barBgAlpha);
-    var di = makeBar(bw, bh, br, bar.pct, dc, p.dark.barBgColor, p.dark.barBgAlpha);
-    results.push(li + ',' + di);
-  }
-  return JSON.stringify({images: results, width: p.barWidth, height: p.barHeight});
-}
-`;
 const dropdownBarCache = new Map();
 function renderDropdownBarImages(bars) {
     if (bars.length === 0) {
@@ -233,11 +86,7 @@ function renderDropdownBarImages(bars) {
         return cached ? cached.images.map((img) => ({ image: img, width: cached.width, height: cached.height })) : [];
     }
     try {
-        const output = execFileSync("/usr/bin/osascript", ["-l", "JavaScript", "-e", DROPDOWN_BAR_SCRIPT, cacheKey], {
-            encoding: "utf8",
-            timeout: 3000,
-        }).trim();
-        const result = JSON.parse(output);
+        const result = renderDropdownBars(payload);
         dropdownBarCache.set(cacheKey, result);
         return result.images.map((img) => ({ image: img, width: result.width, height: result.height }));
     }
@@ -489,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 = [];
@@ -559,11 +410,7 @@ function titleImageValue(providers) {
         return titleImageCache.get(cacheKey);
     }
     try {
-        const output = execFileSync("/usr/bin/osascript", ["-l", "JavaScript", "-e", TITLE_IMAGE_SCRIPT, cacheKey], {
-            encoding: "utf8",
-            timeout: 2500,
-        }).trim();
-        const images = JSON.parse(output);
+        const images = renderTitleImage(payload);
         const value = images.light?.image && images.dark?.image && images.light.width && images.light.height
             ? {
                 image: `${images.light.image},${images.dark.image}`,
@@ -605,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,
@@ -618,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,
@@ -645,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") {
@@ -672,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} `);
@@ -726,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 = [];
@@ -734,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) {
@@ -769,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/png.d.ts

@@ -0,0 +1,7 @@
+export declare function encodePNG(rgba: Uint8Array, width: number, height: number): Buffer;
+export interface DecodedPNG {
+    width: number;
+    height: number;
+    data: Uint8Array;
+}
+export declare function decodePNG(buffer: Buffer): DecodedPNG;

package/dist/png.js

@@ -0,0 +1,141 @@
+import zlib from "node:zlib";
+// Minimal zero-dependency PNG codec, scoped to 8-bit RGBA, non-interlaced images.
+// That is the only format this tool renders (menu bar strips) and the only
+// format its provider icon assets use (all 18x18 RGBA8). Keeping the codec tiny
+// preserves the package's zero-runtime-dependency property.
+const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+const CRC_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++) {
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        }
+        table[n] = c >>> 0;
+    }
+    return table;
+})();
+function crc32(buf) {
+    let c = 0xffffffff;
+    for (let i = 0; i < buf.length; i++) {
+        c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
+    }
+    return (c ^ 0xffffffff) >>> 0;
+}
+function chunk(type, data) {
+    const typeBuf = Buffer.from(type, "ascii");
+    const len = Buffer.alloc(4);
+    len.writeUInt32BE(data.length, 0);
+    const crcBuf = Buffer.alloc(4);
+    crcBuf.writeUInt32BE(crc32(Buffer.concat([typeBuf, data])), 0);
+    return Buffer.concat([len, typeBuf, data, crcBuf]);
+}
+export function encodePNG(rgba, width, height) {
+    const stride = width * 4;
+    // One filter byte (0 = None) per scanline, followed by the raw RGBA row.
+    const raw = Buffer.alloc(height * (stride + 1));
+    for (let y = 0; y < height; y++) {
+        const dst = y * (stride + 1);
+        raw[dst] = 0;
+        for (let i = 0; i < stride; i++) {
+            raw[dst + 1 + i] = rgba[y * stride + i];
+        }
+    }
+    const ihdr = Buffer.alloc(13);
+    ihdr.writeUInt32BE(width, 0);
+    ihdr.writeUInt32BE(height, 4);
+    ihdr[8] = 8; // bit depth
+    ihdr[9] = 6; // color type: RGBA
+    ihdr[10] = 0; // compression
+    ihdr[11] = 0; // filter
+    ihdr[12] = 0; // interlace
+    const idat = zlib.deflateSync(raw, { level: 9 });
+    return Buffer.concat([
+        PNG_SIGNATURE,
+        chunk("IHDR", ihdr),
+        chunk("IDAT", idat),
+        chunk("IEND", Buffer.alloc(0)),
+    ]);
+}
+function paeth(a, b, c) {
+    const p = a + b - c;
+    const pa = Math.abs(p - a);
+    const pb = Math.abs(p - b);
+    const pc = Math.abs(p - c);
+    if (pa <= pb && pa <= pc)
+        return a;
+    if (pb <= pc)
+        return b;
+    return c;
+}
+export function decodePNG(buffer) {
+    if (!buffer.subarray(0, 8).equals(PNG_SIGNATURE)) {
+        throw new Error("decodePNG: not a PNG file");
+    }
+    let offset = 8;
+    let width = 0;
+    let height = 0;
+    const idatParts = [];
+    while (offset < buffer.length) {
+        const len = buffer.readUInt32BE(offset);
+        const type = buffer.toString("ascii", offset + 4, offset + 8);
+        const dataStart = offset + 8;
+        const data = buffer.subarray(dataStart, dataStart + len);
+        if (type === "IHDR") {
+            width = data.readUInt32BE(0);
+            height = data.readUInt32BE(4);
+            const bitDepth = data[8];
+            const colorType = data[9];
+            const interlace = data[12];
+            if (bitDepth !== 8 || colorType !== 6 || interlace !== 0) {
+                throw new Error(`decodePNG: unsupported PNG (bitDepth=${bitDepth} colorType=${colorType} interlace=${interlace}); only 8-bit RGBA non-interlaced is supported`);
+            }
+        }
+        else if (type === "IDAT") {
+            idatParts.push(Buffer.from(data));
+        }
+        else if (type === "IEND") {
+            break;
+        }
+        offset = dataStart + len + 4; // skip data + CRC
+    }
+    const inflated = zlib.inflateSync(Buffer.concat(idatParts));
+    const bpp = 4;
+    const stride = width * bpp;
+    const out = new Uint8Array(width * height * bpp);
+    let prev = new Uint8Array(stride);
+    for (let y = 0; y < height; y++) {
+        const filterType = inflated[y * (stride + 1)];
+        const rowStart = y * (stride + 1) + 1;
+        const cur = new Uint8Array(stride);
+        for (let i = 0; i < stride; i++) {
+            const rawByte = inflated[rowStart + i];
+            const a = i >= bpp ? cur[i - bpp] : 0;
+            const b = prev[i];
+            const c = i >= bpp ? prev[i - bpp] : 0;
+            let value;
+            switch (filterType) {
+                case 0:
+                    value = rawByte;
+                    break;
+                case 1:
+                    value = rawByte + a;
+                    break;
+                case 2:
+                    value = rawByte + b;
+                    break;
+                case 3:
+                    value = rawByte + ((a + b) >> 1);
+                    break;
+                case 4:
+                    value = rawByte + paeth(a, b, c);
+                    break;
+                default: throw new Error(`decodePNG: unknown filter type ${filterType}`);
+            }
+            cur[i] = value & 0xff;
+        }
+        out.set(cur, y * stride);
+        prev = cur;
+    }
+    return { width, height, data: out };
+}

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.2",
+  "version": "0.3.0",
   "description": "macOS menu bar usage monitor for Claude Code, Codex, GLM, DeepSeek, and MiniMax.",
   "author": "hanzhangzzz",
   "license": "MIT",