coding-usage-bar 0.4.0 → 0.4.1

package/dist/burn.d.ts

@@ -1,3 +1,4 @@
 import { BurnAnalysis, BurnProfile, ProviderUsage } from "./types.js";
 export declare function estimateConversionRate(samples: ProviderUsage[]): number | null;
+export declare function analyzeUsageWithConversionRate(usage: ProviderUsage, conversionRate: number | null, profile?: BurnProfile, now?: Date): BurnAnalysis;
 export declare function analyzeUsage(usage: ProviderUsage, samples: ProviderUsage[], profile?: BurnProfile, now?: Date): BurnAnalysis;

package/dist/burn.js

@@ -74,7 +74,7 @@ function messageForState(provider, state, fiveUsed, target) {
     }
     return `${label} burn pace is on track (${round(fiveUsed)}%, target ${round(target.min)}%-${round(target.max)}%).`;
 }
-export function analyzeUsage(usage, samples, profile = "low", now = new Date()) {
+function analyzeUsageWithRateResolver(usage, resolveConversionRate, profile = "low", now = new Date()) {
     const fiveHour = findWindow(usage, "five_hour");
     const sevenDay = findWindow(usage, "seven_day");
     if (usage.balance && usage.windows.length === 0) {
@@ -118,7 +118,7 @@ export function analyzeUsage(usage, samples, profile = "low", now = new Date())
             message,
         };
     }
-    const conversionRate = estimateConversionRate(samples);
+    const conversionRate = resolveConversionRate();
     if (conversionRate === null) {
         return {
             provider: usage.provider,
@@ -162,3 +162,9 @@ export function analyzeUsage(usage, samples, profile = "low", now = new Date())
         }),
     };
 }
+export function analyzeUsageWithConversionRate(usage, conversionRate, profile = "low", now = new Date()) {
+    return analyzeUsageWithRateResolver(usage, () => conversionRate, profile, now);
+}
+export function analyzeUsage(usage, samples, profile = "low", now = new Date()) {
+    return analyzeUsageWithRateResolver(usage, () => estimateConversionRate(samples), profile, now);
+}

package/dist/cli.js

@@ -10,6 +10,7 @@ import { installMenuBar, renderMenuBar, uninstallMenuBar, toggleCompactMode } fr
 import { buildPaths } from "./paths.js";
 import { bakeGlyphAtlases } from "./glyphs.js";
 import { maybePromptForStar } from "./star.js";
+import { updateStatusSnapshotUsage } from "./status.js";
 function hasFlag(args, flag) {
     return args.includes(flag);
 }
@@ -119,6 +120,13 @@ async function main() {
             const parsed = JSON.parse(input);
             const usage = usageFromClaudeStatusLine(parsed);
             saveUsage(usage);
+            try {
+                updateStatusSnapshotUsage(usage);
+            }
+            catch {
+                // The provider cache is authoritative. A later daemon run can rebuild
+                // status.json if this best-effort display update loses lock contention.
+            }
             return;
         }
         if (command === "daemon") {

package/dist/runtime.d.ts

@@ -13,6 +13,12 @@ export declare function analyzeUsages(usages: ProviderUsage[], profile: BurnProf
 export declare function readProfile(): BurnProfile;
 export declare function loadFixtureSamples(provider: string): ProviderUsage[];
 export declare function analyzeFixtureUsages(usages: ProviderUsage[], profile: BurnProfile): BurnAnalysis[];
+export declare function commitCollectedStatusSnapshot(usages: ProviderUsage[], issues: StatusIssue[], options?: {
+    paths?: RuntimePaths;
+    profile?: BurnProfile;
+    generatedAt?: Date;
+    fixtureSamples?: Map<string, ProviderUsage[]>;
+}): StatusSnapshot;
 export declare function collectStatusSnapshot(options?: {
     fixtures?: boolean;
 }): Promise<StatusSnapshot>;

package/dist/runtime.js

@@ -10,7 +10,7 @@ import { collectKimiUsage, resolveKimiConfig } from "./kimi.js";
 import { collectMinimaxUsage } from "./minimax.js";
 import { buildPaths } from "./paths.js";
 import { loadLatestUsage, saveUsage } from "./store.js";
-import { createStatusSnapshot, loadStatusSnapshot, refreshStatusSnapshotFreshness, saveStatusSnapshot, } from "./status.js";
+import { createStatusSnapshot, loadStatusSnapshot, reconcileLatestUsages, replaceStatusSnapshotUsage, refreshStatusSnapshotFreshness, saveStatusSnapshot, withStatusSnapshotLock, } from "./status.js";
 const FIXTURES_DIR = fileURLToPath(new URL("../fixtures", import.meta.url));
 export function loadFixtureUsages(fixturesDir) {
     const providers = ["claude", "codex", "glm", "deepseek", "minimax", "kimi"];
@@ -248,17 +248,42 @@ export function analyzeFixtureUsages(usages, profile) {
     const fixtureSamples = new Map(usages.map((usage) => [usage.provider, loadFixtureSamples(usage.provider)]));
     return createStatusSnapshot(usages, profile, { fixtureSamples }).providers.map((provider) => provider.analysis);
 }
+export function commitCollectedStatusSnapshot(usages, issues, options = {}) {
+    const paths = options.paths ?? buildPaths();
+    const profile = options.profile ?? readProfile();
+    const now = options.generatedAt ?? new Date();
+    const candidate = createStatusSnapshot(usages, profile, {
+        paths,
+        generatedAt: now,
+        fixtureSamples: options.fixtureSamples,
+        issues,
+    });
+    return withStatusSnapshotLock(paths, () => {
+        const existing = loadStatusSnapshot(paths);
+        const cached = reconcileLatestUsages(usages, paths);
+        let snapshot = candidate;
+        for (const usage of cached) {
+            snapshot = replaceStatusSnapshotUsage(snapshot, usage, now);
+        }
+        if (existing) {
+            for (const provider of existing.providers) {
+                snapshot = replaceStatusSnapshotUsage(snapshot, provider.usage, now);
+            }
+        }
+        saveStatusSnapshot(snapshot, paths);
+        return snapshot;
+    });
+}
 export async function collectStatusSnapshot(options = {}) {
     const { usages, issues } = await collectLocalState(options);
     const profile = readProfile();
     const fixtureSamples = options.fixtures
         ? new Map(usages.map((usage) => [usage.provider, loadFixtureSamples(usage.provider)]))
         : undefined;
-    const snapshot = createStatusSnapshot(usages, profile, { fixtureSamples, issues });
     if (!options.fixtures) {
-        saveStatusSnapshot(snapshot);
+        return commitCollectedStatusSnapshot(usages, issues, { profile });
     }
-    return snapshot;
+    return createStatusSnapshot(usages, profile, { fixtureSamples, issues });
 }
 export function loadDisplayStatusSnapshot(options = {}) {
     if (options.fixtures || options.refresh) {

package/dist/status.d.ts

@@ -1,4 +1,6 @@
 import { BurnProfile, ProviderUsage, RuntimePaths, StatusIssue, StatusSnapshot } from "./types.js";
+export declare function withStatusSnapshotLock<T>(paths: RuntimePaths, action: () => T): T;
+export declare function reconcileLatestUsages(usages: ProviderUsage[], paths: RuntimePaths): ProviderUsage[];
 export declare function createStatusSnapshot(usages: ProviderUsage[], profile: BurnProfile, options?: {
     paths?: RuntimePaths;
     generatedAt?: Date;
@@ -12,3 +14,5 @@ export declare function refreshStatusSnapshotFreshness(snapshot: StatusSnapshot,
 }): StatusSnapshot;
 export declare function saveStatusSnapshot(snapshot: StatusSnapshot, paths?: RuntimePaths): void;
 export declare function loadStatusSnapshot(paths?: RuntimePaths): StatusSnapshot | null;
+export declare function replaceStatusSnapshotUsage(existing: StatusSnapshot | null, usage: ProviderUsage, now?: Date): StatusSnapshot;
+export declare function updateStatusSnapshotUsage(usage: ProviderUsage, paths?: RuntimePaths): StatusSnapshot;

package/dist/status.js

@@ -1,8 +1,91 @@
-import { analyzeUsage } from "./burn.js";
-import { readJsonFile, writeJsonAtomic } from "./fs-util.js";
-import { buildPaths } from "./paths.js";
+import fs from "node:fs";
+import path from "node:path";
+import { analyzeUsage, analyzeUsageWithConversionRate } from "./burn.js";
+import { ensureDir, readJsonFile, writeJsonAtomic } from "./fs-util.js";
+import { buildPaths, providerLatestPath } from "./paths.js";
 import { loadSamples } from "./store.js";
 const DEFAULT_STALE_AFTER_SECONDS = 10 * 60;
+const STATUS_LOCK_RETRY_MS = 5;
+const STATUS_LOCK_TIMEOUT_MS = 2_000;
+const STATUS_LOCK_STALE_MS = 10_000;
+const lockWaitArray = new Int32Array(new SharedArrayBuffer(4));
+function waitForStatusLock() {
+    Atomics.wait(lockWaitArray, 0, 0, STATUS_LOCK_RETRY_MS);
+}
+export function withStatusSnapshotLock(paths, action) {
+    const lockFile = `${paths.statusFile}.lock`;
+    const deadline = Date.now() + STATUS_LOCK_TIMEOUT_MS;
+    ensureDir(path.dirname(lockFile));
+    let descriptor = null;
+    while (descriptor === null) {
+        try {
+            descriptor = fs.openSync(lockFile, "wx", 0o600);
+            fs.writeFileSync(descriptor, `${process.pid}\n`, "utf8");
+        }
+        catch (error) {
+            if (error.code !== "EEXIST") {
+                throw error;
+            }
+            try {
+                const ageMs = Date.now() - fs.statSync(lockFile).mtimeMs;
+                if (ageMs > STATUS_LOCK_STALE_MS) {
+                    fs.unlinkSync(lockFile);
+                    continue;
+                }
+            }
+            catch (statError) {
+                if (statError.code === "ENOENT") {
+                    continue;
+                }
+                throw statError;
+            }
+            if (Date.now() >= deadline) {
+                throw new Error(`Timed out waiting for status snapshot lock at ${lockFile}`);
+            }
+            waitForStatusLock();
+        }
+    }
+    try {
+        return action();
+    }
+    finally {
+        fs.closeSync(descriptor);
+        try {
+            fs.unlinkSync(lockFile);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+}
+function observedAtMs(usage) {
+    const value = Date.parse(usage.observedAt);
+    return Number.isFinite(value) ? value : null;
+}
+function newestUsage(usages) {
+    return usages.reduce((latest, candidate) => {
+        const latestTime = observedAtMs(latest);
+        const candidateTime = observedAtMs(candidate);
+        return candidateTime !== null && (latestTime === null || candidateTime > latestTime)
+            ? candidate
+            : latest;
+    });
+}
+export function reconcileLatestUsages(usages, paths) {
+    return usages.map((usage) => {
+        const cached = readJsonFile(providerLatestPath(paths, usage.provider));
+        if (!cached || cached.provider !== usage.provider) {
+            return usage;
+        }
+        const cachedTime = observedAtMs(cached);
+        const usageTime = observedAtMs(usage);
+        return cachedTime !== null && (usageTime === null || cachedTime > usageTime)
+            ? cached
+            : usage;
+    });
+}
 function buildProviderMeta(usage, generatedAt, staleAfterSeconds) {
     const ageSeconds = Math.max(0, Math.round((generatedAt.getTime() - Date.parse(usage.observedAt)) / 1000));
     return {
@@ -79,3 +162,39 @@ export function saveStatusSnapshot(snapshot, paths = buildPaths()) {
 export function loadStatusSnapshot(paths = buildPaths()) {
     return readJsonFile(paths.statusFile);
 }
+export function replaceStatusSnapshotUsage(existing, usage, now = new Date()) {
+    if (!existing) {
+        return createStatusSnapshot([usage], "low", {
+            generatedAt: now,
+            fixtureSamples: new Map([[usage.provider, []]]),
+        });
+    }
+    const previous = existing.providers.find((provider) => provider.usage.provider === usage.provider);
+    const selectedUsage = previous ? newestUsage([previous.usage, usage]) : usage;
+    const conversionRate = previous?.analysis.target?.conversionRate ?? null;
+    const provider = {
+        usage: selectedUsage,
+        analysis: analyzeUsageWithConversionRate(selectedUsage, conversionRate, existing.profile, now),
+        meta: buildProviderMeta(selectedUsage, now, DEFAULT_STALE_AFTER_SECONDS),
+    };
+    const providers = previous
+        ? existing.providers.map((item) => item.usage.provider === usage.provider ? provider : item)
+        : [...existing.providers, provider];
+    return refreshStatusSnapshotFreshness({
+        ...existing,
+        generatedAt: now.toISOString(),
+        providers,
+        issues: existing.issues.filter((issue) => (issue.code !== "USAGE_STALE"
+            && !(issue.provider === usage.provider && issue.code === "CLAUDE_INGEST_MISSING"))),
+    }, { now });
+}
+export function updateStatusSnapshotUsage(usage, paths = buildPaths()) {
+    return withStatusSnapshotLock(paths, () => {
+        const now = new Date();
+        const existing = loadStatusSnapshot(paths);
+        const cached = reconcileLatestUsages([usage], paths)[0];
+        const snapshot = replaceStatusSnapshotUsage(existing, newestUsage([usage, cached]), now);
+        saveStatusSnapshot(snapshot, paths);
+        return snapshot;
+    });
+}

package/package.json

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