coding-usage-bar 0.1.0

package/dist/doctor.js

@@ -0,0 +1,225 @@
+import fs from "node:fs";
+import path from "node:path";
+import { readConfig } from "./config.js";
+import { collectCodexUsage } from "./codex.js";
+import { claudeStatusLineHasIngest, getClaudeStatusLineCommand, readClaudeSettings } from "./claude.js";
+import { isDir, isFile } from "./fs-util.js";
+import { buildPaths, providerLatestPath } from "./paths.js";
+import { notificationBackend } from "./notifier.js";
+import { isSwiftBarInstalled, swiftBarPluginPath } from "./menubar.js";
+function stableClaudeIngestHint() {
+    const paths = buildPaths();
+    return `printf "%s" "$input" | node "${paths.stateDir}/app/dist/cli.js" ingest claude-statusline >/dev/null`;
+}
+function pathEntries() {
+    return (process.env.PATH ?? "").split(path.delimiter).filter(Boolean);
+}
+function isManagedCliShim() {
+    const paths = buildPaths();
+    try {
+        return fs.lstatSync(paths.cliBinFile).isSymbolicLink()
+            && path.resolve(path.dirname(paths.cliBinFile), fs.readlinkSync(paths.cliBinFile))
+                === path.join(paths.stateDir, "app", "dist", "cli.js");
+    }
+    catch {
+        return false;
+    }
+}
+export function runDoctor(options = {}) {
+    const paths = buildPaths();
+    const config = readConfig(paths);
+    const monitored = new Set(config.providers);
+    const checks = [];
+    checks.push({
+        name: "Runtime directory",
+        ok: options.dryRun ? true : isDir(paths.stateDir),
+        message: options.dryRun ? `[dry-run] would use ${paths.stateDir}` : paths.stateDir,
+    });
+    const cliBinInPath = pathEntries().includes(paths.cliBinDir);
+    checks.push({
+        name: "CLI command",
+        ok: options.dryRun ? true : isManagedCliShim() && cliBinInPath,
+        message: options.dryRun
+            ? `[dry-run] would link ${paths.cliBinFile}`
+            : cliBinInPath
+                ? `${paths.cliBinFile}`
+                : `${paths.cliBinFile}; add ${paths.cliBinDir} to PATH to use coding-usage-bar directly`,
+    });
+    checks.push({
+        name: "Configured providers",
+        ok: true,
+        message: `${config.providers.join(", ")} (${paths.configFile})`,
+    });
+    if (monitored.has("codex")) {
+        try {
+            const usage = collectCodexUsage(path.join(paths.homeDir, ".codex"));
+            checks.push({
+                name: "Codex usage",
+                ok: true,
+                message: `latest rate_limits observed at ${usage.observedAt}`,
+            });
+        }
+        catch (error) {
+            checks.push({
+                name: "Codex usage",
+                ok: false,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    else {
+        checks.push({
+            name: "Codex usage",
+            ok: true,
+            message: "disabled by config",
+        });
+    }
+    const claudeLatest = providerLatestPath(paths, "claude");
+    if (monitored.has("claude")) {
+        checks.push({
+            name: "Claude usage cache",
+            ok: isFile(claudeLatest),
+            message: isFile(claudeLatest)
+                ? `found ${claudeLatest}`
+                : `missing ${claudeLatest}; add Claude status line ingest, e.g. ${stableClaudeIngestHint()}`,
+        });
+        const settings = readClaudeSettings(paths.claudeSettingsFile);
+        const command = getClaudeStatusLineCommand(settings);
+        checks.push({
+            name: "Claude status line",
+            ok: claudeStatusLineHasIngest(command, {
+                appCliPath: path.join(paths.stateDir, "app", "dist", "cli.js"),
+                managedScriptPath: paths.claudeStatusLineScript,
+            }),
+            message: command
+                ? `configured: ${command}`
+                : "not configured; coding-usage-bar install can create a minimal collector if no status line exists",
+        });
+    }
+    else {
+        checks.push({
+            name: "Claude usage cache",
+            ok: true,
+            message: "disabled by config",
+        });
+    }
+    if (monitored.has("glm")) {
+        const hasApiKey = Boolean(config.glm?.apiKey);
+        checks.push({
+            name: "GLM API key",
+            ok: hasApiKey,
+            message: hasApiKey
+                ? "configured"
+                : "not set; edit ~/.coding-usage-bar/config.json to set glm.apiKey",
+        });
+        const glmLatest = providerLatestPath(paths, "glm");
+        checks.push({
+            name: "GLM usage cache",
+            ok: !hasApiKey || isFile(glmLatest),
+            message: isFile(glmLatest)
+                ? `found ${glmLatest}`
+                : hasApiKey
+                    ? `missing ${glmLatest}; run coding-usage-bar daemon --once to collect`
+                    : "skipped (API key not set)",
+        });
+    }
+    else {
+        checks.push({
+            name: "GLM",
+            ok: true,
+            message: "disabled by config",
+        });
+    }
+    if (monitored.has("deepseek")) {
+        const hasApiKey = Boolean(config.deepseek?.apiKey);
+        checks.push({
+            name: "DeepSeek API key",
+            ok: hasApiKey,
+            message: hasApiKey
+                ? "configured"
+                : "not set; edit ~/.coding-usage-bar/config.json to set deepseek.apiKey",
+        });
+        const deepseekLatest = providerLatestPath(paths, "deepseek");
+        checks.push({
+            name: "DeepSeek balance cache",
+            ok: !hasApiKey || isFile(deepseekLatest),
+            message: isFile(deepseekLatest)
+                ? `found ${deepseekLatest}`
+                : hasApiKey
+                    ? `missing ${deepseekLatest}; run coding-usage-bar daemon --once to collect`
+                    : "skipped (API key not set)",
+        });
+    }
+    else {
+        checks.push({
+            name: "DeepSeek",
+            ok: true,
+            message: "disabled by config",
+        });
+    }
+    if (monitored.has("minimax")) {
+        const hasApiKey = Boolean(config.minimax?.apiKey);
+        checks.push({
+            name: "MiniMax API key",
+            ok: hasApiKey,
+            message: hasApiKey
+                ? `configured (region: ${config.minimax?.region ?? "cn"})`
+                : "not set; edit ~/.coding-usage-bar/config.json to set minimax.apiKey",
+        });
+        const minimaxLatest = providerLatestPath(paths, "minimax");
+        checks.push({
+            name: "MiniMax usage cache",
+            ok: !hasApiKey || isFile(minimaxLatest),
+            message: isFile(minimaxLatest)
+                ? `found ${minimaxLatest}`
+                : hasApiKey
+                    ? `missing ${minimaxLatest}; run coding-usage-bar daemon --once to collect`
+                    : "skipped (API key not set)",
+        });
+    }
+    else {
+        checks.push({
+            name: "MiniMax",
+            ok: true,
+            message: "disabled by config",
+        });
+    }
+    const backend = notificationBackend();
+    const notificationOk = backend !== "unsupported" && backend !== "burnt-toast";
+    checks.push({
+        name: "Notification",
+        ok: notificationOk,
+        message: backend === "burnt-toast"
+            ? "Windows design target: install PowerShell module BurntToast with Install-Module BurntToast -Scope CurrentUser"
+            : `backend=${backend}`,
+    });
+    checks.push({
+        name: "Daemon",
+        ok: process.platform === "darwin" ? fs.existsSync(paths.launchAgentFile) || Boolean(options.dryRun) : false,
+        message: process.platform === "darwin"
+            ? options.dryRun
+                ? `[dry-run] would use ${paths.launchAgentFile}`
+                : paths.launchAgentFile
+            : "daemon install is only implemented for macOS launchd in v1",
+    });
+    const swiftBarInstalled = isSwiftBarInstalled();
+    const swiftBarPlugin = swiftBarPluginPath(paths);
+    checks.push({
+        name: "Menu bar",
+        ok: swiftBarInstalled && isFile(swiftBarPlugin.file),
+        message: swiftBarInstalled
+            ? isFile(swiftBarPlugin.file)
+                ? `SwiftBar plugin installed: ${swiftBarPlugin.file}`
+                : `SwiftBar found; run coding-usage-bar menubar install`
+            : "SwiftBar not found; install SwiftBar, then run coding-usage-bar menubar install",
+    });
+    return checks;
+}
+export function formatDoctor(checks) {
+    return checks
+        .map((check) => `${check.ok ? "OK" : "MISSING"}  ${check.name}: ${check.message}`)
+        .join("\n");
+}
+export function doctorHasFailures(checks) {
+    return checks.some((check) => !check.ok);
+}

package/dist/format.d.ts

@@ -0,0 +1,9 @@
+import { BurnAnalysis, StatusIssue, ProviderUsage, UsageWindow, StatusSnapshot } from "./types.js";
+export declare function formatDurationUntil(iso: string, now?: Date): string;
+export declare function formatProviderLabel(provider: string): "Claude" | "GLM" | "DeepSeek" | "MiniMax" | "Codex";
+export declare function formatWindowLabel(window: UsageWindow): "5h" | "7d";
+export declare function usageBar(usedPercent: number, width?: number): string;
+export declare function formatStatusRows(usages: ProviderUsage[], analyses: BurnAnalysis[]): string;
+export declare function formatAnalysisDetail(analysis: BurnAnalysis): string;
+export declare function formatIssues(issues: StatusIssue[]): string;
+export declare function formatProviderMeta(snapshot: StatusSnapshot): string;

package/dist/format.js

@@ -0,0 +1,92 @@
+export function formatDurationUntil(iso, now = new Date()) {
+    const minutes = Math.max(0, Math.round((Date.parse(iso) - now.getTime()) / 60_000));
+    const days = Math.floor(minutes / 1440);
+    const hours = Math.floor((minutes % 1440) / 60);
+    const mins = minutes % 60;
+    if (days > 0) {
+        return `${days}d ${hours}h`;
+    }
+    if (hours > 0) {
+        return `${hours}h ${mins}m`;
+    }
+    return `${mins}m`;
+}
+function windowLabel(window) {
+    return window.name === "five_hour" ? "5h" : "7d";
+}
+function providerLabel(provider) {
+    if (provider === "claude")
+        return "Claude";
+    if (provider === "glm")
+        return "GLM";
+    if (provider === "deepseek")
+        return "DeepSeek";
+    if (provider === "minimax")
+        return "MiniMax";
+    return "Codex";
+}
+export function formatProviderLabel(provider) {
+    return providerLabel(provider);
+}
+export function formatWindowLabel(window) {
+    return windowLabel(window);
+}
+export function usageBar(usedPercent, width = 12) {
+    const usedCells = Math.max(0, Math.min(width, Math.round((usedPercent / 100) * width)));
+    return `[${"#".repeat(usedCells)}${"-".repeat(width - usedCells)}] ${Math.round(usedPercent)}%`;
+}
+export function formatStatusRows(usages, analyses) {
+    const rows = ["Provider  Period  Usage              Reset     State"];
+    for (const usage of usages) {
+        const analysis = analyses.find((item) => item.provider === usage.provider);
+        if (usage.balance && usage.windows.length === 0) {
+            const currency = usage.balance.currency === "CNY" ? "¥" : "$";
+            rows.push([
+                providerLabel(usage.provider).padEnd(8),
+                "balance".padEnd(8),
+                `${currency}${usage.balance.total}`.padEnd(19),
+                "".padEnd(10),
+                analysis?.state ?? "RAW",
+            ].join(""));
+            continue;
+        }
+        for (const window of usage.windows) {
+            rows.push([
+                providerLabel(usage.provider).padEnd(8),
+                windowLabel(window).padEnd(8),
+                usageBar(window.usedPercent).padEnd(19),
+                formatDurationUntil(window.resetsAt).padEnd(10),
+                analysis?.state ?? "RAW",
+            ].join(""));
+        }
+    }
+    return rows.join("\n");
+}
+export function formatAnalysisDetail(analysis) {
+    if (!analysis.target) {
+        return analysis.message;
+    }
+    return `${analysis.message} k=${analysis.target.conversionRate.toFixed(3)}, recommended=${analysis.target.recommendedPercent.toFixed(1)}%.`;
+}
+export function formatIssues(issues) {
+    if (issues.length === 0) {
+        return "";
+    }
+    return issues
+        .map((issue) => {
+        const provider = issue.provider ? `${providerLabel(issue.provider)} ` : "";
+        return `${issue.severity.toUpperCase()} ${provider}${issue.code}: ${issue.message}`;
+    })
+        .join("\n");
+}
+export function formatProviderMeta(snapshot) {
+    if (snapshot.providers.length === 0) {
+        return "";
+    }
+    return snapshot.providers
+        .map(({ usage, meta }) => {
+        const stale = meta.stale ? "stale" : "fresh";
+        return `${providerLabel(usage.provider)} source=${meta.source} age=${meta.ageSeconds}s ${stale}`;
+    })
+        .join("\n");
+}

package/dist/fs-util.d.ts

@@ -0,0 +1,6 @@
+export declare function ensureDir(dir: string): void;
+export declare function readJsonFile<T>(file: string): T | null;
+export declare function writeJsonAtomic(file: string, value: unknown): void;
+export declare function appendJsonLine(file: string, value: unknown): void;
+export declare function isFile(file: string): boolean;
+export declare function isDir(dir: string): boolean;

package/dist/fs-util.js

@@ -0,0 +1,39 @@
+import fs from "node:fs";
+import path from "node:path";
+export function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+export function readJsonFile(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function writeJsonAtomic(file, value) {
+    ensureDir(path.dirname(file));
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    fs.renameSync(tmp, file);
+}
+export function appendJsonLine(file, value) {
+    ensureDir(path.dirname(file));
+    fs.appendFileSync(file, `${JSON.stringify(value)}\n`, "utf8");
+}
+export function isFile(file) {
+    try {
+        return fs.statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export function isDir(dir) {
+    try {
+        return fs.statSync(dir).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/glm.d.ts

@@ -0,0 +1,22 @@
+import { GlmConfig, ProviderUsage } from "./types.js";
+interface GlmLimit {
+    type: string;
+    unit?: number;
+    number?: number;
+    percentage: number;
+    nextResetTime: number;
+}
+interface GlmQuotaResponse {
+    success: boolean;
+    data?: {
+        limits: GlmLimit[];
+        level: string;
+    };
+}
+export declare function fetchGlmQuota(config: GlmConfig): Promise<GlmQuotaResponse>;
+export declare function usageFromGlmQuota(quota: GlmQuotaResponse, options: {
+    observedAt?: string;
+    source: string;
+}): ProviderUsage | null;
+export declare function collectGlmUsage(config: GlmConfig): Promise<ProviderUsage>;
+export {};

package/dist/glm.js

@@ -0,0 +1,62 @@
+import { makeProviderUsage, normalizeWindow } from "./usage.js";
+const DEFAULT_BASE_URL = "https://open.bigmodel.cn";
+export async function fetchGlmQuota(config) {
+    const baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+    const url = `${baseUrl}/api/monitor/usage/quota/limit`;
+    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(`GLM quota API returned HTTP ${response.status}`);
+    }
+    return (await response.json());
+}
+export function usageFromGlmQuota(quota, options) {
+    if (!quota.success || !quota.data) {
+        return null;
+    }
+    const tokenLimits = quota.data.limits.filter((limit) => limit.type === "TOKENS_LIMIT");
+    if (tokenLimits.length < 2) {
+        return null;
+    }
+    const sortedByReset = [...tokenLimits].sort((a, b) => a.nextResetTime - b.nextResetTime);
+    const fiveHourRaw = sortedByReset[0];
+    const sevenDayRaw = sortedByReset[1];
+    const fiveHour = normalizeWindow("five_hour", {
+        used_percent: fiveHourRaw.percentage,
+        resets_at: new Date(fiveHourRaw.nextResetTime).toISOString(),
+    }, 300);
+    const sevenDay = normalizeWindow("seven_day", {
+        used_percent: sevenDayRaw.percentage,
+        resets_at: new Date(sevenDayRaw.nextResetTime).toISOString(),
+    }, 10080);
+    if (!fiveHour || !sevenDay) {
+        return null;
+    }
+    return makeProviderUsage({
+        provider: "glm",
+        source: options.source,
+        observedAt: options.observedAt,
+        planType: quota.data.level ?? null,
+        fiveHour,
+        sevenDay,
+    });
+}
+export async function collectGlmUsage(config) {
+    if (!config.apiKey) {
+        throw new Error("GLM API key not configured. Edit ~/.coding-usage-bar/config.json to set glm.apiKey.");
+    }
+    const quota = await fetchGlmQuota(config);
+    const usage = usageFromGlmQuota(quota, {
+        source: `${config.baseUrl || DEFAULT_BASE_URL}/api/monitor/usage/quota/limit`,
+    });
+    if (!usage) {
+        throw new Error("GLM quota response did not contain expected token limit data");
+    }
+    return usage;
+}

package/dist/install.d.ts

@@ -0,0 +1,25 @@
+import { RuntimePaths } from "./types.js";
+export declare const LAUNCHD_LABEL = "com.duying.coding-usage-bar";
+interface StatusLineUpdateContext {
+    existingCommand: string;
+    wrapperScript: string;
+    originalCommandFile: string;
+    stableIngestCommand: string;
+}
+interface ClaudeStatusLineInstallOptions {
+    dryRun: boolean;
+    confirmStatusLineUpdate?: (context: StatusLineUpdateContext) => boolean;
+}
+export declare function isSameDirectory(left: string, right: string): boolean;
+type LaunchctlRunner = (file: string, args: string[], options?: {
+    stdio?: "ignore";
+}) => unknown;
+export declare function stopLaunchAgent(plistFile: string, run?: LaunchctlRunner): void;
+export declare function installClaudeStatusLine(paths: RuntimePaths, options: ClaudeStatusLineInstallOptions): string[];
+export declare function install(options?: {
+    dryRun?: boolean;
+}): string[];
+export declare function uninstall(options?: {
+    dryRun?: boolean;
+}): string[];
+export {};