@howaboua/opencode-usage-plugin 0.1.4-dev.0 → 0.1.4-dev.1

package/dist/ui/formatters/copilot.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Formats GitHub Copilot usage snapshots.
+ * Handles chat and completion quotas with progress bars and reset times.
+ */
+import type { UsageSnapshot } from "../../types";
+export declare function formatCopilotSnapshot(snapshot: UsageSnapshot): string[];
+//# sourceMappingURL=copilot.d.ts.map

package/dist/ui/formatters/copilot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copilot.d.ts","sourceRoot":"","sources":["../../../src/ui/formatters/copilot.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAGhD,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,EAAE,CAkBvE"}

package/dist/ui/formatters/copilot.js

@@ -0,0 +1,21 @@
+/**
+ * Formats GitHub Copilot usage snapshots.
+ * Handles chat and completion quotas with progress bars and reset times.
+ */
+import { formatBar, formatResetSuffixISO, formatMissingSnapshot } from "./shared";
+export function formatCopilotSnapshot(snapshot) {
+    const copilot = snapshot.copilotQuota;
+    if (!copilot)
+        return formatMissingSnapshot(snapshot);
+    const lines = ["→ [GITHUB] Copilot"];
+    const reset = copilot.resetTime ? formatResetSuffixISO(copilot.resetTime) : "";
+    const total = copilot.total === -1 ? "∞" : copilot.total.toString();
+    lines.push(`  ${"Chat:".padEnd(13)} ${formatBar(copilot.percentRemaining)} ${copilot.used}/${total}${reset}`);
+    if (copilot.completionsUsed !== undefined && copilot.completionsTotal !== undefined) {
+        const pct = copilot.completionsTotal > 0
+            ? Math.round((copilot.completionsUsed / copilot.completionsTotal) * 100)
+            : 0;
+        lines.push(`  ${"Completions:".padEnd(13)} ${formatBar(pct)} ${copilot.completionsUsed}/${copilot.completionsTotal}`);
+    }
+    return lines;
+}

package/dist/ui/formatters/proxy.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Formats Mirrowel Proxy usage snapshots.
+ * Handles multi-provider and multi-tier quota reporting with progress bars.
+ */
+import type { UsageSnapshot } from "../../types";
+export declare function formatProxySnapshot(snapshot: UsageSnapshot): string[];
+//# sourceMappingURL=proxy.d.ts.map

package/dist/ui/formatters/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../../src/ui/formatters/proxy.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAGhD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,EAAE,CAcrE"}

package/dist/ui/formatters/proxy.js

@@ -0,0 +1,31 @@
+/**
+ * Formats Mirrowel Proxy usage snapshots.
+ * Handles multi-provider and multi-tier quota reporting with progress bars.
+ */
+import { formatBar, formatResetSuffixISO, formatMissingSnapshot } from "./shared";
+export function formatProxySnapshot(snapshot) {
+    const proxy = snapshot.proxyQuota;
+    if (!proxy?.providers?.length)
+        return formatMissingSnapshot(snapshot);
+    const lines = ["→ [Google] Mirrowel Proxy"];
+    for (const provider of proxy.providers) {
+        const providerLines = formatProxyProvider(provider);
+        if (providerLines.length) {
+            lines.push("", `  ${provider.name}:`, ...providerLines);
+        }
+    }
+    return lines;
+}
+function formatProxyProvider(provider) {
+    const lines = [];
+    for (const tier of provider.tiers) {
+        if (!tier.quotaGroups?.length)
+            continue;
+        lines.push(`    ${tier.tier === "paid" ? "Paid" : "Free"}:`);
+        for (const group of tier.quotaGroups) {
+            const reset = group.resetTime ? formatResetSuffixISO(group.resetTime) : "";
+            lines.push(`      ${group.name.padEnd(9)} ${formatBar(group.remainingPct)} ${group.remaining}/${group.max}${reset}`);
+        }
+    }
+    return lines;
+}

package/dist/ui/formatters/shared.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Formats various usage snapshots (Proxy, Copilot, Codex) into human-readable text.
+ * Provides specialized formatting for progress bars, reset times, and missing data states.
+ */
+import type { UsageSnapshot } from "../../types";
+export declare function formatBar(pct: number): string;
+export declare function formatResetSuffix(resetAt: number | null): string;
+export declare function formatResetSuffixISO(iso: string): string;
+export declare function formatMissingSnapshot(snapshot: UsageSnapshot): string[];
+//# sourceMappingURL=shared.d.ts.map

package/dist/ui/formatters/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/ui/formatters/shared.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAK7C;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAGhE;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKxD;AAWD,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,EAAE,CAgBvE"}

package/dist/ui/formatters/shared.js

@@ -0,0 +1,63 @@
+/**
+ * Formats various usage snapshots (Proxy, Copilot, Codex) into human-readable text.
+ * Provides specialized formatting for progress bars, reset times, and missing data states.
+ */
+import { platform, homedir } from "os";
+import { join } from "path";
+export function formatBar(pct) {
+    const clamped = Math.max(0, Math.min(100, pct));
+    const size = 15;
+    const filled = Math.round((clamped / 100) * size);
+    return `${"█".repeat(filled)}${"░".repeat(size - filled)}`;
+}
+export function formatResetSuffix(resetAt) {
+    if (!resetAt)
+        return "";
+    return ` (resets in ${formatTimeDelta(resetAt)})`;
+}
+export function formatResetSuffixISO(iso) {
+    try {
+        const at = Math.floor(new Date(iso).getTime() / 1000);
+        return ` (resets in ${formatTimeDelta(at)})`;
+    }
+    catch {
+        return "";
+    }
+}
+function formatTimeDelta(at) {
+    const diff = at - Math.floor(Date.now() / 1000);
+    if (diff <= 0)
+        return "now";
+    if (diff < 60)
+        return `${diff}s`;
+    if (diff < 3600)
+        return `${Math.ceil(diff / 60)}m`;
+    if (diff < 84400)
+        return `${Math.round(diff / 3600)}h`;
+    return `${Math.round(diff / 86400)}d`;
+}
+export function formatMissingSnapshot(snapshot) {
+    const { provider } = snapshot;
+    const configPath = getConfigPath();
+    const instructions = {
+        codex: "if you dont have codex oauth, please set your usage-config.jsonc to openai: false",
+        proxy: "if you are not running Mirrowel's proxy, please set your usage-config.jsonc to proxy: false",
+        copilot: "if you are not running GitHub Copilot, please set your usage-config.jsonc to copilot: false"
+    };
+    const lines = [`→ [${provider.toUpperCase()}] - ${instructions[provider] || ""}`];
+    if (snapshot.missingReason)
+        lines.push("", `Reason: ${snapshot.missingReason}`);
+    if (snapshot.missingDetails?.length) {
+        lines.push("", "Details:", ...snapshot.missingDetails.map((d) => `- ${d}`));
+    }
+    return [...lines, "", `File: ${configPath}`, "", "Issue? https://github.com/IgorWarzocha/opencode-usage-plugin/issues"];
+}
+function getConfigPath() {
+    const home = homedir();
+    const plat = platform();
+    if (plat === "darwin")
+        return join(home, ".config", "opencode", "usage-config.jsonc");
+    if (plat === "win32")
+        return join(process.env.APPDATA || join(home, "AppData", "Roaming"), "opencode", "usage-config.jsonc");
+    return join(process.env.XDG_CONFIG_HOME || join(home, ".config"), "opencode", "usage-config.jsonc");
+}

package/dist/ui/status.d.ts

@@ -1,5 +1,6 @@
 /**
  * Renders usage snapshots into readable status text.
+ * Dispatches to specialized formatters and manages session messaging.
  */
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { UsageSnapshot } from "../types";

package/dist/ui/status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/ui/status.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAGtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAC7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,KAAK,WAAW,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAA;AAExC,wBAAsB,iBAAiB,CAAC,OAAO,EAAE;IAC/C,MAAM,EAAE,WAAW,CAAA;IACnB,KAAK,EAAE,UAAU,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;CACb,GAAG,OAAO,CAAC,IAAI,CAAC,CAqChB;AAkMD,wBAAsB,iBAAiB,CAAC,OAAO,EAAE;IAC/C,MAAM,EAAE,WAAW,CAAA;IACnB,KAAK,EAAE,UAAU,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,aAAa,EAAE,CAAA;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6BhB"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/ui/status.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAC7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAK1C,KAAK,WAAW,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAA;AAExC,wBAAsB,iBAAiB,CAAC,OAAO,EAAE;IAC/C,MAAM,EAAE,WAAW,CAAA;IACnB,KAAK,EAAE,UAAU,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;CACb,GAAG,OAAO,CAAC,IAAI,CAAC,CAmBhB;AAiCD,wBAAsB,iBAAiB,CAAC,OAAO,EAAE;IAC/C,MAAM,EAAE,WAAW,CAAA;IACnB,KAAK,EAAE,UAAU,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,aAAa,EAAE,CAAA;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAAC,IAAI,CAAC,CAahB"}

package/dist/ui/status.js

@@ -1,231 +1,68 @@
 /**
  * Renders usage snapshots into readable status text.
+ * Dispatches to specialized formatters and manages session messaging.
  */
-import { platform, homedir } from "os";
-import { join } from "path";
+import { formatProxySnapshot } from "./formatters/proxy";
+import { formatCopilotSnapshot } from "./formatters/copilot";
+import { formatBar, formatResetSuffix, formatMissingSnapshot } from "./formatters/shared";
 export async function sendStatusMessage(options) {
-    // @ts-ignore
     const bus = options.client.bus;
     if (bus) {
         try {
             await bus.publish({
                 topic: "companion.projection",
-                body: {
-                    key: "usage",
-                    kind: "markdown",
-                    content: options.text,
-                },
+                body: { key: "usage", kind: "markdown", content: options.text },
             });
         }
         catch { }
     }
-    await options.client.session
-        .prompt({
+    await options.client.session.prompt({
         path: { id: options.sessionID },
-        body: {
-            noReply: true,
-            parts: [
-                {
-                    type: "text",
-                    text: options.text,
-                    ignored: true,
-                },
-            ],
-        },
-    })
-        .catch(async () => {
-        await options.client.tui
-            .showToast({
+        body: { noReply: true, parts: [{ type: "text", text: options.text, ignored: true }] },
+    }).catch(async () => {
+        await options.client.tui.showToast({
             body: { title: "Usage Status", message: options.text, variant: "info" },
-        })
-            .catch(() => { });
+        }).catch(() => { });
     });
 }
-function formatBar(remainingPercent) {
-    const clamped = Math.max(0, Math.min(100, remainingPercent));
-    const size = 15;
-    const filled = Math.round((clamped / 100) * size);
-    const empty = size - filled;
-    return `${"█".repeat(filled)}${"░".repeat(empty)}`;
-}
-function formatPlanType(planType) {
-    return planType
-        .replace(/_/g, " ")
-        .split(" ")
-        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-        .join(" ");
-}
-function formatResetTime(resetAt) {
-    const now = Math.floor(Date.now() / 1000);
-    const diff = resetAt - now;
-    if (diff <= 0)
-        return "now";
-    if (diff < 60)
-        return `${diff}s`;
-    if (diff < 3600)
-        return `${Math.ceil(diff / 60)}m`;
-    if (diff < 86400)
-        return `${Math.round(diff / 3600)}h`;
-    return `${Math.round(diff / 86400)}d`;
-}
-function formatResetSuffix(resetAt) {
-    if (!resetAt)
-        return "";
-    return ` (resets in ${formatResetTime(resetAt)})`;
-}
-function formatResetSuffixISO(isoString) {
-    try {
-        const resetAt = Math.floor(new Date(isoString).getTime() / 1000);
-        return ` (resets in ${formatResetTime(resetAt)})`;
-    }
-    catch {
-        return "";
-    }
-}
-function formatProxySnapshot(snapshot) {
-    const proxy = snapshot.proxyQuota;
-    if (!proxy || !proxy.providers || proxy.providers.length === 0)
-        return ["→ [proxy] No data"];
-    const lines = ["→ [Google] Mirrowel Proxy"];
-    for (const provider of proxy.providers) {
-        const providerLines = [];
-        for (const tierInfo of provider.tiers) {
-            if (!tierInfo.quotaGroups || tierInfo.quotaGroups.length === 0)
-                continue;
-            const tierLabel = tierInfo.tier === "paid" ? "Paid" : "Free";
-            providerLines.push(`    ${tierLabel}:`);
-            for (const group of tierInfo.quotaGroups) {
-                const resetSuffix = group.resetTime ? formatResetSuffixISO(group.resetTime) : "";
-                const label = `${group.name}:`.padEnd(9);
-                providerLines.push(`      ${label} ${formatBar(group.remainingPct)} ${group.remaining}/${group.max}${resetSuffix}`);
-            }
-        }
-        if (providerLines.length > 0) {
-            lines.push("");
-            lines.push(`  ${provider.name}:`);
-            for (const line of providerLines)
-                lines.push(line);
-        }
-    }
-    return lines;
-}
-function formatCopilotSnapshot(snapshot) {
-    const copilot = snapshot.copilotQuota;
-    if (!copilot)
-        return ["→ [copilot] No data"];
-    const lines = ["→ [GITHUB] Copilot"];
-    const resetSuffix = copilot.resetTime ? formatResetSuffixISO(copilot.resetTime) : "";
-    const totalLabel = copilot.total === -1 ? "∞" : copilot.total.toString();
-    const chatLabel = "Chat:".padEnd(13);
-    const chatRemaining = copilot.used;
-    const chatPct = copilot.percentRemaining;
-    lines.push(`  ${chatLabel} ${formatBar(chatPct)} ${chatRemaining}/${totalLabel}${resetSuffix}`);
-    if (copilot.completionsUsed !== undefined && copilot.completionsTotal !== undefined) {
-        const compLabel = "Completions:".padEnd(13);
-        const compPct = copilot.completionsTotal > 0
-            ? Math.round((copilot.completionsUsed / copilot.completionsTotal) * 100)
-            : 0;
-        lines.push(`  ${compLabel} ${formatBar(compPct)} ${copilot.completionsUsed}/${copilot.completionsTotal}`);
-    }
-    return lines;
-}
-function getAppDataPath() {
-    const home = homedir();
-    const plat = platform();
-    if (plat === "darwin")
-        return join(home, ".config", "opencode");
-    if (plat === "win32")
-        return join(process.env.APPDATA || join(home, "AppData", "Roaming"), "opencode");
-    return join(process.env.XDG_CONFIG_HOME || join(home, ".config"), "opencode");
-}
-function formatMissingSnapshot(snapshot) {
-    const provider = snapshot.provider;
-    const configPath = join(getAppDataPath(), "usage-config.jsonc");
-    let providerInstruction = "";
-    if (provider === "codex") {
-        providerInstruction = "if you dont have codex oauth, please set your usage-config.jsonc to openai: false";
-    }
-    else if (provider === "proxy") {
-        providerInstruction = "if you are not running Mirrowel's proxy, please set your usage-config.jsonc to proxy: false";
-    }
-    else if (provider === "copilot") {
-        providerInstruction = "if you are not running GitHub Copilot, please set your usage-config.jsonc to copilot: false";
-    }
-    const lines = [
-        `→ [${provider.toUpperCase()}] - ${providerInstruction}`,
-    ];
-    if (snapshot.missingReason) {
-        lines.push("", `Reason: ${snapshot.missingReason}`);
-    }
-    if (snapshot.missingDetails && snapshot.missingDetails.length > 0) {
-        lines.push("", "Details:");
-        for (const detail of snapshot.missingDetails) {
-            lines.push(`- ${detail}`);
-        }
-    }
-    lines.push("", `The file can be found in ${configPath}. Please read the comments in the file or visit the repo for the readme.`, "", "If you are seeing empty usages or errors, despite having everything set up correctly, please fire an issue at https://github.com/IgorWarzocha/opencode-usage-plugin/issues - thank you!");
-    return lines;
-}
 function formatSnapshot(snapshot) {
-    if (snapshot.isMissing) {
+    if (snapshot.isMissing)
         return formatMissingSnapshot(snapshot);
-    }
-    if (snapshot.provider === "proxy" && snapshot.proxyQuota) {
+    if (snapshot.provider === "proxy")
         return formatProxySnapshot(snapshot);
-    }
-    if (snapshot.provider === "copilot" && snapshot.copilotQuota) {
+    if (snapshot.provider === "copilot")
         return formatCopilotSnapshot(snapshot);
-    }
-    const plan = snapshot.planType ? ` (${formatPlanType(snapshot.planType)})` : "";
+    const plan = snapshot.planType ? ` (${snapshot.planType.replace(/_/g, " ").replace(/\b\w/g, c => c.toUpperCase())})` : "";
     const lines = [`→ [${snapshot.provider.toUpperCase()}]${plan}`];
-    const primary = snapshot.primary;
-    if (primary) {
-        const remainingPct = 100 - primary.usedPercent;
-        const label = "Hourly:".padEnd(13);
-        lines.push(`  ${label} ${formatBar(remainingPct)} ${remainingPct.toFixed(0)}% left${formatResetSuffix(primary.resetsAt)}`);
-    }
-    const secondary = snapshot.secondary;
-    if (secondary) {
-        const remainingPct = 100 - secondary.usedPercent;
-        const label = "Weekly:".padEnd(13);
-        lines.push(`  ${label} ${formatBar(remainingPct)} ${remainingPct.toFixed(0)}% left${formatResetSuffix(secondary.resetsAt)}`);
-    }
-    const codeReview = snapshot.codeReview;
-    if (codeReview) {
-        const remainingPct = 100 - codeReview.usedPercent;
-        const label = "Code Review:".padEnd(13);
-        lines.push(`  ${label} ${formatBar(remainingPct)} ${remainingPct.toFixed(0)}% left${formatResetSuffix(codeReview.resetsAt)}`);
+    const metrics = [
+        { label: "Hourly:", data: snapshot.primary },
+        { label: "Weekly:", data: snapshot.secondary },
+        { label: "Code Review:", data: snapshot.codeReview }
+    ];
+    let hasData = false;
+    for (const m of metrics) {
+        if (m.data) {
+            const pct = 100 - m.data.usedPercent;
+            lines.push(`  ${m.label.padEnd(13)} ${formatBar(pct)} ${pct.toFixed(0)}% left${formatResetSuffix(m.data.resetsAt)}`);
+            hasData = true;
+        }
     }
     if (snapshot.credits?.hasCredits) {
         lines.push(`  Credits:      ${snapshot.credits.balance}`);
+        hasData = true;
     }
-    return lines;
+    return hasData ? lines : formatMissingSnapshot(snapshot);
 }
 export async function renderUsageStatus(options) {
     if (options.snapshots.length === 0) {
         const filterMsg = options.filter ? ` for "${options.filter}"` : "";
-        await sendStatusMessage({
-            client: options.client,
-            state: options.state,
-            sessionID: options.sessionID,
-            text: `▣ Usage | No data received${filterMsg}.`,
-        });
-        return;
+        return sendStatusMessage({ ...options, text: `▣ Usage | No data received${filterMsg}.` });
     }
     const lines = ["▣ Usage Status", ""];
-    options.snapshots.forEach((snapshot, index) => {
-        const snapshotLines = formatSnapshot(snapshot);
-        for (const line of snapshotLines)
-            lines.push(line);
-        if (index < options.snapshots.length - 1) {
-            lines.push("");
-            lines.push("---");
-        }
-    });
-    await sendStatusMessage({
-        client: options.client,
-        state: options.state,
-        sessionID: options.sessionID,
-        text: lines.join("\n"),
+    options.snapshots.forEach((s, i) => {
+        lines.push(...formatSnapshot(s));
+        if (i < options.snapshots.length - 1)
+            lines.push("", "---");
     });
+    await sendStatusMessage({ ...options, text: lines.join("\n") });
 }

package/dist/usage/auth/loader.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Utility for loading and merging authentication records from multiple system paths.
+ * Handles platform-specific path resolution and specific provider auth transformations.
+ */
+import z from "zod";
+declare const authEntrySchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodString>;
+    access: z.ZodOptional<z.ZodString>;
+    refresh: z.ZodOptional<z.ZodString>;
+    enterpriseUrl: z.ZodOptional<z.ZodString>;
+    accountId: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type AuthEntry = z.infer<typeof authEntrySchema>;
+export type AuthRecord = Record<string, AuthEntry>;
+export declare function loadMergedAuths(): Promise<{
+    auths: AuthRecord;
+    codexDiagnostics: string[];
+}>;
+export {};
+//# sourceMappingURL=loader.d.ts.map

package/dist/usage/auth/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../src/usage/auth/loader.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,CAAC,MAAM,KAAK,CAAA;AAGnB,QAAA,MAAM,eAAe;;;;;;;iBAOL,CAAA;AAIhB,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AACvD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;AAElD,wBAAsB,eAAe,IAAI,OAAO,CAAC;IAC/C,KAAK,EAAE,UAAU,CAAA;IACjB,gBAAgB,EAAE,MAAM,EAAE,CAAA;CAC3B,CAAC,CAYD"}

package/dist/usage/auth/loader.js

@@ -0,0 +1,68 @@
+/**
+ * Utility for loading and merging authentication records from multiple system paths.
+ * Handles platform-specific path resolution and specific provider auth transformations.
+ */
+import z from "zod";
+import { getPossibleAuthPaths } from "../../utils";
+const authEntrySchema = z.object({
+    type: z.string().optional(),
+    access: z.string().optional(),
+    refresh: z.string().optional(),
+    enterpriseUrl: z.string().optional(),
+    accountId: z.string().optional(),
+    key: z.string().optional(),
+}).passthrough();
+const authRecordSchema = z.record(z.string(), authEntrySchema);
+export async function loadMergedAuths() {
+    const possiblePaths = getPossibleAuthPaths();
+    const mergedAuth = {};
+    const codexDiagnostics = [`Auth paths checked: ${possiblePaths.join(", ")}`];
+    const orderedPaths = [...possiblePaths].reverse();
+    for (const authPath of orderedPaths) {
+        const diagnostics = await processAuthPath(authPath, mergedAuth);
+        codexDiagnostics.push(...diagnostics);
+    }
+    return { auths: mergedAuth, codexDiagnostics };
+}
+async function processAuthPath(authPath, mergedAuth) {
+    const diagnostics = [];
+    try {
+        const file = Bun.file(authPath);
+        if (!(await file.exists()))
+            return [`Missing auth file: ${authPath}`];
+        const data = await file.json();
+        if (typeof data !== "object" || data === null)
+            return [`Auth file is not a JSON object: ${authPath}`];
+        if (authPath.includes(".codex")) {
+            const parsed = parseCodexAuth(data, authPath);
+            if (parsed.auth)
+                Object.assign(mergedAuth, parsed.auth);
+            return parsed.diagnostics;
+        }
+        const parsed = authRecordSchema.safeParse(data);
+        if (!parsed.success)
+            return [`Auth file failed schema validation: ${authPath}`];
+        Object.assign(mergedAuth, parsed.data);
+        diagnostics.push(`Loaded auth from ${authPath}`);
+    }
+    catch (e) {
+        diagnostics.push(`Failed to read auth file ${authPath}: ${e.message}`);
+    }
+    return diagnostics;
+}
+function parseCodexAuth(data, path) {
+    const tokens = data.tokens;
+    if (!tokens?.access_token)
+        return { auth: null, diagnostics: [`Invalid Codex auth in ${path}`] };
+    return {
+        auth: {
+            openai: {
+                type: "oauth",
+                access: tokens.access_token,
+                accountId: tokens.account_id,
+                refresh: tokens.refresh_token,
+            },
+        },
+        diagnostics: [`Codex CLI auth loaded from ${path}`],
+    };
+}

package/dist/usage/fetch.d.ts

@@ -1,15 +1,9 @@
 /**
- * Loads auth data and fetches live usage snapshots from providers.
- * Supports filtering by provider alias.
+ * Orchestrates the fetching of usage snapshots from multiple providers.
+ * Manages provider filtering, concurrency, and fallback for missing data.
  */
 import type { UsageSnapshot } from "../types";
-import type { AuthRecord } from "./registry";
-export declare const providerAliases: Record<string, string>;
-export declare function resolveProviderFilter(filter?: string): string | undefined;
 export declare function fetchUsageSnapshots(filter?: string): Promise<UsageSnapshot[]>;
-export declare function loadAuths(): Promise<AuthRecord>;
-export declare function loadAuthsWithDiagnostics(): Promise<{
-    auths: AuthRecord;
-    codexDiagnostics: string[];
-}>;
+export declare function resolveProviderFilter(filter?: string): string | undefined;
+export declare function loadAuths(): Promise<import("./auth/loader").AuthRecord>;
 //# sourceMappingURL=fetch.d.ts.map

package/dist/usage/fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/usage/fetch.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAI7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAgB5C,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAWlD,CAAA;AAED,wBAAgB,qBAAqB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAIzE;AAED,wBAAsB,mBAAmB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CA+EnF;AAED,wBAAsB,SAAS,IAAI,OAAO,CAAC,UAAU,CAAC,CAGrD;AAED,wBAAsB,wBAAwB,IAAI,OAAO,CAAC;IACxD,KAAK,EAAE,UAAU,CAAA;IACjB,gBAAgB,EAAE,MAAM,EAAE,CAAA;CAC3B,CAAC,CAsED"}
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/usage/fetch.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAQ7C,wBAAsB,mBAAmB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAoCnF;AAWD,wBAAgB,qBAAqB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEzE;AA6BD,wBAAsB,SAAS,gDAG9B"}

package/dist/usage/fetch.js

@@ -1,215 +1,83 @@
 /**
- * Loads auth data and fetches live usage snapshots from providers.
- * Supports filtering by provider alias.
+ * Orchestrates the fetching of usage snapshots from multiple providers.
+ * Manages provider filtering, concurrency, and fallback for missing data.
  */
-import z from "zod";
 import { providers } from "../providers";
 import { loadUsageConfig } from "./config";
-import { getPossibleAuthPaths } from "../utils";
+import { loadMergedAuths } from "./auth/loader";
 import { resolveProviderAuths } from "./registry";
-const authEntrySchema = z
-    .object({
-    type: z.string().optional(),
-    access: z.string().optional(),
-    refresh: z.string().optional(),
-    enterpriseUrl: z.string().optional(),
-    accountId: z.string().optional(),
-    key: z.string().optional(),
-})
-    .passthrough();
-const authRecordSchema = z.record(z.string(), authEntrySchema);
-export const providerAliases = {
-    codex: "codex",
-    openai: "codex",
-    gpt: "codex",
-    proxy: "proxy",
-    agy: "proxy",
-    antigravity: "proxy",
-    gemini: "proxy",
-    copilot: "copilot",
-    gh: "copilot",
-    github: "copilot",
-};
-export function resolveProviderFilter(filter) {
-    if (!filter)
-        return undefined;
-    const normalized = filter.toLowerCase().trim();
-    return providerAliases[normalized];
-}
+const CORE_PROVIDERS = ["codex", "proxy", "copilot"];
 export async function fetchUsageSnapshots(filter) {
-    const targetProvider = resolveProviderFilter(filter);
-    const usageConfig = await loadUsageConfig().catch(() => null);
-    const providerToggles = usageConfig?.providers ?? {};
-    const isProviderEnabled = (id) => {
+    const target = resolveFilter(filter);
+    const config = await loadUsageConfig().catch(() => null);
+    const toggles = config?.providers ?? {};
+    const isEnabled = (id) => {
         if (id === "codex")
-            return providerToggles.openai !== false;
-        if (id === "proxy")
-            return providerToggles.proxy !== false;
-        if (id === "copilot")
-            return providerToggles.copilot !== false;
-        return true;
+            return toggles.openai !== false;
+        return toggles[id] !== false;
     };
-    const { auths, codexDiagnostics } = await loadAuthsWithDiagnostics();
+    const { auths, codexDiagnostics } = await loadMergedAuths();
     const entries = resolveProviderAuths(auths, null);
     const snapshots = [];
-    const coreProviders = ["codex", "proxy", "copilot"];
-    const fetchedProviders = new Set();
+    const fetched = new Set();
     const fetches = entries
-        .filter((entry) => !targetProvider || entry.providerID === targetProvider)
-        .filter((entry) => isProviderEnabled(entry.providerID))
-        .map(async (entry) => {
-        const provider = providers[entry.providerID];
-        if (!provider?.fetchUsage)
-            return;
-        try {
-            const snapshot = await provider.fetchUsage(entry.auth);
-            if (snapshot) {
-                snapshots.push(snapshot);
-                fetchedProviders.add(entry.providerID);
-            }
-        }
-        catch {
+        .filter(e => (!target || e.providerID === target) && isEnabled(e.providerID))
+        .map(async (e) => {
+        const snap = await providers[e.providerID]?.fetchUsage?.(e.auth).catch(() => null);
+        if (snap) {
+            snapshots.push(snap);
+            fetched.add(e.providerID);
         }
     });
-    const specialProviders = ["proxy", "copilot"];
-    for (const id of specialProviders) {
-        if ((!targetProvider || targetProvider === id) && isProviderEnabled(id) && !fetchedProviders.has(id)) {
+    // Handle special/default fetches
+    for (const id of ["proxy", "copilot"]) {
+        if ((!target || target === id) && isEnabled(id) && !fetched.has(id)) {
             const provider = providers[id];
             if (provider?.fetchUsage) {
-                fetches.push(provider
-                    .fetchUsage(undefined)
-                    .then((snapshot) => {
-                    if (snapshot) {
-                        snapshots.push(snapshot);
-                        fetchedProviders.add(id);
+                fetches.push(provider.fetchUsage(undefined).then(s => {
+                    if (s) {
+                        snapshots.push(s);
+                        fetched.add(id);
                     }
-                })
-                    .catch(() => { }));
+                }).catch(() => { }));
             }
         }
     }
-    await Promise.race([Promise.all(fetches), timeout(5000)]);
-    for (const id of coreProviders) {
-        if (isProviderEnabled(id) && !fetchedProviders.has(id)) {
-            if (!targetProvider || targetProvider === id) {
-                const codexDetails = id === "codex" && codexDiagnostics.length > 0 ? codexDiagnostics : undefined;
-                snapshots.push({
-                    timestamp: Date.now(),
-                    provider: id,
-                    planType: null,
-                    primary: null,
-                    secondary: null,
-                    codeReview: null,
-                    credits: null,
-                    updatedAt: Date.now(),
-                    isMissing: true,
-                    missingReason: codexDetails ? "Codex auth was not resolved from auth.json." : undefined,
-                    missingDetails: codexDetails,
-                });
-            }
-        }
-    }
-    return snapshots;
+    await Promise.race([Promise.all(fetches), new Promise(r => setTimeout(r, 5000))]);
+    return appendMissingStates(snapshots, fetched, isEnabled, target, codexDiagnostics);
 }
-export async function loadAuths() {
-    const { auths } = await loadAuthsWithDiagnostics();
-    return auths;
+function resolveFilter(f) {
+    const aliases = {
+        codex: "codex", openai: "codex", gpt: "codex",
+        proxy: "proxy", agy: "proxy", gemini: "proxy",
+        copilot: "copilot", github: "copilot"
+    };
+    return f ? aliases[f.toLowerCase().trim()] : undefined;
 }
-export async function loadAuthsWithDiagnostics() {
-    const possiblePaths = getPossibleAuthPaths();
-    const mergedAuth = {};
-    const codexDiagnostics = [];
-    const orderedPaths = [...possiblePaths].reverse();
-    codexDiagnostics.push(`Auth paths checked: ${possiblePaths.join(", ")}`);
-    for (const authPath of orderedPaths) {
-        try {
-            const file = Bun.file(authPath);
-            const exists = await file.exists();
-            if (!exists) {
-                codexDiagnostics.push(`Missing auth file: ${authPath}`);
-                continue;
-            }
-            const data = await file.json();
-            if (!isRecord(data)) {
-                codexDiagnostics.push(`Auth file is not a JSON object: ${authPath}`);
-                continue;
-            }
-            if (authPath.includes(".codex")) {
-                const parsed = parseCodexAuth(data, authPath);
-                codexDiagnostics.push(...parsed.diagnostics);
-                if (parsed.auth)
-                    Object.assign(mergedAuth, parsed.auth);
-                continue;
-            }
-            const parsed = authRecordSchema.safeParse(data);
-            if (!parsed.success) {
-                codexDiagnostics.push(`Auth file failed schema validation: ${authPath}`);
-                continue;
-            }
-            Object.assign(mergedAuth, parsed.data);
-            const openaiEntry = parsed.data.openai ?? parsed.data.codex;
-            if (!openaiEntry) {
-                codexDiagnostics.push(`No "openai" or "codex" entry in auth file: ${authPath}`);
-                continue;
-            }
-            codexDiagnostics.push(`Found OpenAI/Codex entry in auth file: ${authPath}`);
-            if (openaiEntry.type && openaiEntry.type !== "oauth" && openaiEntry.type !== "token") {
-                codexDiagnostics.push(`OpenAI/Codex entry has unsupported type "${openaiEntry.type}" in ${authPath}`);
-            }
-            if (!openaiEntry.access && !openaiEntry.key) {
-                codexDiagnostics.push(`OpenAI/Codex entry missing "access" or "key" in ${authPath}`);
-            }
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            codexDiagnostics.push(`Failed to read auth file ${authPath}: ${message}`);
-            continue;
-        }
-    }
-    const mergedEntry = mergedAuth.openai ?? mergedAuth.codex;
-    if (!mergedEntry) {
-        codexDiagnostics.push("Merged auth record has no OpenAI/Codex entry.");
-    }
-    else {
-        if (mergedEntry.type && mergedEntry.type !== "oauth" && mergedEntry.type !== "token") {
-            codexDiagnostics.push(`Merged OpenAI/Codex entry has unsupported type "${mergedEntry.type}".`);
-        }
-        if (!mergedEntry.access && !mergedEntry.key) {
-            codexDiagnostics.push("Merged OpenAI/Codex entry missing access or key.");
-        }
-    }
-    return { auths: mergedAuth, codexDiagnostics };
+export function resolveProviderFilter(filter) {
+    return resolveFilter(filter);
 }
-function parseCodexAuth(data, authPath) {
-    const diagnostics = [];
-    const tokens = data.tokens;
-    if (!isRecord(tokens)) {
-        diagnostics.push(`Codex auth missing "tokens" object in ${authPath}`);
-        return { auth: null, diagnostics };
-    }
-    const accessToken = tokens.access_token;
-    if (typeof accessToken !== "string" || accessToken.length === 0) {
-        diagnostics.push(`Codex auth missing tokens.access_token in ${authPath}`);
-        return { auth: null, diagnostics };
+function appendMissingStates(snaps, fetched, isEnabled, target, diagnostics) {
+    for (const id of CORE_PROVIDERS) {
+        if (isEnabled(id) && !fetched.has(id) && (!target || target === id)) {
+            snaps.push({
+                timestamp: Date.now(),
+                provider: id,
+                planType: null,
+                primary: null,
+                secondary: null,
+                codeReview: null,
+                credits: null,
+                updatedAt: Date.now(),
+                isMissing: true,
+                missingReason: id === "codex" ? "Auth resolution failed" : undefined,
+                missingDetails: id === "codex" ? diagnostics : undefined
+            });
+        }
     }
-    const accountId = tokens.account_id;
-    const refreshToken = tokens.refresh_token;
-    diagnostics.push(`Codex CLI auth loaded from ${authPath}`);
-    return {
-        auth: {
-            openai: {
-                type: "oauth",
-                access: accessToken,
-                accountId: typeof accountId === "string" ? accountId : undefined,
-                refresh: typeof refreshToken === "string" ? refreshToken : undefined,
-            },
-        },
-        diagnostics,
-    };
+    return snaps;
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
-function timeout(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+export async function loadAuths() {
+    const { auths } = await loadMergedAuths();
+    return auths;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/opencode-usage-plugin",
-  "version": "0.1.4-dev.0",
+  "version": "0.1.4-dev.1",
   "description": "opencode plugin for tracking AI provider usage, rate limits, and quotas",
   "type": "module",
   "main": "dist/index.js",