@slkiser/opencode-quota 3.9.0 → 3.10.1

package/dist/plugin.js

@@ -9,115 +9,23 @@ import { DEFAULT_CONFIG } from "./lib/types.js";
 import { createLoadConfigMeta } from "./lib/config.js";
 import { clearCache, getOrFetchWithCacheControl } from "./lib/cache.js";
 import { formatQuotaRows } from "./lib/format.js";
-import { formatQuotaCommand } from "./lib/quota-command-format.js";
 import { getProviders } from "./providers/registry.js";
 import { tool } from "@opencode-ai/plugin";
-import { aggregateUsage, resolveSessionTree, SessionNotFoundError, } from "./lib/quota-stats.js";
-import { formatQuotaStatsReport } from "./lib/quota-stats-format.js";
 import { buildQuotaStatusReport } from "./lib/quota-status.js";
 import { inspectTuiConfig } from "./lib/tui-config-diagnostics.js";
-import { getPricingSnapshotMeta, getPricingSnapshotSource, getRuntimePricingRefreshStatePath, getRuntimePricingSnapshotPath, maybeRefreshPricingSnapshot, setPricingSnapshotAutoRefresh, setPricingSnapshotSelection, } from "./lib/modelsdev-pricing.js";
+import { maybeRefreshPricingSnapshot, setPricingSnapshotAutoRefresh, setPricingSnapshotSelection, } from "./lib/modelsdev-pricing.js";
 import { refreshGoogleTokensForAllAccounts } from "./lib/google.js";
 import { DEFAULT_ALIBABA_AUTH_CACHE_MAX_AGE_MS, isAlibabaModelId, resolveAlibabaCodingPlanAuthCached, } from "./lib/alibaba-auth.js";
 import { isQwenCodeModelId, resolveQwenLocalPlanCached } from "./lib/qwen-auth.js";
 import { recordAlibabaCodingPlanCompletion, recordQwenCompletion } from "./lib/qwen-local-quota.js";
 import { isCursorModelId, isCursorProviderId } from "./lib/cursor-pricing.js";
-import { parseOptionalJsonArgs, parseQuotaBetweenArgs, startOfLocalDayMs, startOfNextLocalDayMs, formatYmd, } from "./lib/command-parsing.js";
-import { handled } from "./lib/command-handled.js";
-import { renderCommandHeading } from "./lib/format-utils.js";
 import { sanitizeDisplayText } from "./lib/display-sanitize.js";
-import { ALL_WINDOWS_FORMAT_STYLE, SINGLE_WINDOW_PER_PROVIDER_FORMAT_STYLE, resolveQuotaFormatStyle, } from "./lib/quota-format-style.js";
-import { collectConcreteEnabledProviderIds, collectQuotaRenderData, collectQuotaStatusLiveProbes, matchesQuotaProviderCurrentSelection, resolveQuotaRenderSelection, } from "./lib/quota-render-data.js";
+import { SINGLE_WINDOW_PER_PROVIDER_FORMAT_STYLE, resolveQuotaFormatStyle, } from "./lib/quota-format-style.js";
+import { collectQuotaRenderData, collectQuotaStatusLiveProbes, matchesQuotaProviderCurrentSelection, } from "./lib/quota-render-data.js";
 import { createQuotaProviderRuntimeContext, createQuotaRuntimeRequestContext, resolveQuotaRuntimeContext, } from "./lib/quota-runtime-context.js";
 import { findGitWorktreeRoot, getEffectiveConfigRoot } from "./lib/config-file-utils.js";
 import { BUNDLED_MAINTAINER_ANNOUNCEMENTS, formatMaintainerAnnouncementHomeCountLine, getMaintainerAnnouncementsSummary, } from "./lib/maintainer-announcements.js";
 const DEFERRED_QUOTA_REFRESH_DELAYS_MS = [3_000, 15_000, 60_000, 300_000];
-/** All token report command specifications */
-const TOKEN_REPORT_COMMANDS = [
-    {
-        id: "tokens_today",
-        template: "/tokens_today",
-        description: "Token + deterministic cost summary for today (calendar day, local timezone).",
-        title: "Tokens used (Today) (/tokens_today)",
-        metadataTitle: "Tokens used (Today)",
-        kind: "today",
-    },
-    {
-        id: "tokens_daily",
-        template: "/tokens_daily",
-        description: "Token + deterministic cost summary for the last 24 hours (rolling).",
-        title: "Tokens used (Last 24 Hours) (/tokens_daily)",
-        metadataTitle: "Tokens used (Last 24 Hours)",
-        kind: "rolling",
-        windowMs: 24 * 60 * 60 * 1000,
-    },
-    {
-        id: "tokens_weekly",
-        template: "/tokens_weekly",
-        description: "Token + deterministic cost summary for the last 7 days (rolling).",
-        title: "Tokens used (Last 7 Days) (/tokens_weekly)",
-        metadataTitle: "Tokens used (Last 7 Days)",
-        kind: "rolling",
-        windowMs: 7 * 24 * 60 * 60 * 1000,
-    },
-    {
-        id: "tokens_monthly",
-        template: "/tokens_monthly",
-        description: "Token + deterministic cost summary for the last 30 days (rolling).",
-        title: "Tokens used (Last 30 Days) (/tokens_monthly)",
-        metadataTitle: "Tokens used (Last 30 Days)",
-        kind: "rolling",
-        windowMs: 30 * 24 * 60 * 60 * 1000,
-    },
-    {
-        id: "tokens_all",
-        template: "/tokens_all",
-        description: "Token + deterministic cost summary for all locally saved OpenCode history.",
-        title: "Tokens used (All Time) (/tokens_all)",
-        metadataTitle: "Tokens used (All Time)",
-        kind: "all",
-        topModels: 12,
-        topSessions: 12,
-    },
-    {
-        id: "tokens_session",
-        template: "/tokens_session",
-        description: "Token + deterministic cost summary for current session only.",
-        title: "Tokens used (Current Session) (/tokens_session)",
-        metadataTitle: "Tokens used (Current Session)",
-        kind: "session",
-    },
-    {
-        id: "tokens_session_all",
-        template: "/tokens_session_all",
-        description: "Token + deterministic cost summary for current session and all descendant child/subagent sessions.",
-        title: "Tokens used (Current Session Tree) (/tokens_session_all)",
-        metadataTitle: "Tokens used (Current Session Tree)",
-        kind: "session_tree",
-    },
-    {
-        id: "tokens_between",
-        template: "/tokens_between",
-        description: "Token + deterministic cost report between two YYYY-MM-DD dates (local timezone, inclusive).",
-        titleForRange: (startYmd, endYmd) => {
-            return `Tokens used (${formatYmd(startYmd)} .. ${formatYmd(endYmd)}) (/tokens_between)`;
-        },
-        metadataTitle: "Tokens used (Date Range)",
-        kind: "between",
-    },
-];
-/** Build a lookup map from command ID to spec */
-const TOKEN_REPORT_COMMANDS_BY_ID = (() => {
-    const map = new Map();
-    for (const spec of TOKEN_REPORT_COMMANDS) {
-        map.set(spec.id, spec);
-    }
-    return map;
-})();
-/** Check if a command is a token report command */
-function isTokenReportCommand(cmd) {
-    return TOKEN_REPORT_COMMANDS_BY_ID.has(cmd);
-}
 // =============================================================================
 // Plugin Implementation
 // =============================================================================
@@ -539,56 +447,6 @@ export const QuotaToastPlugin = async ({ client }) => {
             `available=${availability}`,
         ].join("\n");
     }
-    function describeQuotaCommandCurrentSelection(params) {
-        if (isCursorProviderId(params.currentProviderID)) {
-            return `current provider: ${params.currentProviderID}`;
-        }
-        if (params.currentModel) {
-            return `current model: ${params.currentModel}`;
-        }
-        return "current session";
-    }
-    async function buildQuotaCommandUnavailableMessage(runtime) {
-        const selection = await resolveQuotaRenderSelection({
-            client: runtime.client,
-            config: runtime.config,
-            request: createQuotaRuntimeRequestContext(runtime),
-            providers: runtime.providers,
-        });
-        if (!selection) {
-            return "Quota unavailable\n\nNo enabled quota providers are configured.\n\nRun /quota_status for diagnostics.";
-        }
-        if (selection.filteringByCurrentSelection && selection.filtered.length === 0) {
-            const detail = describeQuotaCommandCurrentSelection({
-                currentModel: selection.currentModel,
-                currentProviderID: selection.currentProviderID,
-            });
-            return `Quota unavailable\n\nNo enabled quota providers matched the ${detail}.\n\nRun /quota_status for diagnostics.`;
-        }
-        const avail = await Promise.all(selection.filtered.map(async (p) => {
-            try {
-                return { id: p.id, ok: await p.isAvailable(selection.ctx) };
-            }
-            catch {
-                return { id: p.id, ok: false };
-            }
-        }));
-        const availableIds = avail.filter((x) => x.ok).map((x) => x.id);
-        if (availableIds.length === 0) {
-            const scopedDetail = selection.filteringByCurrentSelection
-                ? ` for the ${describeQuotaCommandCurrentSelection({
-                    currentModel: selection.currentModel,
-                    currentProviderID: selection.currentProviderID,
-                })}`
-                : "";
-            return (`Quota unavailable\n\nNo quota providers detected${scopedDetail}. ` +
-                "Make sure you are logged in to a supported provider (Copilot, OpenAI, etc.).\n\n" +
-                "Run /quota_status for diagnostics.");
-        }
-        return (`Quota unavailable\n\nProviders detected (${availableIds.join(", ")}) but returned no data. ` +
-            "This may be a temporary API error.\n\n" +
-            "Run /quota_status for diagnostics.");
-    }
     function buildToastCacheKey(params) {
         const formatStyle = resolveQuotaFormatStyle(config.formatStyle);
         const enabledProviders = config.enabledProviders === "auto" ? "auto" : config.enabledProviders.join(",");
@@ -949,46 +807,11 @@ export const QuotaToastPlugin = async ({ client }) => {
         }
         finally {
             const state = deferredQuotaRefreshes.get(sessionID);
-            if (state) {
+            if (state && state === pendingDeferred) {
                 state.inFlight = false;
             }
         }
     }
-    async function fetchQuotaCommandData(runtime) {
-        const request = createQuotaRuntimeRequestContext(runtime);
-        const quotaResult = await collectQuotaRenderData({
-            client: runtime.client,
-            config: runtime.config,
-            configMeta: runtime.configMeta,
-            request,
-            surfaceExplicitProviderIssues: false,
-            formatStyle: ALL_WINDOWS_FORMAT_STYLE,
-            providers: runtime.providers,
-        });
-        if (runtime.config.showSessionTokens && request.sessionID) {
-            lastSessionTokenError = quotaResult.sessionTokenError;
-        }
-        return quotaResult.data;
-    }
-    async function buildQuotaReport(params) {
-        const result = await aggregateUsage({
-            sinceMs: params.sinceMs,
-            untilMs: params.untilMs,
-            sessionID: params.filterSessionID,
-            sessionIDs: params.filterSessionIDs,
-        });
-        return formatQuotaStatsReport({
-            title: params.title,
-            result,
-            topModels: params.topModels,
-            topSessions: params.topSessions,
-            focusSessionID: params.sessionID,
-            sessionOnly: params.sessionOnly,
-            reportKind: params.reportKind,
-            sessionTree: params.sessionTree,
-            generatedAtMs: params.generatedAtMs,
-        });
-    }
     async function buildStatusReport(params) {
         const runtime = await resolvePluginRuntimeContext({
             sessionID: params.sessionID,
@@ -1113,266 +936,12 @@ export const QuotaToastPlugin = async ({ client }) => {
             generatedAtMs: params.generatedAtMs,
         });
     }
-    function formatIsoTimestamp(timestampMs) {
-        return typeof timestampMs === "number" && Number.isFinite(timestampMs) && timestampMs > 0
-            ? new Date(timestampMs).toISOString()
-            : "(none)";
-    }
-    function buildPricingRefreshCommandOutput(params) {
-        const meta = getPricingSnapshotMeta();
-        const activeSource = getPricingSnapshotSource();
-        const configuredSelection = config.pricingSnapshot.source;
-        const resultLabel = params.result.reason ??
-            params.result.state.lastResult ??
-            (params.result.updated ? "success" : "unknown");
-        const lines = [
-            renderCommandHeading({
-                title: "Pricing Refresh (/pricing_refresh)",
-                generatedAtMs: params.generatedAtMs,
-            }),
-            "",
-            "refresh:",
-            `- attempted: ${params.result.attempted ? "true" : "false"}`,
-            `- result: ${resultLabel}`,
-            `- runtime_snapshot_persisted: ${params.result.updated ? "true" : "false"}`,
-        ];
-        if (params.result.error) {
-            lines.push(`- error: ${params.result.error}`);
-        }
-        lines.push("");
-        lines.push("pricing_snapshot:");
-        lines.push(`- selection: configured=${configuredSelection} active=${activeSource}`);
-        lines.push(`- active_snapshot: source=${meta.source} generated_at=${formatIsoTimestamp(meta.generatedAt)} units=${meta.units}`);
-        lines.push(`- runtime_paths: snapshot=${getRuntimePricingSnapshotPath()} refresh_state=${getRuntimePricingRefreshStatePath()}`);
-        if (configuredSelection === "bundled" && params.result.updated) {
-            lines.push("- selection_note: runtime snapshot refreshed locally, but active reports remain pinned to bundled pricing");
-        }
-        return lines.join("\n");
-    }
-    function buildTokenReportUnavailableOutput(params) {
-        const lines = [
-            renderCommandHeading({
-                title: `Token report unavailable (${params.command})`,
-                generatedAtMs: params.generatedAtMs,
-            }),
-            "",
-            "session_lookup_error:",
-            `- session_id: ${params.error.sessionID}`,
-            `- error: ${params.error.message}`,
-            `- checked_path: ${params.error.checkedPath}`,
-        ];
-        return lines.join("\n");
-    }
-    async function injectCommandOutputAndHandle(sessionID, output) {
-        if (output !== undefined && output !== null) {
-            await injectRawOutput(sessionID, output);
-        }
-        handled();
-    }
-    async function handleQuotaSlashCommand(input) {
-        const sessionID = input.sessionID;
-        const generatedAtMs = Date.now();
-        const sessionMeta = sessionID ? await getSessionModelMeta(sessionID) : undefined;
-        const runtime = await resolvePluginRuntimeContext({
-            sessionID,
-            sessionMeta,
-            includeSessionMeta: (config) => config.onlyCurrentModel,
-        });
-        const reportData = await fetchQuotaCommandData(runtime);
-        if (!reportData) {
-            if (!configLoaded) {
-                return await injectCommandOutputAndHandle(sessionID, "Quota unavailable (config not loaded, try again)");
-            }
-            if (!runtime.config.enabled) {
-                return await injectCommandOutputAndHandle(sessionID, "Quota disabled in config (enabled: false)");
-            }
-            return await injectCommandOutputAndHandle(sessionID, await buildQuotaCommandUnavailableMessage(runtime));
-        }
-        return await injectCommandOutputAndHandle(sessionID, formatQuotaCommand({
-            ...reportData,
-            generatedAtMs,
-        }));
-    }
-    async function handlePricingRefreshSlashCommand(input) {
-        const sessionID = input.sessionID;
-        const generatedAtMs = Date.now();
-        if ((input.arguments ?? "").trim()) {
-            return await injectCommandOutputAndHandle(sessionID, "Invalid arguments for /pricing_refresh\n\nThis command does not accept arguments.\n\nUsage:\n/pricing_refresh");
-        }
-        const result = await maybeRefreshPricingSnapshot({
-            reason: "manual",
-            force: true,
-            snapshotSelection: config.pricingSnapshot.source,
-            allowRefreshWhenSelectionBundled: true,
-        });
-        return await injectCommandOutputAndHandle(sessionID, buildPricingRefreshCommandOutput({
-            result,
-            generatedAtMs,
-        }));
-    }
-    async function handleTokenReportSlashCommand(input, command) {
-        const sessionID = input.sessionID;
-        const untilMs = Date.now();
-        const generatedAtMs = Date.now();
-        await kickPricingRefresh({ reason: "tokens", maxWaitMs: 750 });
-        const spec = TOKEN_REPORT_COMMANDS_BY_ID.get(command);
-        try {
-            if (spec.kind === "between") {
-                const parsed = parseQuotaBetweenArgs(input.arguments);
-                if (!parsed.ok) {
-                    return await injectCommandOutputAndHandle(sessionID, `Invalid arguments for /${spec.id}\n\n${parsed.error}\n\nExpected: /${spec.id} YYYY-MM-DD YYYY-MM-DD\nExample: /${spec.id} 2026-01-01 2026-01-15`);
-                }
-                const sinceMs = startOfLocalDayMs(parsed.startYmd);
-                const rangeUntilMs = startOfNextLocalDayMs(parsed.endYmd);
-                return await injectCommandOutputAndHandle(sessionID, await buildQuotaReport({
-                    title: spec.titleForRange(parsed.startYmd, parsed.endYmd),
-                    sinceMs,
-                    untilMs: rangeUntilMs,
-                    sessionID,
-                    generatedAtMs,
-                }));
-            }
-            let sinceMs;
-            let filterSessionID;
-            let filterSessionIDs;
-            let sessionOnly;
-            let topModels;
-            let topSessions;
-            let reportKind;
-            let sessionTree;
-            switch (spec.kind) {
-                case "rolling":
-                    sinceMs = untilMs - spec.windowMs;
-                    break;
-                case "today": {
-                    const now = new Date();
-                    const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate());
-                    sinceMs = startOfDay.getTime();
-                    break;
-                }
-                case "session":
-                    filterSessionID = sessionID;
-                    sessionOnly = true;
-                    reportKind = "session";
-                    break;
-                case "session_tree": {
-                    const nodes = await resolveSessionTree(sessionID);
-                    filterSessionIDs = nodes.map((node) => node.sessionID);
-                    reportKind = "session_tree";
-                    sessionTree = { rootSessionID: sessionID, nodes };
-                    break;
-                }
-                case "all":
-                    topModels = spec.topModels;
-                    topSessions = spec.topSessions;
-                    break;
-            }
-            return await injectCommandOutputAndHandle(sessionID, await buildQuotaReport({
-                title: spec.title,
-                sinceMs,
-                untilMs: spec.kind === "rolling" || spec.kind === "today" ? untilMs : undefined,
-                sessionID,
-                filterSessionID,
-                filterSessionIDs,
-                sessionOnly,
-                reportKind,
-                sessionTree,
-                topModels,
-                topSessions,
-                generatedAtMs,
-            }));
-        }
-        catch (err) {
-            if (err instanceof SessionNotFoundError) {
-                return await injectCommandOutputAndHandle(sessionID, buildTokenReportUnavailableOutput({
-                    command: spec.template,
-                    generatedAtMs,
-                    error: err,
-                }));
-            }
-            throw err;
-        }
-    }
-    async function buildQuotaAnnouncementsCommandOutput() {
-        let activeAnnouncements = [];
-        if (config.enabled && config.maintainerAnnouncements.enabled) {
-            const runtime = await resolvePluginRuntimeContext();
-            const providerIds = await collectConcreteEnabledProviderIds({
-                providers: runtime.providers,
-                ctx: createQuotaProviderRuntimeContext(runtime),
-                enabledProviders: runtime.config.enabledProviders,
-            });
-            const summary = getMaintainerAnnouncementsSummary({
-                announcements: BUNDLED_MAINTAINER_ANNOUNCEMENTS,
-                enabledProviders: providerIds,
-            });
-            activeAnnouncements = summary.activeAnnouncements;
-        }
-        const lines = ["Maintainer announcements", ""];
-        if (activeAnnouncements.length === 0) {
-            lines.push("No current announcements.");
-            return lines.join("\n");
-        }
-        for (const evaluation of activeAnnouncements) {
-            lines.push(`- ${evaluation.announcement.message}`);
-            if (evaluation.announcement.url) {
-                lines.push(`  ${evaluation.announcement.url}`);
-            }
-        }
-        return lines.join("\n");
-    }
-    async function handleQuotaAnnouncementsSlashCommand(input) {
-        if ((input.arguments ?? "").trim()) {
-            return await injectCommandOutputAndHandle(input.sessionID, "Invalid arguments for /quota_announcements\n\nThis command does not accept arguments.\n\nUsage: /quota_announcements");
-        }
-        return await injectCommandOutputAndHandle(input.sessionID, await buildQuotaAnnouncementsCommandOutput());
-    }
-    async function handleQuotaStatusSlashCommand(input) {
-        const sessionID = input.sessionID;
-        const generatedAtMs = Date.now();
-        const parsed = parseOptionalJsonArgs(input.arguments);
-        if (!parsed.ok) {
-            return await injectCommandOutputAndHandle(sessionID, `Invalid arguments for /quota_status\n\n${parsed.error}\n\nExample:\n/quota_status {"refreshGoogleTokens": true}`);
-        }
-        const out = await buildStatusReport({
-            refreshGoogleTokens: parsed.value["refreshGoogleTokens"] === true,
-            skewMs: typeof parsed.value["skewMs"] === "number" ? parsed.value["skewMs"] : undefined,
-            force: parsed.value["force"] === true,
-            sessionID,
-            generatedAtMs,
-        });
-        return await injectCommandOutputAndHandle(sessionID, out);
-    }
     // Return hook implementations
     return {
-        // Register built-in slash commands (in addition to /tool quota_*)
+        // Preserve unrelated config repair only. Deterministic quota slash commands are
+        // registered by the TUI plugin as palette/slash dialog commands.
         config: async (input) => {
             const cfg = input;
-            cfg.command ??= {};
-            // Non-token commands (quota toast and diagnostics)
-            cfg.command["quota"] = {
-                template: "/quota",
-                description: "Show quota toast output in chat.",
-            };
-            cfg.command["quota_status"] = {
-                template: "/quota_status",
-                description: "Diagnostics for toast + TUI + pricing + local storage (includes unknown pricing report).",
-            };
-            cfg.command["quota_announcements"] = {
-                template: "/quota_announcements",
-                description: "List active bundled maintainer announcements.",
-            };
-            cfg.command["pricing_refresh"] = {
-                template: "/pricing_refresh",
-                description: "Refresh the local runtime pricing snapshot from models.dev.",
-            };
-            // Register token report commands (/tokens_*)
-            for (const spec of TOKEN_REPORT_COMMANDS) {
-                cfg.command[spec.id] = {
-                    template: spec.template,
-                    description: spec.description,
-                };
-            }
             // Fix zero-width space mismatch between default_agent and agent keys.
             // Some plugins remap agent keys with invisible Unicode prefixes for sort
             // ordering but set default_agent without them, causing OpenCode to crash
@@ -1386,45 +955,6 @@ export const QuotaToastPlugin = async ({ client }) => {
                 }
             }
         },
-        "command.execute.before": async (input) => {
-            try {
-                const cmd = input.command;
-                const isHandledSlashCommand = cmd === "quota" ||
-                    cmd === "quota_status" ||
-                    cmd === "quota_announcements" ||
-                    cmd === "pricing_refresh" ||
-                    isTokenReportCommand(cmd);
-                if (isHandledSlashCommand && !configLoaded) {
-                    await refreshConfig();
-                }
-                if (isHandledSlashCommand && cmd !== "quota_announcements" && !config.enabled) {
-                    handled();
-                }
-                if (cmd === "quota") {
-                    return await handleQuotaSlashCommand(input);
-                }
-                if (cmd === "pricing_refresh") {
-                    return await handlePricingRefreshSlashCommand(input);
-                }
-                if (cmd === "quota_announcements") {
-                    return await handleQuotaAnnouncementsSlashCommand(input);
-                }
-                // Handle token report commands (/tokens_*)
-                if (isTokenReportCommand(cmd)) {
-                    return await handleTokenReportSlashCommand(input, cmd);
-                }
-                // Handle /quota_status (diagnostics - not a token report)
-                if (cmd === "quota_status") {
-                    return await handleQuotaStatusSlashCommand(input);
-                }
-            }
-            catch (err) {
-                // IMPORTANT: do not swallow command-handled sentinel errors.
-                // In OpenCode 1.2.15, if this hook resolves, SessionPrompt.command()
-                // proceeds to prompt(...) and can invoke the tool/LLM path.
-                throw err;
-            }
-        },
         tool: {
             quota_status: tool({
                 description: "Diagnostics for toast + TUI + pricing + local storage (includes unknown pricing report).",