@leo000001/opencode-quota-sidebar 2.0.6 → 2.0.8

package/dist/title.js

@@ -28,6 +28,20 @@ function isCoreDecoratedDetail(line) {
     }
     return false;
 }
+function isQuotaDecoratedDetail(line) {
+    if (!line)
+        return false;
+    if (/^(OpenAI|Copilot|Anthropic|Kimi|XYAI|Buzz|RC(?:-[^\s]+)?)\s*$/.test(line)) {
+        return true;
+    }
+    if (/^(?:(?:Daily\s+\$[\d.,]+\/\$[\d.,]+|\$[\d.,]+\/\$[\d.,]+)(?:\s+(?:Rst|Exp\+?)\s+[-:\d]+)?|(?:\d+[hdw]|Weekly|Monthly)\s+\d{1,3}%(?:\s+Rst\s+[-:\d]+)?|Balance\s+\$[\d.,]+|Remaining\s+\?|(?:error|unsupported|unavailable))$/.test(line)) {
+        return true;
+    }
+    if (/^(OpenAI|Copilot|Anthropic|Kimi|XYAI|Buzz|RC(?:-[^\s]+)?)(?:\s+(?:(?:Daily\s+\$[\d.,]+\/\$[\d.,]+|\$[\d.,]+\/\$[\d.,]+)(?:\s+(?:Rst|Exp\+?)\s+[-:\d]+)?|(?:\d+[hdw]|Weekly|Monthly)\s+\d{1,3}%(?:\s+Rst\s+[-:\d]+)?|(?:error|unsupported|unavailable)))$/.test(line)) {
+        return true;
+    }
+    return false;
+}
 function isSingleLineDecoratedPrefix(line) {
     if (!line)
         return false;
@@ -47,7 +61,9 @@ function isSingleLineDecoratedPrefix(line) {
     return false;
 }
 function isSingleLineDetailPrefix(line) {
-    return isCoreDecoratedDetail(line) || isSingleLineDecoratedPrefix(line);
+    return (isCoreDecoratedDetail(line) ||
+        isSingleLineDecoratedPrefix(line) ||
+        isQuotaDecoratedDetail(line));
 }
 function decoratedSingleLineBase(line) {
     const parts = sanitizeTitleFragment(line)
@@ -72,7 +88,7 @@ export function normalizeBaseTitle(title) {
     const lines = stripAnsi(safeTitle).split(/\r?\n/);
     if (lines.length > 1) {
         const detail = lines.slice(1).map((line) => sanitizeTitleFragment(line).trim());
-        if (detail.some((line) => isCoreDecoratedDetail(line))) {
+        if (detail.some((line) => isCoreDecoratedDetail(line) || isQuotaDecoratedDetail(line))) {
             return sanitizeTitleFragment(firstLine) || 'Session';
         }
     }
@@ -122,5 +138,5 @@ export function looksDecorated(title) {
     const detail = lines
         .slice(1)
         .map((line) => sanitizeTitleFragment(line).trim());
-    return detail.some((line) => isCoreDecoratedDetail(line));
+    return detail.some((line) => isCoreDecoratedDetail(line) || isQuotaDecoratedDetail(line));
 }

package/dist/title_apply.js

@@ -33,6 +33,13 @@ export function createTitleApplicator(deps) {
         if (canonicalizeTitle(currentTitle) !==
             canonicalizeTitle(sessionState.lastAppliedTitle || '')) {
             if (looksDecorated(currentTitle)) {
+                if (/\r?\n/.test(currentTitle)) {
+                    const normalizedBase = normalizeBaseTitle(currentTitle);
+                    if (sessionState.baseTitle !== normalizedBase) {
+                        sessionState.baseTitle = normalizedBase;
+                        stateMutated = true;
+                    }
+                }
                 // Ignore decorated echoes as base-title source.
                 // If we previously applied a decorated title, treat this as an
                 // equivalent echo (OpenCode may normalize whitespace) and keep

package/dist/usage_service.js

@@ -1,8 +1,8 @@
 import { TtlValueCache } from './cache.js';
 import { cacheCoverageModeFromRates, calcEquivalentApiCostForMessage, canonicalApiCostProviderID, modelCostKey, parseModelCostRates, SUBSCRIPTION_API_COST_PROVIDERS, } from './cost.js';
-import { dateKeyFromTimestamp, scanAllSessions, updateSessionsInDayChunks, } from './storage.js';
+import { deleteSessionFromDayChunk, dateKeyFromTimestamp, scanAllSessions, updateSessionsInDayChunks, } from './storage.js';
 import { periodStart } from './period.js';
-import { debug, isRecord, mapConcurrent, swallow } from './helpers.js';
+import { debug, debugError, isRecord, mapConcurrent, swallow, } from './helpers.js';
 import { emptyUsageSummary, fromCachedSessionUsage, mergeUsage, summarizeMessagesInCompletedRange, summarizeMessagesIncremental, toCachedSessionUsage, USAGE_BILLING_CACHE_VERSION, } from './usage.js';
 const READ_ONLY_CACHE_PROVIDERS = new Set([
     'openai',
@@ -218,18 +218,81 @@ export function createUsageService(deps) {
             return undefined;
         return decoded;
     };
-    const loadSessionEntries = async (sessionID) => {
-        const response = await deps.client.session
-            .messages({
-            path: { id: sessionID },
-            query: { directory: deps.directory },
-            throwOnError: true,
-        })
-            .catch(swallow('loadSessionEntries'));
-        if (!response)
+    const errorStatusCode = (value, seen = new Set()) => {
+        if (!isRecord(value) || seen.has(value))
             return undefined;
-        const data = response.data;
-        return decodeMessageEntries(data);
+        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) => {
+        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 };
+        }
+        catch (error) {
+            debugError(`loadSessionEntries ${sessionID}`, error);
+            return {
+                status: isMissingSessionError(error) ? 'missing' : 'error',
+            };
+        }
     };
     const persistSessionUsage = (sessionID, usage) => {
         const sessionState = deps.state.sessions[sessionID];
@@ -262,7 +325,8 @@ export function createUsageService(deps) {
         });
     };
     const summarizeSessionUsage = async (sessionID, generationAtStart, options) => {
-        const entries = await loadSessionEntries(sessionID);
+        const load = await loadSessionEntries(sessionID);
+        const entries = load.status === 'ok' ? load.entries : undefined;
         const sessionState = deps.state.sessions[sessionID];
         // If we can't load messages (transient API failure), fall back to cached
         // usage if available and avoid mutating cursor/dirty state.
@@ -426,8 +490,8 @@ export function createUsageService(deps) {
         };
         if (sessions.length > 0) {
             const fetched = await mapConcurrent(sessions, RANGE_USAGE_CONCURRENCY, async (session) => {
-                const entries = await loadSessionEntries(session.sessionID);
-                if (!entries) {
+                const load = await loadSessionEntries(session.sessionID);
+                if (load.status !== 'ok') {
                     return {
                         sessionID: session.sessionID,
                         dateKey: session.dateKey,
@@ -436,16 +500,19 @@ export function createUsageService(deps) {
                         dirty: session.state.dirty === true,
                         computed: emptyUsageSummary(),
                         fullUsage: undefined,
-                        loadFailed: true,
+                        loadFailed: load.status === 'error',
+                        missing: load.status === 'missing',
                         persist: false,
                         cursor: undefined,
                     };
                 }
+                const entries = load.entries;
                 const computed = summarizeMessagesInCompletedRange(entries, startAt, endAt, 0, {
                     calcApiCost: (message) => calcEquivalentApiCost(message, modelCostMap),
                     classifyCacheMode: (message) => classifyCacheMode(message, modelCostMap),
                 });
-                const shouldPersistFullUsage = !session.state.usage || shouldRecomputeUsageCache(session.state.usage);
+                const shouldPersistFullUsage = !session.state.usage ||
+                    shouldRecomputeUsageCache(session.state.usage);
                 if (!shouldPersistFullUsage) {
                     return {
                         sessionID: session.sessionID,
@@ -456,6 +523,7 @@ export function createUsageService(deps) {
                         computed,
                         fullUsage: undefined,
                         loadFailed: false,
+                        missing: false,
                         persist: false,
                         cursor: session.state.cursor,
                     };
@@ -473,10 +541,35 @@ export function createUsageService(deps) {
                     computed,
                     fullUsage,
                     loadFailed: false,
+                    missing: false,
                     persist: true,
                     cursor,
                 };
             });
+            const missingSessions = fetched.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();
+            }
             const failedLoads = fetched.filter((item) => {
                 if (!item.loadFailed)
                     return false;
@@ -493,7 +586,7 @@ export function createUsageService(deps) {
             }
             let dirty = false;
             const diskOnlyUpdates = [];
-            for (const { sessionID, dateKey, computed, fullUsage, persist, cursor } of fetched) {
+            for (const { sessionID, dateKey, computed, fullUsage, persist, cursor, } of fetched) {
                 if (computed.assistantMessages > 0) {
                     computed.sessionCount = 1;
                     mergeUsage(usage, computed);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leo000001/opencode-quota-sidebar",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "description": "OpenCode plugin that shows quota and token usage in session titles",
   "type": "module",
   "main": "dist/index.js",