@leo000001/opencode-quota-sidebar 3.0.9 → 4.0.0

package/dist/usage_service.js

@@ -3,7 +3,9 @@ import { API_COST_ENABLED_PROVIDERS, cacheCoverageModeFromRates, calcEquivalentA
 import { deleteSessionFromDayChunk, dateKeyFromTimestamp, scanAllSessions, updateSessionsInDayChunks, } from './storage.js';
 import { periodStart } from './period.js';
 import { debug, debugError, isRecord, mapConcurrent, swallow, } from './helpers.js';
-import { emptyUsageSummary, fromCachedSessionUsage, mergeUsage, summarizeMessagesInCompletedRange, summarizeMessagesIncremental, toCachedSessionUsage, USAGE_BILLING_CACHE_VERSION, } from './usage.js';
+import { accumulateMessagesInCompletedRange, emptyUsageSummary, fromCachedSessionUsage, mergeCursorFromEntries, mergeUsage, summarizeMessagesIncremental, toCachedSessionUsage, USAGE_BILLING_CACHE_VERSION, } from './usage.js';
+import { decodeMessageEntries, isMissingSessionError, nextCursorFromResponse, } from './history_messages.js';
+import { computeHistoryUsage } from './history_usage.js';
 const READ_ONLY_CACHE_PROVIDERS = new Set([
     'openai',
     'github-copilot',
@@ -135,164 +137,50 @@ export function createUsageService(deps) {
         // treat it as read-only (the safer default — avoids overstating cached ratio).
         return 'read-only';
     };
-    const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
-    const 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 },
-        };
-    };
-    const 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;
+    const loadSessionEntries = async (sessionID) => {
+        try {
+            const response = await deps.client.session.messages({
+                path: { id: sessionID },
+                query: { directory: deps.directory },
+                throwOnError: true,
+            });
+            const data = response.data;
+            const entries = decodeMessageEntries(data);
+            if (!entries)
+                return { status: 'error' };
+            return { status: 'ok', entries };
         }
-        if (value.role !== 'assistant') {
+        catch (error) {
+            debugError(`loadSessionEntries ${sessionID}`, error);
             return {
-                ...value,
-                time: {
-                    created: value.time.created,
-                    completed: value.time.completed,
-                },
+                status: isMissingSessionError(error) ? 'missing' : 'error',
             };
         }
-        if (typeof value.providerID !== 'string')
-            return undefined;
-        if (typeof value.modelID !== 'string')
-            return undefined;
-        const tokens = decodeTokens(value.tokens);
-        if (!tokens)
-            return undefined;
-        // Normalize token fields to a stable shape (some providers/SDK versions may
-        // omit reasoning/cache.write; treat them as 0).
-        return {
-            ...value,
-            time: {
-                created: value.time.created,
-                completed: value.time.completed,
-            },
-            tokens,
-        };
-    };
-    const decodeMessageEntry = (value) => {
-        if (!isRecord(value))
-            return undefined;
-        const decoded = decodeMessageInfo(value.info);
-        if (!decoded)
-            return undefined;
-        return { info: decoded };
-    };
-    const decodeMessageEntries = (value) => {
-        if (!Array.isArray(value))
-            return undefined;
-        const decoded = value
-            .map((item) => decodeMessageEntry(item))
-            .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 the API returned entries but none match the expected shape,
-        // treat it as a load failure so we don't silently undercount.
-        if (decoded.length === 0 && value.length > 0)
-            return undefined;
-        return decoded;
-    };
-    const 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));
-    };
-    const 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');
     };
-    const 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));
-    };
-    const loadSessionEntries = async (sessionID) => {
+    const MESSAGE_PAGE_LIMIT = 200;
+    const loadSessionEntriesPage = async (sessionID, before) => {
         try {
             const response = await deps.client.session.messages({
                 path: { id: sessionID },
-                query: { directory: deps.directory },
+                query: {
+                    directory: deps.directory,
+                    limit: MESSAGE_PAGE_LIMIT,
+                    ...(before ? { before } : {}),
+                },
                 throwOnError: true,
             });
             const data = response.data;
             const entries = decodeMessageEntries(data);
             if (!entries)
                 return { status: 'error' };
-            return { status: 'ok', entries };
+            return {
+                status: 'ok',
+                entries,
+                nextBefore: nextCursorFromResponse(response),
+            };
         }
         catch (error) {
-            debugError(`loadSessionEntries ${sessionID}`, error);
+            debugError(`loadSessionEntriesPage ${sessionID}`, error);
             return {
                 status: isMissingSessionError(error) ? 'missing' : 'error',
             };
@@ -349,6 +237,21 @@ export function createUsageService(deps) {
             return modelCostLookupKeys(info.providerID, info.modelID).some((key) => Boolean(modelCostMap[key]));
         });
     };
+    const shouldTrackFullUsageForRange = (cached, hasPricing) => {
+        if (!cached)
+            return true;
+        if (!isUsageBillingCurrent(cached))
+            return true;
+        if (!hasPricing)
+            return false;
+        if (cached.assistantMessages <= 0)
+            return false;
+        if (cached.apiCost > 0)
+            return false;
+        if (cached.total <= 0)
+            return false;
+        return hasAnySubscriptionProvider(cached);
+    };
     const summarizeSessionUsage = async (sessionID, generationAtStart, options) => {
         const load = await loadSessionEntries(sessionID);
         const entries = load.status === 'ok' ? load.entries : undefined;
@@ -487,69 +390,88 @@ export function createUsageService(deps) {
         return merged;
     };
     const RANGE_USAGE_CONCURRENCY = 5;
+    const 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;
+        });
+    };
     const summarizeRangeUsage = async (period) => {
-        const startAt = periodStart(period);
-        const endAt = Date.now();
+        const now = Date.now();
+        const startAt = periodStart(period, now);
+        const endAt = now;
         await deps.persistence.flushSave();
-        const sessions = await scanAllSessions(deps.statePath, deps.state);
+        const sessions = filterRangeSessions(await scanAllSessions(deps.statePath, deps.state), startAt, endAt);
         const usage = emptyUsageSummary();
         const modelCostMap = await getModelCostMap();
         const hasPricing = Object.keys(modelCostMap).length > 0;
         if (sessions.length > 0) {
             const fetched = await mapConcurrent(sessions, RANGE_USAGE_CONCURRENCY, async (session) => {
-                const load = await loadSessionEntries(session.sessionID);
-                if (load.status !== 'ok') {
-                    return {
-                        sessionID: session.sessionID,
-                        dateKey: session.dateKey,
-                        createdAt: session.state.createdAt,
-                        lastMessageTime: session.state.cursor?.lastMessageTime,
-                        dirty: session.state.dirty === true,
-                        computed: emptyUsageSummary(),
-                        fullUsage: undefined,
-                        loadFailed: load.status === 'error',
-                        missing: load.status === 'missing',
-                        persist: false,
-                        cursor: undefined,
-                    };
-                }
-                const entries = load.entries;
-                const computed = summarizeMessagesInCompletedRange(entries, startAt, endAt, 0, {
+                const usageOptions = {
                     calcApiCost: (message) => calcEquivalentApiCost(message, modelCostMap),
                     classifyCacheMode: (message) => classifyCacheMode(message, modelCostMap),
-                });
-                const shouldPersistFullUsage = !session.state.usage ||
-                    shouldRecomputeUsageCache(session.state.usage, hasPricing, hasResolvableApiCostMessages(entries, modelCostMap));
-                if (!shouldPersistFullUsage) {
-                    return {
-                        sessionID: session.sessionID,
-                        dateKey: session.dateKey,
-                        createdAt: session.state.createdAt,
-                        lastMessageTime: session.state.cursor?.lastMessageTime,
-                        dirty: session.state.dirty === true,
-                        computed,
-                        fullUsage: undefined,
-                        loadFailed: false,
-                        missing: false,
-                        persist: false,
-                        cursor: session.state.cursor,
-                    };
+                };
+                const computed = emptyUsageSummary();
+                const trackFullUsage = shouldTrackFullUsageForRange(session.state.usage, hasPricing);
+                const fullUsage = trackFullUsage ? emptyUsageSummary() : undefined;
+                let cursor;
+                let hasResolvableApiCostMessage = false;
+                let before;
+                while (true) {
+                    const load = await loadSessionEntriesPage(session.sessionID, before);
+                    if (load.status !== 'ok') {
+                        return {
+                            sessionID: session.sessionID,
+                            dateKey: session.dateKey,
+                            createdAt: session.state.createdAt,
+                            lastMessageTime: session.state.cursor?.lastMessageTime,
+                            dirty: session.state.dirty === true,
+                            computed: emptyUsageSummary(),
+                            fullUsage: undefined,
+                            loadFailed: load.status === 'error',
+                            missing: load.status === 'missing',
+                            persist: false,
+                            cursor: undefined,
+                        };
+                    }
+                    const entries = load.entries;
+                    if (entries.length === 0)
+                        break;
+                    accumulateMessagesInCompletedRange(computed, entries, startAt, endAt, usageOptions);
+                    if (fullUsage) {
+                        accumulateMessagesInCompletedRange(fullUsage, entries, 0, Number.POSITIVE_INFINITY, usageOptions);
+                        cursor = mergeCursorFromEntries(cursor, entries);
+                    }
+                    if (!hasResolvableApiCostMessage) {
+                        hasResolvableApiCostMessage = hasResolvableApiCostMessages(entries, modelCostMap);
+                    }
+                    if (!load.nextBefore)
+                        break;
+                    before = load.nextBefore;
                 }
-                const { usage: fullUsage, cursor } = summarizeMessagesIncremental(entries, undefined, undefined, true, {
-                    calcApiCost: (message) => calcEquivalentApiCost(message, modelCostMap),
-                    classifyCacheMode: (message) => classifyCacheMode(message, modelCostMap),
-                });
+                const shouldPersistFullUsage = !!fullUsage &&
+                    (!session.state.usage ||
+                        shouldRecomputeUsageCache(session.state.usage, hasPricing, hasResolvableApiCostMessage));
                 return {
                     sessionID: session.sessionID,
                     dateKey: session.dateKey,
                     createdAt: session.state.createdAt,
-                    lastMessageTime: cursor.lastMessageTime,
-                    dirty: false,
+                    lastMessageTime: cursor?.lastMessageTime,
+                    dirty: session.state.dirty === true,
                     computed,
-                    fullUsage,
+                    fullUsage: shouldPersistFullUsage ? fullUsage : undefined,
                     loadFailed: false,
                     missing: false,
-                    persist: true,
+                    persist: shouldPersistFullUsage,
                     cursor,
                 };
             });
@@ -632,6 +554,87 @@ export function createUsageService(deps) {
         }
         return usage;
     };
+    const summarizeHistoryUsage = async (period, rawSince) => {
+        await deps.persistence.flushSave();
+        const sessions = await scanAllSessions(deps.statePath, deps.state);
+        const result = await computeHistoryUsage({
+            sessions,
+            loadMessagesPage: loadSessionEntriesPage,
+            getModelCostMap: getModelCostMap,
+            calcApiCost: (message, costMap) => calcEquivalentApiCost(message, costMap),
+            classifyCacheMode: (message, costMap) => classifyCacheMode(message, costMap),
+            hasResolvableApiCostMessages: (entries, costMap) => hasResolvableApiCostMessages(entries, costMap),
+            shouldTrackFullUsage: shouldTrackFullUsageForRange,
+            shouldRecomputeUsageCache,
+            throwOnLoadFailure: true,
+        }, period, rawSince);
+        // Server-side persistence: persist recomputed full-session usage back to
+        // memory state and day chunks so future queries are faster.
+        const hints = result.persistenceHints;
+        if (hints && hints.length > 0) {
+            const missingSessions = hints.filter((item) => item.missing);
+            if (missingSessions.length > 0) {
+                let stateChanged = false;
+                for (const missing of missingSessions) {
+                    deps.state.deletedSessionDateMap[missing.sessionID] = missing.dateKey;
+                    delete deps.state.sessions[missing.sessionID];
+                    delete deps.state.sessionDateMap[missing.sessionID];
+                    deps.persistence.markDirty(missing.dateKey);
+                    forgetSession(missing.sessionID);
+                    stateChanged = true;
+                }
+                await Promise.all(missingSessions.map(async (missing) => {
+                    const deletedFromChunk = await deleteSessionFromDayChunk(deps.statePath, missing.sessionID, missing.dateKey).catch((error) => {
+                        swallow('deleteSessionFromDayChunk')(error);
+                        return false;
+                    });
+                    if (!deletedFromChunk)
+                        return;
+                    delete deps.state.deletedSessionDateMap[missing.sessionID];
+                    stateChanged = true;
+                }));
+                if (stateChanged)
+                    deps.persistence.scheduleSave();
+            }
+            let dirty = false;
+            const diskOnlyUpdates = [];
+            for (const item of hints) {
+                if (!item.persist || !item.fullUsage)
+                    continue;
+                const memoryState = deps.state.sessions[item.sessionID];
+                if (memoryState) {
+                    memoryState.usage = toCachedSessionUsage(item.fullUsage);
+                    memoryState.cursor = item.cursor;
+                    const resolvedDateKey = deps.state.sessionDateMap[item.sessionID] ||
+                        dateKeyFromTimestamp(memoryState.createdAt);
+                    deps.state.sessionDateMap[item.sessionID] = resolvedDateKey;
+                    deps.persistence.markDirty(resolvedDateKey);
+                    memoryState.dirty = false;
+                    dirty = true;
+                }
+                else {
+                    diskOnlyUpdates.push({
+                        sessionID: item.sessionID,
+                        dateKey: item.dateKey,
+                        usage: toCachedSessionUsage(item.fullUsage),
+                        cursor: item.cursor,
+                    });
+                }
+            }
+            if (diskOnlyUpdates.length > 0) {
+                const persisted = await updateSessionsInDayChunks(deps.statePath, diskOnlyUpdates).catch((error) => {
+                    swallow('updateSessionsInDayChunks')(error);
+                    return false;
+                });
+                if (!persisted) {
+                    throw new Error(`history usage unavailable: failed to persist ${diskOnlyUpdates.length} disk-only session(s)`);
+                }
+            }
+            if (dirty)
+                deps.persistence.scheduleSave();
+        }
+        return result;
+    };
     const summarizeForTool = async (period, sessionID, includeChildren) => {
         if (period === 'session') {
             if (!includeChildren) {
@@ -683,6 +686,7 @@ export function createUsageService(deps) {
     return {
         summarizeSessionUsageForDisplay,
         summarizeForTool,
+        summarizeHistoryUsage,
         markSessionDirty,
         markForceRescan,
         forgetSession,

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@leo000001/opencode-quota-sidebar",
-  "version": "3.0.9",
+  "version": "4.0.0",
   "description": "OpenCode plugin that shows quota and token usage in TUI sidebar panels and compact session titles",
   "type": "module",
   "main": "dist/index.js",
+  "bin": {
+    "opencode-quota": "./dist/cli.js"
+  },
   "types": "dist/index.d.ts",
   "exports": {
     ".": {

package/quota-sidebar.config.example.json

@@ -1,45 +1,36 @@
-{
-  "sidebar": {
-    "enabled": true,
-    "width": 36,
-    "titleMode": "auto",
-    "multilineTitle": true,
-    "showCost": true,
-    "showQuota": true,
-    "wrapQuotaLines": true,
-    "includeChildren": true,
-    "childrenMaxDepth": 6,
-    "childrenMaxSessions": 128,
-    "childrenConcurrency": 5,
-    "desktopCompact": {
-      "recentRequests": 50,
-      "recentMinutes": 60
-    }
-  },
-  "quota": {
-    "refreshMs": 300000,
-    "includeOpenAI": true,
-    "includeCopilot": true,
-    "includeAnthropic": true,
-    "providers": {
-      "rightcode": {
-        "enabled": true
-      },
-      "xyai": {
-        "enabled": false,
-        "baseURL": "https://new.xychatai.com",
-        "serviceType": "codex",
-        "login": {
-          "username": "your-account@example.com",
-          "password": "your-password"
-        }
-      }
-    },
-    "refreshAccessToken": false,
-    "requestTimeoutMs": 8000
-  },
-  "toast": {
-    "durationMs": 12000
-  },
-  "retentionDays": 730
-}
+{
+  "sidebar": {
+    "enabled": true,
+    "width": 36,
+    "titleMode": "auto",
+    "multilineTitle": true,
+    "showCost": true,
+    "showQuota": true,
+    "wrapQuotaLines": true,
+    "includeChildren": true,
+    "childrenMaxDepth": 6,
+    "childrenMaxSessions": 128,
+    "childrenConcurrency": 5,
+    "desktopCompact": {
+      "recentRequests": 50,
+      "recentMinutes": 60
+    }
+  },
+  "quota": {
+    "refreshMs": 60000,
+    "includeOpenAI": true,
+    "includeCopilot": true,
+    "includeAnthropic": true,
+    "providers": {
+      "rightcode": {
+        "enabled": true
+      }
+    },
+    "refreshAccessToken": false,
+    "requestTimeoutMs": 12000
+  },
+  "toast": {
+    "durationMs": 12000
+  },
+  "retentionDays": 730
+}

package/dist/providers/third_party/xyai.d.ts

@@ -1,2 +0,0 @@
-import type { QuotaProviderAdapter } from "../types.js";
-export declare const xyaiAdapter: QuotaProviderAdapter;