coding-usage-bar 0.3.1 → 0.4.1

package/dist/notifier.js

@@ -6,6 +6,14 @@ import { readJsonFile, writeJsonAtomic } from "./fs-util.js";
 import { buildPaths, installedAssetPath } from "./paths.js";
 import { formatDurationUntil } from "./format.js";
 import { writeNotificationCard } from "./card.js";
+// State is keyed by provider. Legacy records were keyed `provider:state` and
+// re-notified on a cooldown, which spammed osascript spawns all day; dropping
+// those keys makes each provider re-notify once after upgrade, then follow the
+// transition-based rules.
+function readNotificationState(paths) {
+    const raw = readJsonFile(paths.notificationStateFile) ?? {};
+    return Object.fromEntries(Object.entries(raw).filter(([key]) => !key.includes(":")));
+}
 export function commandExists(command) {
     const result = spawnSync("/bin/sh", ["-c", `command -v ${command}`], {
         stdio: "ignore",
@@ -24,33 +32,56 @@ export function notificationBackend() {
 function cooldownMinutes(profile) {
     return profile === "high" ? 15 : 30;
 }
-function notificationKey(analysis) {
-    return `${analysis.provider}:${analysis.state}`;
-}
+// Notify only on a state transition or when the 5h window resets while the
+// alert persists — never on a periodic cooldown. The cooldown only acts as a
+// per-provider floor between notifications so a flapping state cannot spam.
 export function shouldNotify(analysis, paths = buildPaths(), now = new Date()) {
     if (analysis.state === "RAW" || analysis.state === "ON_TRACK") {
         return false;
     }
-    const state = readJsonFile(paths.notificationStateFile) ?? {};
-    const key = notificationKey(analysis);
-    const previous = state[key];
-    const resetAt = analysis.fiveHour?.resetsAt;
+    const previous = readNotificationState(paths)[analysis.provider];
     if (!previous) {
         return true;
     }
-    if (previous.resetAt && resetAt && previous.resetAt !== resetAt) {
+    if (previous.state === analysis.state) {
+        const resetAt = analysis.fiveHour?.resetsAt;
+        const sameWindow = !previous.resetAt || !resetAt || previous.resetAt === resetAt;
+        if (sameWindow) {
+            return false;
+        }
+    }
+    if (!previous.notifiedAt) {
         return true;
     }
     const elapsedMinutes = (now.getTime() - Date.parse(previous.notifiedAt)) / 60_000;
     return elapsedMinutes >= cooldownMinutes(analysis.profile);
 }
 export function markNotified(analysis, paths = buildPaths(), now = new Date()) {
-    const state = readJsonFile(paths.notificationStateFile) ?? {};
-    state[notificationKey(analysis)] = {
-        notifiedAt: now.toISOString(),
-        resetAt: analysis.fiveHour?.resetsAt,
-    };
-    writeJsonAtomic(paths.notificationStateFile, state);
+    const state = readNotificationState(paths);
+    writeJsonAtomic(paths.notificationStateFile, {
+        ...state,
+        [analysis.provider]: {
+            state: analysis.state,
+            notifiedAt: now.toISOString(),
+            resetAt: analysis.fiveHour?.resetsAt,
+        },
+    });
+}
+// Record recovery so the next entry into an alert state counts as a transition
+// and notifies again. Keeps notifiedAt so the anti-flap floor still applies.
+export function markRecovered(analysis, paths = buildPaths()) {
+    if (analysis.state !== "ON_TRACK") {
+        return;
+    }
+    const state = readNotificationState(paths);
+    const previous = state[analysis.provider];
+    if (!previous || previous.state === "ON_TRACK") {
+        return;
+    }
+    writeJsonAtomic(paths.notificationStateFile, {
+        ...state,
+        [analysis.provider]: { ...previous, state: "ON_TRACK" },
+    });
 }
 function notificationText(analysis) {
     const provider = analysis.provider === "claude" ? "Claude" : analysis.provider === "glm" ? "GLM" : analysis.provider === "minimax" ? "MiniMax" : analysis.provider === "deepseek" ? "DeepSeek" : analysis.provider === "kimi" ? "Kimi" : "Codex";

package/dist/paths.js

@@ -22,6 +22,7 @@ export function buildPaths(homeDir = os.homedir()) {
         launchAgentFile: path.join(homeDir, "Library", "LaunchAgents", "com.duying.coding-usage-bar.plist"),
         claudeSettingsFile: path.join(homeDir, ".claude", "settings.json"),
         claudeStatusLineScript: path.join(stateDir, "claude", "statusline.sh"),
+        glyphsDir: path.join(stateDir, "glyphs"),
     };
 }
 export function installedAssetPath(homeDir, assetName) {

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/dist/types.d.ts

@@ -78,6 +78,7 @@ export interface RuntimePaths {
     launchAgentFile: string;
     claudeSettingsFile: string;
     claudeStatusLineScript: string;
+    glyphsDir: string;
 }
 export interface ProviderStatus {
     usage: ProviderUsage;

package/package.json

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