coding-usage-bar 0.1.0

package/dist/claude.js

@@ -0,0 +1,141 @@
+import fs from "node:fs";
+import path from "node:path";
+import { makeProviderUsage, normalizeWindow } from "./usage.js";
+export function usageFromClaudeStatusLine(input) {
+    if (input === null || typeof input !== "object") {
+        throw new Error("Claude status line input must be a JSON object");
+    }
+    const record = input;
+    const rateLimits = record.rate_limits;
+    if (!rateLimits || typeof rateLimits !== "object") {
+        throw new Error("Claude usage unavailable: status line input has no rate_limits field");
+    }
+    const fiveHour = normalizeWindow("five_hour", rateLimits.five_hour, 300);
+    const sevenDay = normalizeWindow("seven_day", rateLimits.seven_day, 10080);
+    if (!fiveHour || !sevenDay) {
+        throw new Error("Claude usage unavailable: missing five_hour or seven_day rate limit window");
+    }
+    return makeProviderUsage({
+        provider: "claude",
+        source: "claude_statusline_stdin",
+        fiveHour,
+        sevenDay,
+    });
+}
+export function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => resolve(data));
+        process.stdin.on("error", reject);
+    });
+}
+export function readClaudeSettings(file) {
+    let contents;
+    try {
+        contents = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw new Error(`Cannot read Claude settings at ${file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    try {
+        return JSON.parse(contents);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON in Claude settings at ${file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function getClaudeStatusLineCommand(settings) {
+    const statusLine = settings?.statusLine;
+    if (statusLine && typeof statusLine === "object") {
+        const command = statusLine.command;
+        return typeof command === "string" ? command : null;
+    }
+    return null;
+}
+function splitShellWords(command) {
+    const words = [];
+    let current = "";
+    let quote = null;
+    let escaped = false;
+    for (const char of command) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === "\\" && quote !== "'") {
+            escaped = true;
+            continue;
+        }
+        if ((char === "'" || char === "\"") && !quote) {
+            quote = char;
+            continue;
+        }
+        if (char === quote) {
+            quote = null;
+            continue;
+        }
+        if (/\s/.test(char) && !quote) {
+            if (current) {
+                words.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current) {
+        words.push(current);
+    }
+    return words;
+}
+function statusLineScriptCandidates(command) {
+    const words = splitShellWords(command);
+    const candidates = [command];
+    const interpreter = path.basename(words[0] ?? "");
+    if (["bash", "sh", "zsh", "node"].includes(interpreter)) {
+        for (const word of words.slice(1)) {
+            if (word === "-c") {
+                break;
+            }
+            if (word.startsWith("-")) {
+                continue;
+            }
+            candidates.push(word);
+            break;
+        }
+    }
+    return [...new Set(candidates)];
+}
+export function claudeStatusLineHasIngest(command, options) {
+    if (!command) {
+        return false;
+    }
+    if (command.includes("coding-usage-bar ingest claude-statusline")
+        || command.includes(options.appCliPath)
+        || command === options.managedScriptPath) {
+        return true;
+    }
+    for (const candidate of statusLineScriptCandidates(command)) {
+        try {
+            if (!fs.statSync(candidate).isFile()) {
+                continue;
+            }
+            const script = fs.readFileSync(candidate, "utf8");
+            if (script.includes("coding-usage-bar ingest claude-statusline") || script.includes(options.appCliPath)) {
+                return true;
+            }
+        }
+        catch {
+            // Ignore command strings that are not readable script paths.
+        }
+    }
+    return false;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+import { usageFromClaudeStatusLine, readStdin } from "./claude.js";
+import { install, uninstall } from "./install.js";
+import { saveUsage } from "./store.js";
+import { formatStatusRows, formatAnalysisDetail, formatIssues, formatProviderMeta } from "./format.js";
+import { loadDisplayStatusSnapshot, collectStatusSnapshot } from "./runtime.js";
+import { runDaemonOnce } from "./daemon.js";
+import { doctorHasFailures, formatDoctor, runDoctor } from "./doctor.js";
+import { installMenuBar, renderMenuBar, uninstallMenuBar, toggleCompactMode } from "./menubar.js";
+import { buildPaths } from "./paths.js";
+import { maybePromptForStar } from "./star.js";
+function hasFlag(args, flag) {
+    return args.includes(flag);
+}
+function printHelp() {
+    console.log(`Coding Usage Bar
+
+Usage:
+  coding-usage-bar install [--dry-run]
+  coding-usage-bar uninstall [--dry-run]
+  coding-usage-bar doctor [--dry-run]
+  coding-usage-bar status [--fixtures] [--json] [--refresh]
+  coding-usage-bar menubar render
+  coding-usage-bar menubar install [--dry-run]
+  coding-usage-bar menubar uninstall [--dry-run]
+  coding-usage-bar menubar toggle-compact
+  coding-usage-bar ingest claude-statusline
+  coding-usage-bar daemon [--once] [--dry-run]
+`);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    const subcommand = args[1];
+    const dryRun = hasFlag(args, "--dry-run");
+    try {
+        if (!command || command === "-h" || command === "--help") {
+            printHelp();
+            return;
+        }
+        if (command === "install") {
+            const messages = install({ dryRun });
+            console.log(messages.join("\n"));
+            if (messages.some((message) => message.startsWith("Installed and restarted launchd agent:"))) {
+                const starMessages = maybePromptForStar(buildPaths(), { dryRun, env: process.env });
+                if (starMessages.length > 0) {
+                    console.log(starMessages.join("\n"));
+                }
+            }
+            return;
+        }
+        if (command === "uninstall") {
+            console.log(uninstall({ dryRun }).join("\n"));
+            return;
+        }
+        if (command === "doctor") {
+            const checks = runDoctor({ dryRun });
+            console.log(formatDoctor(checks));
+            if (doctorHasFailures(checks)) {
+                process.exitCode = 1;
+            }
+            return;
+        }
+        if (command === "status") {
+            const fixtures = hasFlag(args, "--fixtures");
+            const json = hasFlag(args, "--json");
+            const refresh = hasFlag(args, "--refresh");
+            const snapshot = refresh || fixtures
+                ? await collectStatusSnapshot({ fixtures })
+                : loadDisplayStatusSnapshot();
+            if (json) {
+                console.log(JSON.stringify(snapshot, null, 2));
+                return;
+            }
+            const usages = snapshot.providers.map((provider) => provider.usage);
+            const analyses = snapshot.providers.map((provider) => provider.analysis);
+            console.log(formatStatusRows(usages, analyses));
+            console.log("");
+            for (const analysis of analyses) {
+                console.log(formatAnalysisDetail(analysis));
+            }
+            const meta = formatProviderMeta(snapshot);
+            if (meta) {
+                console.log("");
+                console.log(meta);
+            }
+            const issues = formatIssues(snapshot.issues);
+            if (issues) {
+                console.log("");
+                console.log(issues);
+            }
+            return;
+        }
+        if (command === "menubar" && subcommand === "render") {
+            console.log(renderMenuBar());
+            return;
+        }
+        if (command === "menubar" && subcommand === "install") {
+            console.log(installMenuBar({ dryRun }).join("\n"));
+            return;
+        }
+        if (command === "menubar" && subcommand === "uninstall") {
+            console.log(uninstallMenuBar({ dryRun }).join("\n"));
+            return;
+        }
+        if (command === "menubar" && subcommand === "toggle-compact") {
+            const isCompact = toggleCompactMode();
+            console.log(isCompact ? "Compact" : "Expanded");
+            return;
+        }
+        if (command === "ingest" && subcommand === "claude-statusline") {
+            const input = await readStdin();
+            const parsed = JSON.parse(input);
+            const usage = usageFromClaudeStatusLine(parsed);
+            saveUsage(usage);
+            return;
+        }
+        if (command === "daemon") {
+            console.log((await runDaemonOnce({ dryRun })).join("\n"));
+            return;
+        }
+        throw new Error(`Unknown command: ${args.join(" ")}`);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}
+await main();

package/dist/codex.d.ts

@@ -0,0 +1,6 @@
+import { ProviderUsage } from "./types.js";
+export declare function usageFromCodexRateLimits(rateLimits: unknown, options: {
+    observedAt?: string;
+    source: string;
+}): ProviderUsage | null;
+export declare function collectCodexUsage(codexHome?: string): ProviderUsage;

package/dist/codex.js

@@ -0,0 +1,128 @@
+import fs from "node:fs";
+import path from "node:path";
+import { isDir } from "./fs-util.js";
+import { normalizeWindow } from "./usage.js";
+function walkJsonlFiles(dir, result = []) {
+    if (!isDir(dir)) {
+        return result;
+    }
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === "node_modules" || entry.name === ".git") {
+                continue;
+            }
+            walkJsonlFiles(fullPath, result);
+        }
+        else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+            result.push({ file: fullPath, mtimeMs: fs.statSync(fullPath).mtimeMs });
+        }
+    }
+    return result;
+}
+function codexSessionRoots(codexHome) {
+    return ["sessions", "archived_sessions"]
+        .map((name) => path.join(codexHome, name))
+        .filter(isDir);
+}
+function parseObservedMs(raw, fallbackMs) {
+    if (typeof raw === "string") {
+        const parsed = Date.parse(raw);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    if (typeof raw === "number" && Number.isFinite(raw)) {
+        return raw > 10_000_000_000 ? raw : raw * 1000;
+    }
+    return fallbackMs;
+}
+export function usageFromCodexRateLimits(rateLimits, options) {
+    if (rateLimits === null || typeof rateLimits !== "object") {
+        return null;
+    }
+    const record = rateLimits;
+    if (typeof record.limit_name === "string") {
+        return null;
+    }
+    const windows = [record.primary, record.secondary]
+        .map((raw) => {
+        if (raw === null || typeof raw !== "object") {
+            return null;
+        }
+        const rawRecord = raw;
+        const rawWindowMinutes = rawRecord.window_minutes ?? rawRecord.windowMinutes;
+        const windowMinutes = typeof rawWindowMinutes === "number"
+            ? rawWindowMinutes
+            : typeof rawWindowMinutes === "string" && rawWindowMinutes.trim() !== ""
+                ? Number(rawWindowMinutes)
+                : null;
+        const name = windowMinutes === 300 ? "five_hour" : windowMinutes === 10080 ? "seven_day" : null;
+        return name ? normalizeWindow(name, raw, name === "five_hour" ? 300 : 10080) : null;
+    })
+        .filter((window) => window !== null);
+    if (windows.length === 0) {
+        return null;
+    }
+    return {
+        provider: "codex",
+        source: options.source,
+        observedAt: options.observedAt ?? new Date().toISOString(),
+        planType: typeof record.plan_type === "string" ? record.plan_type : null,
+        windows,
+    };
+}
+function latestCandidateFromFile(file) {
+    const stat = fs.statSync(file);
+    const lines = fs.readFileSync(file, "utf8").split(/\r?\n/);
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        const line = lines[i]?.trim();
+        if (!line || !line.includes("rate_limits")) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(line);
+            const payload = parsed.payload;
+            const rateLimits = payload?.rate_limits ?? parsed.rate_limits;
+            const observedMs = parseObservedMs(parsed.timestamp ?? parsed.ts, stat.mtimeMs);
+            const usage = usageFromCodexRateLimits(rateLimits, {
+                source: file,
+                observedAt: new Date(observedMs).toISOString(),
+            });
+            if (usage) {
+                return { usage, observedMs };
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+export function collectCodexUsage(codexHome = path.join(process.env.HOME ?? "", ".codex")) {
+    if (!isDir(codexHome)) {
+        throw new Error(`Codex usage unavailable: ${codexHome} does not exist`);
+    }
+    const files = codexSessionRoots(codexHome)
+        .flatMap((root) => walkJsonlFiles(root))
+        .sort((left, right) => right.mtimeMs - left.mtimeMs);
+    let latest = null;
+    for (const { file, mtimeMs } of files) {
+        if (latest && mtimeMs < latest.observedMs) {
+            break;
+        }
+        try {
+            const candidate = latestCandidateFromFile(file);
+            if (candidate && (!latest || candidate.observedMs > latest.observedMs)) {
+                latest = candidate;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    if (!latest) {
+        throw new Error("Codex usage unavailable: no local session JSONL entry with payload.rate_limits was found. Run Codex CLI/App once and try again.");
+    }
+    return latest.usage;
+}

package/dist/config.d.ts

@@ -0,0 +1,4 @@
+import { BurnConfig, RuntimePaths } from "./types.js";
+export declare function defaultConfig(): BurnConfig;
+export declare function readConfig(paths?: RuntimePaths): BurnConfig;
+export declare function ensureConfig(paths?: RuntimePaths): boolean;

package/dist/config.js

@@ -0,0 +1,64 @@
+import { readJsonFile, writeJsonAtomic } from "./fs-util.js";
+import { buildPaths } from "./paths.js";
+const DEFAULT_PROVIDERS = ["codex", "claude", "glm", "deepseek", "minimax"];
+const PROVIDERS = new Set(["codex", "claude", "glm", "deepseek", "minimax"]);
+function normalizeProviders(value) {
+    if (!Array.isArray(value)) {
+        return DEFAULT_PROVIDERS;
+    }
+    const providers = value.filter((item) => {
+        return typeof item === "string" && PROVIDERS.has(item);
+    });
+    return providers.length > 0 ? [...new Set(providers)] : DEFAULT_PROVIDERS;
+}
+function envProviders() {
+    const raw = process.env.CODING_USAGE_BAR_PROVIDERS;
+    if (!raw) {
+        return null;
+    }
+    return normalizeProviders(raw.split(",").map((item) => item.trim()));
+}
+export function defaultConfig() {
+    return {
+        providers: DEFAULT_PROVIDERS,
+        glm: { baseUrl: "https://open.bigmodel.cn", apiKey: "" },
+        deepseek: { apiKey: "" },
+        minimax: { region: "cn", apiKey: "" },
+    };
+}
+export function readConfig(paths = buildPaths()) {
+    const fromEnv = envProviders();
+    if (fromEnv) {
+        return { providers: fromEnv };
+    }
+    const fileConfig = readJsonFile(paths.configFile);
+    if (!fileConfig) {
+        return defaultConfig();
+    }
+    return {
+        providers: normalizeProviders(fileConfig.providers),
+        glm: fileConfig.glm ?? defaultConfig().glm,
+        deepseek: fileConfig.deepseek ?? defaultConfig().deepseek,
+        minimax: fileConfig.minimax ?? defaultConfig().minimax,
+    };
+}
+export function ensureConfig(paths = buildPaths()) {
+    const existing = readJsonFile(paths.configFile);
+    if (!existing) {
+        writeJsonAtomic(paths.configFile, defaultConfig());
+        return true;
+    }
+    if (!existing.glm) {
+        writeJsonAtomic(paths.configFile, { ...existing, glm: defaultConfig().glm });
+        return true;
+    }
+    if (!existing.deepseek) {
+        const current = readJsonFile(paths.configFile) ?? existing;
+        writeJsonAtomic(paths.configFile, { ...current, deepseek: defaultConfig().deepseek });
+    }
+    const latest = readJsonFile(paths.configFile) ?? existing;
+    if (!latest.minimax) {
+        writeJsonAtomic(paths.configFile, { ...latest, minimax: defaultConfig().minimax });
+    }
+    return false;
+}

package/dist/daemon.d.ts

@@ -0,0 +1,3 @@
+export declare function runDaemonOnce(options?: {
+    dryRun?: boolean;
+}): Promise<string[]>;

package/dist/daemon.js

@@ -0,0 +1,16 @@
+import { collectStatusSnapshot } from "./runtime.js";
+import { markNotified, sendNotification, shouldNotify } from "./notifier.js";
+export async function runDaemonOnce(options = {}) {
+    const snapshot = await collectStatusSnapshot();
+    const messages = [];
+    for (const { analysis } of snapshot.providers) {
+        if (!shouldNotify(analysis)) {
+            continue;
+        }
+        messages.push(sendNotification(analysis, options.dryRun));
+        if (!options.dryRun) {
+            markNotified(analysis);
+        }
+    }
+    return messages.length ? messages : ["No notification needed."];
+}

package/dist/deepseek.d.ts

@@ -0,0 +1,18 @@
+import { DeepseekConfig, ProviderUsage } from "./types.js";
+interface DeepseekBalanceInfo {
+    currency: string;
+    total_balance: string;
+    granted_balance: string;
+    topped_up_balance: string;
+}
+interface DeepseekBalanceResponse {
+    is_available: boolean;
+    balance_infos: DeepseekBalanceInfo[];
+}
+export declare function fetchDeepseekBalance(config: DeepseekConfig): Promise<DeepseekBalanceResponse>;
+export declare function usageFromDeepseekBalance(balance: DeepseekBalanceResponse, options: {
+    observedAt?: string;
+    source: string;
+}): ProviderUsage | null;
+export declare function collectDeepseekUsage(config: DeepseekConfig): Promise<ProviderUsage>;
+export {};

package/dist/deepseek.js

@@ -0,0 +1,47 @@
+const DEFAULT_BASE_URL = "https://api.deepseek.com";
+export async function fetchDeepseekBalance(config) {
+    const url = `${DEFAULT_BASE_URL}/user/balance`;
+    const response = await fetch(url, {
+        method: "GET",
+        headers: {
+            "Authorization": `Bearer ${config.apiKey}`,
+            "Content-Type": "application/json",
+        },
+        signal: AbortSignal.timeout(15_000),
+    });
+    if (!response.ok) {
+        throw new Error(`DeepSeek balance API returned HTTP ${response.status}`);
+    }
+    return (await response.json());
+}
+export function usageFromDeepseekBalance(balance, options) {
+    const info = balance.balance_infos?.[0];
+    if (!info) {
+        return null;
+    }
+    return {
+        provider: "deepseek",
+        source: options.source,
+        observedAt: options.observedAt ?? new Date().toISOString(),
+        planType: null,
+        windows: [],
+        balance: {
+            total: info.total_balance,
+            currency: info.currency,
+            isAvailable: balance.is_available,
+        },
+    };
+}
+export async function collectDeepseekUsage(config) {
+    if (!config.apiKey) {
+        throw new Error("DeepSeek API key not configured. Edit ~/.coding-usage-bar/config.json to set deepseek.apiKey.");
+    }
+    const balance = await fetchDeepseekBalance(config);
+    const usage = usageFromDeepseekBalance(balance, {
+        source: `${DEFAULT_BASE_URL}/user/balance`,
+    });
+    if (!usage) {
+        throw new Error("DeepSeek balance response did not contain expected data");
+    }
+    return usage;
+}

package/dist/doctor.d.ts

@@ -0,0 +1,6 @@
+import { DoctorCheck } from "./types.js";
+export declare function runDoctor(options?: {
+    dryRun?: boolean;
+}): DoctorCheck[];
+export declare function formatDoctor(checks: DoctorCheck[]): string;
+export declare function doctorHasFailures(checks: DoctorCheck[]): boolean;