@leo000001/opencode-quota-sidebar 3.0.10 → 4.0.2

package/dist/history_messages.js

@@ -0,0 +1,157 @@
+import { debug } from './helpers.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function decodeTokens(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (!isFiniteNumber(value.input))
+        return undefined;
+    if (!isFiniteNumber(value.output))
+        return undefined;
+    const reasoning = isFiniteNumber(value.reasoning) ? value.reasoning : 0;
+    const cacheRaw = isRecord(value.cache) ? value.cache : {};
+    const read = isFiniteNumber(cacheRaw.read) ? cacheRaw.read : 0;
+    const write = isFiniteNumber(cacheRaw.write) ? cacheRaw.write : 0;
+    return {
+        input: value.input,
+        output: value.output,
+        reasoning,
+        cache: { read, write },
+    };
+}
+export function decodeMessageInfo(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (typeof value.id !== 'string')
+        return undefined;
+    if (typeof value.sessionID !== 'string')
+        return undefined;
+    if (typeof value.role !== 'string')
+        return undefined;
+    if (!isRecord(value.time))
+        return undefined;
+    if (!isFiniteNumber(value.time.created))
+        return undefined;
+    if (value.time.completed !== undefined &&
+        !isFiniteNumber(value.time.completed)) {
+        return undefined;
+    }
+    if (value.role !== 'assistant') {
+        return {
+            ...value,
+            time: {
+                created: value.time.created,
+                completed: value.time.completed,
+            },
+        };
+    }
+    if (typeof value.providerID !== 'string')
+        return undefined;
+    if (typeof value.modelID !== 'string')
+        return undefined;
+    const tokens = decodeTokens(value.tokens);
+    if (!tokens)
+        return undefined;
+    return {
+        ...value,
+        time: {
+            created: value.time.created,
+            completed: value.time.completed,
+        },
+        tokens,
+    };
+}
+export function decodeMessageEntries(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const decoded = value
+        .map((item) => {
+        if (!isRecord(item))
+            return undefined;
+        const info = decodeMessageInfo(item.info);
+        if (!info)
+            return undefined;
+        return { info };
+    })
+        .filter((item) => Boolean(item));
+    if (decoded.length > 0 && decoded.length < value.length) {
+        debug(`message entries partially decoded: kept ${decoded.length}/${value.length}`);
+        return undefined;
+    }
+    if (decoded.length === 0 && value.length > 0)
+        return undefined;
+    return decoded;
+}
+export function nextCursorFromResponse(value) {
+    if (!isRecord(value))
+        return undefined;
+    const response = value.response;
+    if (!isRecord(response))
+        return undefined;
+    const headers = response.headers;
+    if (!headers || typeof headers.get !== 'function') {
+        return undefined;
+    }
+    const next = headers.get('X-Next-Cursor');
+    return typeof next === 'string' && next ? next : undefined;
+}
+function errorStatusCode(value, seen = new Set()) {
+    if (!isRecord(value) || seen.has(value))
+        return undefined;
+    seen.add(value);
+    const status = value.status;
+    if (typeof status === 'number' && Number.isFinite(status))
+        return status;
+    const statusCode = value.statusCode;
+    if (typeof statusCode === 'number' && Number.isFinite(statusCode)) {
+        return statusCode;
+    }
+    return (errorStatusCode(value.response, seen) ||
+        errorStatusCode(value.cause, seen) ||
+        errorStatusCode(value.error, seen));
+}
+function errorText(value, seen = new Set()) {
+    if (!value || seen.has(value))
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return `${value}`;
+    if (value instanceof Error) {
+        seen.add(value);
+        return [
+            value.message,
+            errorText(value.cause, seen),
+        ]
+            .filter(Boolean)
+            .join('\n');
+    }
+    if (!isRecord(value))
+        return '';
+    seen.add(value);
+    return [
+        typeof value.message === 'string' ? value.message : '',
+        typeof value.error === 'string' ? value.error : '',
+        typeof value.detail === 'string' ? value.detail : '',
+        typeof value.title === 'string' ? value.title : '',
+        errorText(value.response, seen),
+        errorText(value.data, seen),
+        errorText(value.cause, seen),
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+export function isMissingSessionError(error) {
+    const status = errorStatusCode(error);
+    if (status === 404 || status === 410)
+        return true;
+    const text = errorText(error).toLowerCase();
+    if (!text)
+        return false;
+    return (/\b(session|conversation)\b.*\b(not found|missing|deleted|does not exist)\b/.test(text) ||
+        /\b(not found|missing|deleted|does not exist)\b.*\b(session|conversation)\b/.test(text));
+}

package/dist/history_usage.d.ts

@@ -0,0 +1,93 @@
+import type { AssistantMessage, Message } from '@opencode-ai/sdk';
+import { type HistoryPeriod, type PeriodRange, type SinceSpec } from './period.js';
+import { type UsageSummary } from './usage.js';
+import type { CacheCoverageMode, CachedSessionUsage, IncrementalCursor } from './types.js';
+export type HistoryDialogRow = {
+    label: string;
+    isCurrent: boolean;
+    usage: UsageSummary;
+};
+export type HistoryDialogData = {
+    period: HistoryPeriod;
+    since: string;
+    rows: HistoryDialogRow[];
+    total: UsageSummary;
+    warning?: string;
+};
+export type HistoryUsageRow = {
+    range: PeriodRange;
+    usage: UsageSummary;
+};
+export type HistoryUsageResult = {
+    period: HistoryPeriod;
+    since: SinceSpec;
+    rows: HistoryUsageRow[];
+    total: UsageSummary;
+    warning?: string;
+    persistenceHints?: HistoryPersistenceHint[];
+};
+type MessageEntry = {
+    info: Message;
+};
+export type HistoryPersistenceHint = {
+    sessionID: string;
+    dateKey: string;
+    lastMessageTime: number | undefined;
+    dirty: boolean;
+    ranges: UsageSummary[];
+    totalUsage: UsageSummary;
+    fullUsage: UsageSummary | undefined;
+    persist: boolean;
+    cursor: IncrementalCursor | undefined;
+    missing: boolean;
+    loadFailed: boolean;
+};
+export type LoadMessagesPageResult = {
+    status: 'ok';
+    entries: MessageEntry[];
+    nextBefore?: string;
+} | {
+    status: 'missing';
+} | {
+    status: 'error';
+};
+type SessionEntry = {
+    sessionID: string;
+    dateKey: string;
+    state: {
+        createdAt: number;
+        cursor?: IncrementalCursor;
+        dirty?: boolean;
+        usage?: CachedSessionUsage;
+    };
+};
+export type ComputeHistoryUsageDeps = {
+    /** All known sessions (from memory state + disk chunks). */
+    sessions: SessionEntry[];
+    /** Paged message loader — injected so both server and TUI can provide their own implementation. */
+    loadMessagesPage: (sessionID: string, before?: string) => Promise<LoadMessagesPageResult>;
+    /** Model pricing map for API-cost estimation. */
+    getModelCostMap: () => Promise<Record<string, unknown>>;
+    /** Calculate equivalent API cost for a single assistant message. */
+    calcApiCost: (message: AssistantMessage, modelCostMap: Record<string, unknown>) => number;
+    /** Classify cache coverage mode for a single assistant message. */
+    classifyCacheMode: (message: AssistantMessage, modelCostMap: Record<string, unknown>) => CacheCoverageMode;
+    /** Check whether a set of entries has at least one resolvable API-cost message. */
+    hasResolvableApiCostMessages: (entries: MessageEntry[], modelCostMap: Record<string, unknown>) => boolean;
+    /** Whether the cached usage for a session needs a full recompute. */
+    shouldTrackFullUsage: (cached: CachedSessionUsage | undefined, hasPricing: boolean) => boolean;
+    /** Whether cached usage needs recompute (for persistence decision). */
+    shouldRecomputeUsageCache: (cached: CachedSessionUsage, hasPricing: boolean, hasResolvableApiCostMessage: boolean) => boolean;
+    throwOnLoadFailure?: boolean;
+};
+/**
+ * Compute day/week/month history usage by paging through session messages.
+ *
+ * This is the shared core used by both the server-side `quota_summary` tool
+ * and the TUI-local `/qday /qweek /qmonth` popup.
+ *
+ * Callers inject their own `loadMessagesPage` implementation so the function
+ * does not depend on any specific runtime context.
+ */
+export declare function computeHistoryUsage(deps: ComputeHistoryUsageDeps, period: HistoryPeriod, rawSince: string): Promise<HistoryUsageResult>;
+export {};

package/dist/history_usage.js

@@ -0,0 +1,251 @@
+import { parseSince, periodRanges, } from './period.js';
+import { mapConcurrent } from './helpers.js';
+import { accumulateMessagesAcrossCompletedRanges, accumulateMessagesInCompletedRange, emptyUsageSummary, fromCachedSessionUsage, mergeCursorFromEntries, mergeUsage, USAGE_BILLING_CACHE_VERSION, } from './usage.js';
+// ── Constants ──────────────────────────────────────────────────────────────
+const RANGE_USAGE_CONCURRENCY = 5;
+// ── Core ───────────────────────────────────────────────────────────────────
+function filterRangeSessions(sessions, startAt, endAt) {
+    return sessions.filter((session) => {
+        if (session.state.createdAt > endAt)
+            return false;
+        if (session.state.dirty === true)
+            return true;
+        const lastMessageTime = session.state.cursor?.lastMessageTime;
+        if (typeof lastMessageTime === 'number' &&
+            Number.isFinite(lastMessageTime) &&
+            lastMessageTime < startAt) {
+            return false;
+        }
+        return true;
+    });
+}
+function pageLatestTimestamp(entries) {
+    let latest = Number.NEGATIVE_INFINITY;
+    for (const entry of entries) {
+        const info = entry.info;
+        const completed = info.time?.completed;
+        if (typeof completed === 'number' && Number.isFinite(completed)) {
+            if (completed > latest)
+                latest = completed;
+            continue;
+        }
+        const created = info.time?.created;
+        if (typeof created === 'number' && Number.isFinite(created)) {
+            if (created > latest)
+                latest = created;
+        }
+    }
+    return latest;
+}
+function rangeIndexForTimestamp(ranges, timestamp) {
+    let low = 0;
+    let high = ranges.length - 1;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const range = ranges[mid];
+        if (timestamp < range.startAt) {
+            high = mid - 1;
+            continue;
+        }
+        if (timestamp >= range.endAt) {
+            low = mid + 1;
+            continue;
+        }
+        return mid;
+    }
+    return -1;
+}
+function canUseCurrentSessionCache(cached, session, ranges) {
+    if (!cached)
+        return undefined;
+    if (cached.billingVersion !== USAGE_BILLING_CACHE_VERSION)
+        return undefined;
+    if (session.state.dirty === true)
+        return undefined;
+    const lastMessageTime = session.state.cursor?.lastMessageTime;
+    if (typeof lastMessageTime !== 'number' ||
+        !Number.isFinite(lastMessageTime)) {
+        return undefined;
+    }
+    if (typeof session.state.createdAt !== 'number' ||
+        !Number.isFinite(session.state.createdAt)) {
+        return undefined;
+    }
+    const startIndex = rangeIndexForTimestamp(ranges, session.state.createdAt);
+    const endIndex = rangeIndexForTimestamp(ranges, lastMessageTime);
+    if (startIndex < 0 || endIndex < 0 || startIndex !== endIndex) {
+        return undefined;
+    }
+    return {
+        index: startIndex,
+        usage: fromCachedSessionUsage(cached, 1),
+        lastMessageTime,
+    };
+}
+/**
+ * Compute day/week/month history usage by paging through session messages.
+ *
+ * This is the shared core used by both the server-side `quota_summary` tool
+ * and the TUI-local `/qday /qweek /qmonth` popup.
+ *
+ * Callers inject their own `loadMessagesPage` implementation so the function
+ * does not depend on any specific runtime context.
+ */
+export async function computeHistoryUsage(deps, period, rawSince) {
+    const now = Date.now();
+    const since = parseSince(rawSince, now);
+    const ranges = periodRanges(period, since, now);
+    const total = emptyUsageSummary();
+    const rows = ranges.map((range) => ({
+        range,
+        usage: emptyUsageSummary(),
+    }));
+    if (ranges.length === 0) {
+        return { period, since, rows, total };
+    }
+    const startAt = ranges[0].startAt;
+    const endAt = ranges[ranges.length - 1].endAt;
+    const sessions = filterRangeSessions(deps.sessions, startAt, endAt);
+    const modelCostMap = await deps.getModelCostMap();
+    const hasPricing = Object.keys(modelCostMap).length > 0;
+    if (sessions.length > 0) {
+        const fetched = await mapConcurrent(sessions, RANGE_USAGE_CONCURRENCY, async (session) => {
+            const cachedHit = canUseCurrentSessionCache(session.state.usage, session, rows.map((row) => ({
+                startAt: row.range.startAt,
+                endAt: row.range.endAt,
+            })));
+            if (cachedHit) {
+                const rangeUsage = rows.map(() => emptyUsageSummary());
+                rangeUsage[cachedHit.index] = cachedHit.usage;
+                return {
+                    sessionID: session.sessionID,
+                    dateKey: session.dateKey,
+                    lastMessageTime: cachedHit.lastMessageTime,
+                    dirty: false,
+                    ranges: rangeUsage,
+                    totalUsage: cachedHit.usage,
+                    fullUsage: undefined,
+                    loadFailed: false,
+                    missing: false,
+                    persist: false,
+                    cursor: session.state.cursor,
+                };
+            }
+            const usageOptions = {
+                calcApiCost: (message) => deps.calcApiCost(message, modelCostMap),
+                classifyCacheMode: (message) => deps.classifyCacheMode(message, modelCostMap),
+            };
+            const rangeUsage = rows.map(() => emptyUsageSummary());
+            const totalUsage = emptyUsageSummary();
+            const trackFullUsage = deps.shouldTrackFullUsage(session.state.usage, hasPricing);
+            const fullUsage = trackFullUsage ? emptyUsageSummary() : undefined;
+            let cursor;
+            let hasResolvable = false;
+            let before;
+            while (true) {
+                const load = await deps.loadMessagesPage(session.sessionID, before);
+                if (load.status !== 'ok') {
+                    return {
+                        sessionID: session.sessionID,
+                        dateKey: session.dateKey,
+                        lastMessageTime: session.state.cursor?.lastMessageTime,
+                        dirty: session.state.dirty === true,
+                        ranges: rows.map(() => emptyUsageSummary()),
+                        totalUsage: emptyUsageSummary(),
+                        fullUsage: undefined,
+                        loadFailed: load.status === 'error',
+                        missing: load.status === 'missing',
+                        persist: false,
+                        cursor: undefined,
+                    };
+                }
+                const entries = load.entries;
+                if (entries.length === 0)
+                    break;
+                accumulateMessagesAcrossCompletedRanges(rangeUsage, entries, rows.map((row) => ({
+                    startAt: row.range.startAt,
+                    endAt: row.range.endAt,
+                })), usageOptions);
+                if (fullUsage) {
+                    accumulateMessagesInCompletedRange(fullUsage, entries, 0, Number.POSITIVE_INFINITY, usageOptions);
+                    cursor = mergeCursorFromEntries(cursor, entries);
+                }
+                if (!hasResolvable) {
+                    hasResolvable = deps.hasResolvableApiCostMessages(entries, modelCostMap);
+                }
+                // `session.messages(limit, before)` pages from newest to oldest.
+                // When we are only computing range usage (no full-session persistence),
+                // we can stop as soon as this page's newest timestamp is already older
+                // than the earliest requested range boundary.
+                if (!fullUsage) {
+                    const latestInPage = pageLatestTimestamp(entries);
+                    if (Number.isFinite(latestInPage) && latestInPage < startAt) {
+                        break;
+                    }
+                }
+                if (!load.nextBefore)
+                    break;
+                before = load.nextBefore;
+            }
+            for (const item of rangeUsage) {
+                if (item.assistantMessages > 0) {
+                    mergeUsage(totalUsage, item);
+                }
+            }
+            if (totalUsage.assistantMessages > 0) {
+                totalUsage.sessionCount = 1;
+            }
+            const shouldPersist = !!fullUsage &&
+                (!session.state.usage ||
+                    deps.shouldRecomputeUsageCache(session.state.usage, hasPricing, hasResolvable));
+            return {
+                sessionID: session.sessionID,
+                dateKey: session.dateKey,
+                lastMessageTime: cursor?.lastMessageTime,
+                dirty: session.state.dirty === true,
+                ranges: rangeUsage,
+                totalUsage,
+                fullUsage: shouldPersist ? fullUsage : undefined,
+                loadFailed: false,
+                missing: false,
+                persist: shouldPersist,
+                cursor,
+            };
+        });
+        const failedLoads = fetched.filter((item) => {
+            if (!item.loadFailed)
+                return false;
+            if (item.dirty)
+                return true;
+            const lastMessageTime = item.lastMessageTime;
+            if (typeof lastMessageTime === 'number' && lastMessageTime < startAt) {
+                return false;
+            }
+            return true;
+        });
+        if (failedLoads.length > 0 && deps.throwOnLoadFailure !== false) {
+            throw new Error(`history usage unavailable: failed to load ${failedLoads.length} session(s)`);
+        }
+        for (const item of fetched) {
+            for (let index = 0; index < rows.length; index++) {
+                if (item.ranges[index].assistantMessages > 0) {
+                    mergeUsage(rows[index].usage, item.ranges[index]);
+                }
+            }
+            if (item.totalUsage.assistantMessages > 0) {
+                mergeUsage(total, item.totalUsage);
+            }
+        }
+        return {
+            period,
+            since,
+            rows,
+            total,
+            warning: deps.throwOnLoadFailure === false && failedLoads.length > 0
+                ? `Skipped ${failedLoads.length} session(s) that could not be loaded.`
+                : undefined,
+            persistenceHints: fetched,
+        };
+    }
+    return { period, since, rows, total };
+}

package/dist/index.js

@@ -1,4 +1,4 @@
-import { renderMarkdownReport, resolveTitleView, renderSidebarTitle, renderToastMessage, } from './format.js';
+import { renderHistoryMarkdownReport, renderMarkdownReport, resolveTitleView, renderSidebarTitle, renderToastMessage, } from './format.js';
 import { createQuotaRuntime } from './quota.js';
 import { authFilePath, dateKeyFromTimestamp, deleteSessionFromDayChunk, evictOldSessions, loadConfig, loadState, normalizeTimestampMs, quotaConfigPaths, resolveOpencodeDataDir, saveState, stateFilePath, } from './storage.js';
 import { debug, swallow } from './helpers.js';
@@ -11,6 +11,7 @@ import { createPersistenceScheduler } from './persistence.js';
 import { createQuotaService } from './quota_service.js';
 import { createUsageService } from './usage_service.js';
 import { createTitleApplicator } from './title_apply.js';
+import { listCurrentProviderIDs } from './provider_catalog.js';
 const SHUTDOWN_HOOK_KEY = Symbol.for('opencode-quota-sidebar.shutdown-hook');
 const SHUTDOWN_CALLBACKS_KEY = Symbol.for('opencode-quota-sidebar.shutdown-callbacks');
 const SESSION_ACTIVE_GRACE_MS = 15_000;
@@ -45,6 +46,7 @@ export async function QuotaSidebarPlugin(input) {
         scheduleSave,
     });
     const getQuotaSnapshots = quotaService.getQuotaSnapshots;
+    const invalidateQuotaForProvider = quotaService.invalidateForProvider;
     const ensureSessionState = (sessionID, title, createdAt = Date.now(), parentID) => {
         const existing = state.sessions[sessionID];
         if (existing) {
@@ -117,7 +119,9 @@ export async function QuotaSidebarPlugin(input) {
     });
     const summarizeSessionUsageForDisplay = usageService.summarizeSessionUsageForDisplay;
     const summarizeForTool = usageService.summarizeForTool;
+    const summarizeHistoryForTool = usageService.summarizeHistoryUsage;
     const activeSessionUntil = new Map();
+    let lastTuiSessionID;
     const markSessionActive = (sessionID, now = Date.now()) => {
         activeSessionUntil.set(sessionID, now + SESSION_ACTIVE_GRACE_MS);
     };
@@ -219,6 +223,8 @@ export async function QuotaSidebarPlugin(input) {
         }
     }
     const showToast = async (period, message) => {
+        if (!input.client.tui?.showToast)
+            return;
         await input.client.tui
             .showToast({
             query: { directory: input.directory },
@@ -345,10 +351,16 @@ export async function QuotaSidebarPlugin(input) {
                 scheduleActiveTitleRefresh(session.parentID, 0);
             }
         },
-        onTuiActivity: async () => {
-            return;
+        onTuiActivity: async (sessionID) => {
+            const target = sessionID || lastTuiSessionID;
+            if (!target)
+                return;
+            lastTuiSessionID = target;
+            markSessionActive(target);
         },
         onTuiSessionSelect: async (sessionID) => {
+            lastTuiSessionID = sessionID;
+            markSessionActive(sessionID);
             scheduleActiveTitleRefresh(sessionID, 0);
         },
         onMessageRemoved: async (info) => {
@@ -360,16 +372,23 @@ export async function QuotaSidebarPlugin(input) {
             const now = Date.now();
             const completed = message.time.completed;
             if (typeof completed !== 'number' || !Number.isFinite(completed)) {
+                const created = message.time.created;
+                if (typeof created === 'number' &&
+                    Number.isFinite(created) &&
+                    created < now - SESSION_ACTIVE_GRACE_MS) {
+                    return;
+                }
                 markSessionActive(message.sessionID, now);
                 return;
             }
+            invalidateQuotaForProvider(message.providerID);
             const wasActive = isSessionActive(message.sessionID, now);
             if (!wasActive) {
                 return;
             }
             markSessionActive(message.sessionID, now);
             usageService.markSessionDirty(message.sessionID);
-            scheduleActiveTitleRefresh(message.sessionID);
+            scheduleActiveTitleRefresh(message.sessionID, 100);
             void maybeShowExpiryToast(message.sessionID);
         },
     });
@@ -399,9 +418,15 @@ export async function QuotaSidebarPlugin(input) {
             restoreSessionTitle: (sessionID) => titleApplicator.restoreSessionTitle(sessionID),
             showToast,
             summarizeForTool,
+            summarizeHistoryForTool,
+            listCurrentProviderIDs: () => listCurrentProviderIDs({
+                client: input.client,
+                directory: input.directory,
+            }),
             getQuotaSnapshots,
             renderMarkdownReport,
             renderToastMessage,
+            renderHistoryMarkdownReport,
             config: {
                 sidebar: config.sidebar,
                 sidebarEnabled: config.sidebar.enabled,

package/dist/period.d.ts

@@ -1 +1,29 @@
-export declare function periodStart(period: 'day' | 'week' | 'month'): number;
+export type HistoryPeriod = 'day' | 'week' | 'month';
+export type SincePrecision = 'month' | 'day';
+export type SinceSpec = {
+    raw: string;
+    precision: SincePrecision;
+    startAt: number;
+};
+export type PeriodRange = {
+    period: HistoryPeriod;
+    startAt: number;
+    endAt: number;
+    label: string;
+    shortLabel: string;
+    isCurrent: boolean;
+    isPartial: boolean;
+    index: number;
+};
+export declare function parseSince(raw: string, now?: number): {
+    raw: string;
+    precision: "month";
+    startAt: number;
+} | {
+    raw: string;
+    precision: "day";
+    startAt: number;
+};
+export declare function periodRanges(period: HistoryPeriod, since: SinceSpec, endAt?: number): PeriodRange[];
+export declare function periodStart(period: HistoryPeriod, now?: number): number;
+export declare function sinceFromLast(period: HistoryPeriod, last: number, now?: number): string;