@leo000001/opencode-quota-sidebar 3.0.6 → 3.0.10

package/dist/index.js

@@ -178,6 +178,7 @@ export async function QuotaSidebarPlugin(input) {
         getQuotaSnapshots,
         summarizeSessionUsageForDisplay,
         scheduleParentRefreshIfSafe,
+        isSessionActive,
         restoreConcurrency: RESTORE_TITLE_CONCURRENCY,
     });
     const titleRefresh = createTitleRefreshScheduler({
@@ -189,30 +190,7 @@ export async function QuotaSidebarPlugin(input) {
         onError: swallow('titleRefresh'),
     });
     scheduleTitleRefresh = titleRefresh.schedule;
-    const restoreAllVisibleTitles = titleApplicator.restoreAllVisibleTitles;
-    const refreshAllTouchedTitles = titleApplicator.refreshAllTouchedTitles;
-    const refreshAllVisibleTitles = titleApplicator.refreshAllVisibleTitles;
-    let startupTitleWork = Promise.resolve();
-    const runStartupRestore = async (attempt = 0) => {
-        const result = await restoreAllVisibleTitles({
-            abortIfEnabled: config.sidebar.enabled,
-        });
-        if (result.restored === result.attempted)
-            return;
-        debug(`startup restore incomplete: restored ${result.restored}/${result.attempted} touched titles while display mode remains OFF`);
-        if (state.titleEnabled || config.sidebar.enabled === false)
-            return;
-        if (attempt >= 2)
-            return;
-        await new Promise((resolve) => setTimeout(resolve, 1_000));
-        await runStartupRestore(attempt + 1);
-    };
-    if (!state.titleEnabled || !config.sidebar.enabled) {
-        startupTitleWork = runStartupRestore().catch(swallow('startup:restoreAllVisibleTitles'));
-    }
-    else {
-        startupTitleWork = Promise.resolve();
-    }
+    const startupTitleWork = Promise.resolve();
     const shutdown = async () => {
         await Promise.race([
             startupTitleWork,
@@ -379,11 +357,17 @@ export async function QuotaSidebarPlugin(input) {
             scheduleParentRefreshIfSafe(info.sessionID, state.sessions[info.sessionID]?.parentID);
         },
         onAssistantMessageUpdated: async (message) => {
-            markSessionActive(message.sessionID);
+            const now = Date.now();
             const completed = message.time.completed;
             if (typeof completed !== 'number' || !Number.isFinite(completed)) {
+                markSessionActive(message.sessionID, now);
+                return;
+            }
+            const wasActive = isSessionActive(message.sessionID, now);
+            if (!wasActive) {
                 return;
             }
+            markSessionActive(message.sessionID, now);
             usageService.markSessionDirty(message.sessionID);
             scheduleActiveTitleRefresh(message.sessionID);
             void maybeShowExpiryToast(message.sessionID);
@@ -406,14 +390,13 @@ export async function QuotaSidebarPlugin(input) {
             scheduleSave,
             flushSave,
             waitForStartupTitleWork: () => startupTitleWork,
+            markSessionActive,
             refreshSessionTitle: (sessionID, delay) => scheduleActiveTitleRefresh(sessionID, delay ?? 250),
             cancelAllTitleRefreshes: () => titleRefresh.cancelAll(),
             flushScheduledTitleRefreshes: () => titleRefresh.flushScheduled(),
             waitForTitleRefreshIdle: () => titleRefresh.waitForIdle(),
             waitForTitleRefreshQuiescence: () => titleRefresh.waitForQuiescence(),
-            restoreAllVisibleTitles,
-            refreshAllTouchedTitles,
-            refreshAllVisibleTitles,
+            restoreSessionTitle: (sessionID) => titleApplicator.restoreSessionTitle(sessionID),
             showToast,
             summarizeForTool,
             getQuotaSnapshots,

package/dist/providers/core/openai.js

@@ -1,5 +1,60 @@
 import { debug, debugError, isRecord, swallow } from '../../helpers.js';
-import { OPENAI_OAUTH_CLIENT_ID, configuredProviderEnabled, fetchWithTimeout, normalizePercent, parseRateLimitWindow, toIso, } from '../common.js';
+import { OPENAI_OAUTH_CLIENT_ID, asNumber, configuredProviderEnabled, fetchWithTimeout, toIso, windowLabel, } from '../common.js';
+function decodeJwtPayload(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3)
+            return undefined;
+        const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf8'));
+        return isRecord(payload) ? payload : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractAccountIdFromJwt(token) {
+    const payload = decodeJwtPayload(token);
+    if (!payload)
+        return undefined;
+    const authClaim = payload['https://api.openai.com/auth'];
+    if (!isRecord(authClaim))
+        return undefined;
+    const accountID = authClaim.chatgpt_account_id;
+    return typeof accountID === 'string' && accountID ? accountID : undefined;
+}
+function normalizeOpenAIQuotaPercent(value) {
+    const numeric = asNumber(value);
+    if (numeric === undefined || Number.isNaN(numeric))
+        return undefined;
+    const expanded = numeric > 0 && numeric < 1 ? numeric * 100 : numeric;
+    if (expanded < 0)
+        return 0;
+    if (expanded > 100)
+        return 100;
+    return expanded;
+}
+function windowResetAt(win, fallback) {
+    const absolute = toIso(win.reset_at ?? fallback?.reset_at);
+    if (absolute)
+        return absolute;
+    const resetAfterSeconds = asNumber(win.reset_after_seconds) ?? asNumber(fallback?.reset_after_seconds);
+    if (resetAfterSeconds === undefined || resetAfterSeconds < 0)
+        return undefined;
+    return new Date(Date.now() + resetAfterSeconds * 1000).toISOString();
+}
+function parseOpenAIWindow(win, fallbackLabel) {
+    const usedPercent = normalizeOpenAIQuotaPercent(win.used_percent);
+    const remainingPercent = normalizeOpenAIQuotaPercent(win.remaining_percent) ??
+        (usedPercent === undefined ? undefined : 100 - usedPercent);
+    if (remainingPercent === undefined)
+        return undefined;
+    return {
+        label: windowLabel(win, fallbackLabel),
+        remainingPercent,
+        usedPercent,
+        resetAt: windowResetAt(win),
+    };
+}
 async function fetchOpenAIQuota(ctx) {
     const checkedAt = Date.now();
     const base = {
@@ -85,13 +140,15 @@ async function fetchOpenAIQuota(ctx) {
             }
         }
     }
+    const accountId = (typeof ctx.auth.accountId === 'string' && ctx.auth.accountId) ||
+        extractAccountIdFromJwt(access);
     const headers = new Headers({
         Authorization: `Bearer ${access}`,
         Accept: 'application/json',
         'User-Agent': 'opencode-quota-sidebar',
     });
-    if (typeof ctx.auth.accountId === 'string' && ctx.auth.accountId) {
-        headers.set('ChatGPT-Account-Id', ctx.auth.accountId);
+    if (accountId) {
+        headers.set('ChatGPT-Account-Id', accountId);
     }
     const response = await fetchWithTimeout('https://chatgpt.com/backend-api/wham/usage', { headers }, ctx.config.quota.requestTimeoutMs).catch(swallow('fetchOpenAIQuota:usage'));
     if (!response) {
@@ -123,18 +180,18 @@ async function fetchOpenAIQuota(ctx) {
     const primary = isRecord(rateLimit.primary_window)
         ? rateLimit.primary_window
         : {};
-    const usedPercent = normalizePercent(primary.used_percent);
-    const remainingPercent = normalizePercent(primary.remaining_percent) ??
+    const usedPercent = normalizeOpenAIQuotaPercent(primary.used_percent);
+    const remainingPercent = normalizeOpenAIQuotaPercent(primary.remaining_percent) ??
         (usedPercent === undefined ? undefined : 100 - usedPercent);
-    const resetAt = toIso(primary.reset_at ?? rateLimit.reset_at);
+    const resetAt = windowResetAt(primary, rateLimit);
     const windows = [];
     if (remainingPercent !== undefined) {
-        const primaryWin = parseRateLimitWindow(primary, '');
+        const primaryWin = parseOpenAIWindow(primary, '');
         if (primaryWin)
             windows.push(primaryWin);
     }
     if (isRecord(rateLimit.secondary_window)) {
-        const secondaryWin = parseRateLimitWindow(rateLimit.secondary_window, 'Weekly');
+        const secondaryWin = parseOpenAIWindow(rateLimit.secondary_window, 'Weekly');
         if (secondaryWin)
             windows.push(secondaryWin);
     }

package/dist/title_apply.d.ts

@@ -17,6 +17,7 @@ export declare function createTitleApplicator(deps: {
     }) => Promise<QuotaSnapshot[]>;
     summarizeSessionUsageForDisplay: (sessionID: string, includeChildren: boolean) => Promise<UsageSummary>;
     scheduleParentRefreshIfSafe: (sessionID: string, parentID?: string) => void;
+    isSessionActive?: (sessionID: string) => boolean;
     restoreConcurrency: number;
 }): {
     applyTitle: (sessionID: string) => Promise<boolean>;

package/dist/title_apply.js

@@ -28,6 +28,10 @@ export function createTitleApplicator(deps) {
     const applyTitle = async (sessionID) => {
         if (!deps.config.sidebar.enabled)
             return false;
+        if (deps.isSessionActive && !deps.isSessionActive(sessionID)) {
+            debug(`applyTitle skipped inactive session ${sessionID}`);
+            return false;
+        }
         let stateMutated = false;
         const session = await deps.client.session
             .get({

package/dist/tools.d.ts

@@ -10,26 +10,13 @@ export declare function createQuotaSidebarTools(deps: {
     scheduleSave: () => void;
     flushSave: () => Promise<void>;
     waitForStartupTitleWork: () => Promise<void>;
+    markSessionActive?: (sessionID: string) => void;
     refreshSessionTitle: (sessionID: string, delay?: number) => void;
     cancelAllTitleRefreshes: () => void;
     flushScheduledTitleRefreshes: () => Promise<void>;
     waitForTitleRefreshIdle: () => Promise<void>;
     waitForTitleRefreshQuiescence: () => Promise<void>;
-    restoreAllVisibleTitles: () => Promise<{
-        attempted: number;
-        restored: number;
-        listFailed: boolean;
-    }>;
-    refreshAllTouchedTitles: () => Promise<{
-        attempted: number;
-        refreshed: number;
-        listFailed: boolean;
-    }>;
-    refreshAllVisibleTitles: () => Promise<{
-        attempted: number;
-        refreshed: number;
-        listFailed: boolean;
-    }>;
+    restoreSessionTitle?: (sessionID: string) => Promise<boolean>;
     showToast: (period: 'session' | 'day' | 'week' | 'month' | 'toggle', message: string) => Promise<void>;
     summarizeForTool: (period: 'session' | 'day' | 'week' | 'month', sessionID: string, includeChildren: boolean) => Promise<UsageSummary>;
     getQuotaSnapshots: (providerIDs: string[], options?: {

package/dist/tools.js

@@ -63,11 +63,13 @@ export function createQuotaSidebarTools(deps) {
                         deps.setTitleEnabled(true);
                         deps.scheduleSave();
                         await deps.flushSave();
+                        deps.markSessionActive?.(context.sessionID);
                         deps.refreshSessionTitle(context.sessionID, 0);
                         if (startupTimedOut) {
                             void deps.waitForStartupTitleWork().then(() => {
                                 if (!deps.getTitleEnabled())
                                     return;
+                                deps.markSessionActive?.(context.sessionID);
                                 deps.refreshSessionTitle(context.sessionID, 0);
                             });
                         }
@@ -79,14 +81,17 @@ export function createQuotaSidebarTools(deps) {
                     await deps.flushSave();
                     deps.cancelAllTitleRefreshes();
                     await deps.waitForTitleRefreshQuiescence();
-                    const restore = await deps.restoreAllVisibleTitles();
-                    if (restore.restored === restore.attempted) {
+                    const restoredCurrent = await (deps.restoreSessionTitle
+                        ? deps.restoreSessionTitle(context.sessionID)
+                        : Promise.resolve(false));
+                    if (restoredCurrent) {
                         await deps.showToast('toggle', 'Sidebar usage display: OFF');
-                        return 'Sidebar usage display is now OFF. Touched session titles were restored to base titles.';
+                        return 'Sidebar usage display is now OFF. The current session title was restored to its base title.';
                     }
                     deps.setTitleEnabled(true);
                     deps.scheduleSave();
                     await deps.flushSave();
+                    deps.markSessionActive?.(context.sessionID);
                     deps.refreshSessionTitle(context.sessionID, 0);
                     await deps.showToast('toggle', 'Sidebar usage display: OFF failed');
                     return 'Sidebar usage display remains ON because some touched session titles could not be restored. Try again after the session service recovers.';

package/package.json

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