@leo000001/opencode-quota-sidebar 1.0.0

package/dist/storage_parse.js

@@ -0,0 +1,149 @@
+import { asNumber, isRecord } from './helpers.js';
+function parseSessionTitleState(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (typeof value.baseTitle !== 'string')
+        return undefined;
+    if (value.lastAppliedTitle !== undefined &&
+        typeof value.lastAppliedTitle !== 'string') {
+        return undefined;
+    }
+    return {
+        baseTitle: value.baseTitle,
+        lastAppliedTitle: value.lastAppliedTitle,
+    };
+}
+function parseProviderUsage(value) {
+    if (!isRecord(value))
+        return undefined;
+    return {
+        input: asNumber(value.input, 0),
+        output: asNumber(value.output, 0),
+        reasoning: asNumber(value.reasoning, 0),
+        cacheRead: asNumber(value.cacheRead, 0),
+        cacheWrite: asNumber(value.cacheWrite, 0),
+        total: asNumber(value.total, 0),
+        cost: asNumber(value.cost, 0),
+        apiCost: asNumber(value.apiCost, 0),
+        assistantMessages: asNumber(value.assistantMessages, 0),
+    };
+}
+function parseCachedUsage(value) {
+    if (!isRecord(value))
+        return undefined;
+    const providersRaw = isRecord(value.providers) ? value.providers : {};
+    const providers = Object.entries(providersRaw).reduce((acc, [providerID, providerUsage]) => {
+        const parsed = parseProviderUsage(providerUsage);
+        if (!parsed)
+            return acc;
+        acc[providerID] = parsed;
+        return acc;
+    }, {});
+    return {
+        input: asNumber(value.input, 0),
+        output: asNumber(value.output, 0),
+        reasoning: asNumber(value.reasoning, 0),
+        cacheRead: asNumber(value.cacheRead, 0),
+        cacheWrite: asNumber(value.cacheWrite, 0),
+        total: asNumber(value.total, 0),
+        cost: asNumber(value.cost, 0),
+        apiCost: asNumber(value.apiCost, 0),
+        assistantMessages: asNumber(value.assistantMessages, 0),
+        providers,
+    };
+}
+function parseCursor(value) {
+    if (!isRecord(value))
+        return undefined;
+    return {
+        lastMessageId: typeof value.lastMessageId === 'string' ? value.lastMessageId : undefined,
+        lastMessageTime: asNumber(value.lastMessageTime),
+    };
+}
+export function parseSessionState(value) {
+    if (!isRecord(value))
+        return undefined;
+    const title = parseSessionTitleState(value);
+    if (!title)
+        return undefined;
+    const createdAt = asNumber(value.createdAt, 0);
+    if (!createdAt)
+        return undefined;
+    return {
+        ...title,
+        createdAt,
+        usage: parseCachedUsage(value.usage),
+        cursor: parseCursor(value.cursor),
+    };
+}
+export function parseSessionTitleForMigration(value) {
+    return parseSessionTitleState(value);
+}
+export function parseQuotaCache(value) {
+    const raw = isRecord(value) ? value : {};
+    return Object.entries(raw).reduce((acc, [key, item]) => {
+        if (!isRecord(item))
+            return acc;
+        const checkedAt = asNumber(item.checkedAt, 0);
+        if (!checkedAt)
+            return acc;
+        const status = item.status;
+        if (status !== 'ok' &&
+            status !== 'unavailable' &&
+            status !== 'unsupported' &&
+            status !== 'error') {
+            return acc;
+        }
+        const label = typeof item.label === 'string' ? item.label : key;
+        const adapterID = typeof item.adapterID === 'string' ? item.adapterID : undefined;
+        const shortLabel = typeof item.shortLabel === 'string' ? item.shortLabel : undefined;
+        const sortOrder = typeof item.sortOrder === 'number' ? item.sortOrder : undefined;
+        const balance = isRecord(item.balance)
+            ? {
+                amount: typeof item.balance.amount === 'number' ? item.balance.amount : 0,
+                currency: typeof item.balance.currency === 'string'
+                    ? item.balance.currency
+                    : '$',
+            }
+            : undefined;
+        const windows = Array.isArray(item.windows)
+            ? item.windows
+                .filter((window) => isRecord(window))
+                .map((window) => ({
+                label: typeof window.label === 'string' ? window.label : '',
+                showPercent: typeof window.showPercent === 'boolean'
+                    ? window.showPercent
+                    : undefined,
+                resetLabel: typeof window.resetLabel === 'string'
+                    ? window.resetLabel
+                    : undefined,
+                remainingPercent: typeof window.remainingPercent === 'number'
+                    ? window.remainingPercent
+                    : undefined,
+                usedPercent: typeof window.usedPercent === 'number'
+                    ? window.usedPercent
+                    : undefined,
+                resetAt: typeof window.resetAt === 'string' ? window.resetAt : undefined,
+            }))
+                .filter((window) => window.label || window.remainingPercent !== undefined)
+            : undefined;
+        acc[key] = {
+            providerID: typeof item.providerID === 'string' ? item.providerID : key,
+            adapterID,
+            label,
+            shortLabel,
+            sortOrder,
+            status,
+            checkedAt,
+            remainingPercent: typeof item.remainingPercent === 'number'
+                ? item.remainingPercent
+                : undefined,
+            usedPercent: typeof item.usedPercent === 'number' ? item.usedPercent : undefined,
+            resetAt: typeof item.resetAt === 'string' ? item.resetAt : undefined,
+            balance,
+            note: typeof item.note === 'string' ? item.note : undefined,
+            windows,
+        };
+        return acc;
+    }, {});
+}

package/dist/storage_paths.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Resolve the OpenCode data directory.
+ *
+ * OpenCode uses `xdg-basedir@5.1.0` which has NO platform-specific logic:
+ *   xdgData = $XDG_DATA_HOME || $HOME/.local/share
+ * This applies on all platforms including Windows and macOS.
+ *
+ * S4 fix: renamed env var from OPENCODE_TEST_HOME to OPENCODE_QUOTA_DATA_HOME.
+ */
+export declare function resolveOpencodeDataDir(): string;
+export declare function stateFilePath(dataDir: string): string;
+export declare function authFilePath(dataDir: string): string;
+export declare function chunkRootPathFromStateFile(statePath: string): string;
+export declare function chunkFilePath(rootPath: string, dateKey: string): string;

package/dist/storage_paths.js

@@ -0,0 +1,31 @@
+import os from 'node:os';
+import path from 'node:path';
+/**
+ * Resolve the OpenCode data directory.
+ *
+ * OpenCode uses `xdg-basedir@5.1.0` which has NO platform-specific logic:
+ *   xdgData = $XDG_DATA_HOME || $HOME/.local/share
+ * This applies on all platforms including Windows and macOS.
+ *
+ * S4 fix: renamed env var from OPENCODE_TEST_HOME to OPENCODE_QUOTA_DATA_HOME.
+ */
+export function resolveOpencodeDataDir() {
+    const home = process.env.OPENCODE_QUOTA_DATA_HOME || os.homedir();
+    const xdg = process.env.XDG_DATA_HOME;
+    if (xdg)
+        return path.join(xdg, 'opencode');
+    return path.join(home, '.local', 'share', 'opencode');
+}
+export function stateFilePath(dataDir) {
+    return path.join(dataDir, 'quota-sidebar.state.json');
+}
+export function authFilePath(dataDir) {
+    return path.join(dataDir, 'auth.json');
+}
+export function chunkRootPathFromStateFile(statePath) {
+    return path.join(path.dirname(statePath), 'quota-sidebar-sessions');
+}
+export function chunkFilePath(rootPath, dateKey) {
+    const [year, month, day] = dateKey.split('-');
+    return path.join(rootPath, year, month, `${day}.json`);
+}

package/dist/title.d.ts

@@ -0,0 +1,8 @@
+export declare function normalizeBaseTitle(title: string): string;
+export declare function stripAnsi(value: string): string;
+export declare function canonicalizeTitle(value: string): string;
+/**
+ * Detect whether a title already contains our decoration.
+ * Current layout has token/quota lines after base title line.
+ */
+export declare function looksDecorated(title: string): boolean;

package/dist/title.js

@@ -0,0 +1,38 @@
+export function normalizeBaseTitle(title) {
+    return stripAnsi(title).split(/\r?\n/, 1)[0] || 'Session';
+}
+export function stripAnsi(value) {
+    return value.replace(/\u001b\[[0-9;]*m/g, '');
+}
+export function canonicalizeTitle(value) {
+    return stripAnsi(value)
+        .split(/\r?\n/)
+        .map((line) => line.trimEnd())
+        .join('\n');
+}
+/**
+ * Detect whether a title already contains our decoration.
+ * Current layout has token/quota lines after base title line.
+ */
+export function looksDecorated(title) {
+    const lines = stripAnsi(title).split(/\r?\n/);
+    if (lines.length < 2)
+        return false;
+    const detail = lines.slice(1).map((line) => line.trim());
+    return detail.some((line) => {
+        if (!line)
+            return false;
+        if (/^Input\s+\S+\s+Output\s+\S+/.test(line))
+            return true;
+        if (/^Cache\s+(Read|Write)\s+\S+/.test(line))
+            return true;
+        if (/^\$\S+\s+as API cost/.test(line))
+            return true;
+        // Backward compatibility: old plugin versions had a separate Reasoning line.
+        if (/^Reasoning\s+\S+/.test(line))
+            return true;
+        if (/^(OpenAI|Copilot|Anthropic|RightCode|RC)\b/.test(line))
+            return true;
+        return false;
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,116 @@
+export type QuotaStatus = 'ok' | 'unavailable' | 'unsupported' | 'error';
+export type QuotaWindow = {
+    label: string;
+    /** Set false when this window line should not render a trailing percentage. */
+    showPercent?: boolean;
+    /** Prefix for reset/expiry time text in sidebar (default: Rst). */
+    resetLabel?: string;
+    remainingPercent?: number;
+    usedPercent?: number;
+    resetAt?: string;
+};
+export type QuotaSnapshot = {
+    providerID: string;
+    /** Adapter ID that produced this snapshot (e.g. openai, rightcode). */
+    adapterID?: string;
+    label: string;
+    /** Short sidebar label (e.g. OpenAI, Copilot, RC). */
+    shortLabel?: string;
+    /** Sort priority: smaller values appear first. */
+    sortOrder?: number;
+    status: QuotaStatus;
+    checkedAt: number;
+    remainingPercent?: number;
+    usedPercent?: number;
+    resetAt?: string;
+    /** Balance-style quota (for providers that expose balance instead of percent). */
+    balance?: {
+        amount: number;
+        currency: string;
+    };
+    note?: string;
+    /** Multi-window quota (e.g. OpenAI short-term + weekly). */
+    windows?: QuotaWindow[];
+};
+export type SessionTitleState = {
+    baseTitle: string;
+    lastAppliedTitle?: string;
+};
+export type CachedProviderUsage = {
+    input: number;
+    output: number;
+    reasoning: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+    cost: number;
+    /** Equivalent API billing cost (USD) computed from model pricing. */
+    apiCost: number;
+    assistantMessages: number;
+};
+export type CachedSessionUsage = {
+    input: number;
+    output: number;
+    reasoning: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+    cost: number;
+    /** Equivalent API billing cost (USD) computed from model pricing. */
+    apiCost: number;
+    assistantMessages: number;
+    providers: Record<string, CachedProviderUsage>;
+};
+/** Tracks incremental aggregation cursor for a session (P1). */
+export type IncrementalCursor = {
+    /** ID of the last processed assistant message. */
+    lastMessageId?: string;
+    /** Timestamp of the last processed assistant message. */
+    lastMessageTime?: number;
+};
+export type SessionState = SessionTitleState & {
+    createdAt: number;
+    usage?: CachedSessionUsage;
+    /** Incremental aggregation cursor (P1). */
+    cursor?: IncrementalCursor;
+};
+export type SessionDayChunk = {
+    version: 1;
+    dateKey: string;
+    sessions: Record<string, SessionState>;
+};
+export type QuotaSidebarState = {
+    version: 2;
+    /** Global toggle — when false, sidebar titles are not modified */
+    titleEnabled: boolean;
+    sessionDateMap: Record<string, string>;
+    sessions: Record<string, SessionState>;
+    quotaCache: Record<string, QuotaSnapshot>;
+};
+export type QuotaSidebarConfig = {
+    sidebar: {
+        enabled: boolean;
+        width: number;
+        showCost: boolean;
+        showQuota: boolean;
+    };
+    quota: {
+        refreshMs: number;
+        includeOpenAI: boolean;
+        includeCopilot: boolean;
+        includeAnthropic: boolean;
+        /** Generic per-adapter switches (e.g. rightcode). */
+        providers?: Record<string, {
+            enabled?: boolean;
+        }>;
+        /** When true, refreshes OpenAI OAuth access token using refresh token */
+        refreshAccessToken: boolean;
+        /** Timeout for external quota fetches */
+        requestTimeoutMs: number;
+    };
+    toast: {
+        durationMs: number;
+    };
+    /** Session retention in days. Sessions older than this are evicted from memory (M2). */
+    retentionDays: number;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/usage.d.ts

@@ -0,0 +1,51 @@
+import type { AssistantMessage, Message } from '@opencode-ai/sdk';
+import type { CachedSessionUsage, IncrementalCursor } from './types.js';
+export type ProviderUsage = {
+    providerID: string;
+    input: number;
+    output: number;
+    /** Legacy field kept for cache compatibility; display merges into output. */
+    reasoning: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+    cost: number;
+    apiCost: number;
+    assistantMessages: number;
+};
+export type UsageSummary = {
+    input: number;
+    output: number;
+    /** Legacy field kept for cache compatibility; display merges into output. */
+    reasoning: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+    cost: number;
+    apiCost: number;
+    assistantMessages: number;
+    sessionCount: number;
+    providers: Record<string, ProviderUsage>;
+};
+export type UsageOptions = {
+    /** Equivalent API cost calculator for the message. */
+    calcApiCost?: (message: AssistantMessage) => number;
+};
+export declare function emptyUsageSummary(): UsageSummary;
+export declare function summarizeMessages(entries: Array<{
+    info: Message;
+}>, startAt?: number, sessionCount?: number, options?: UsageOptions): UsageSummary;
+/**
+ * P1: Incremental usage aggregation.
+ * Only processes messages newer than the cursor. Returns updated cursor.
+ * If `forceRescan` is true (e.g. after message.removed), does a full rescan.
+ */
+export declare function summarizeMessagesIncremental(entries: Array<{
+    info: Message;
+}>, existingUsage: CachedSessionUsage | undefined, cursor: IncrementalCursor | undefined, forceRescan: boolean, options?: UsageOptions): {
+    usage: UsageSummary;
+    cursor: IncrementalCursor;
+};
+export declare function mergeUsage(target: UsageSummary, source: UsageSummary): UsageSummary;
+export declare function toCachedSessionUsage(summary: UsageSummary): CachedSessionUsage;
+export declare function fromCachedSessionUsage(cached: CachedSessionUsage, sessionCount?: number): UsageSummary;

package/dist/usage.js

@@ -0,0 +1,243 @@
+export function emptyUsageSummary() {
+    return {
+        input: 0,
+        output: 0,
+        reasoning: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        total: 0,
+        cost: 0,
+        apiCost: 0,
+        assistantMessages: 0,
+        sessionCount: 0,
+        providers: {},
+    };
+}
+function isAssistant(message) {
+    return message.role === 'assistant';
+}
+function tokenTotal(message) {
+    return (message.tokens.input +
+        message.tokens.output +
+        message.tokens.reasoning +
+        message.tokens.cache.read +
+        message.tokens.cache.write);
+}
+function mergedOutput(message) {
+    // Reasoning is counted into output to keep one output statistic.
+    return message.tokens.output + message.tokens.reasoning;
+}
+function addMessageUsage(target, message, options) {
+    const total = tokenTotal(message);
+    const output = mergedOutput(message);
+    const cost = typeof message.cost === 'number' && Number.isFinite(message.cost)
+        ? message.cost
+        : 0;
+    const apiCostRaw = options?.calcApiCost ? options.calcApiCost(message) : 0;
+    const apiCost = Number.isFinite(apiCostRaw) && apiCostRaw > 0 ? apiCostRaw : 0;
+    target.input += message.tokens.input;
+    target.output += output;
+    target.cacheRead += message.tokens.cache.read;
+    target.cacheWrite += message.tokens.cache.write;
+    target.total += total;
+    target.assistantMessages += 1;
+    target.cost += cost;
+    target.apiCost += apiCost;
+    const provider = target.providers[message.providerID] ||
+        {
+            providerID: message.providerID,
+            input: 0,
+            output: 0,
+            reasoning: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            total: 0,
+            cost: 0,
+            apiCost: 0,
+            assistantMessages: 0,
+        };
+    provider.input += message.tokens.input;
+    provider.output += output;
+    provider.cacheRead += message.tokens.cache.read;
+    provider.cacheWrite += message.tokens.cache.write;
+    provider.total += total;
+    provider.cost += cost;
+    provider.apiCost += apiCost;
+    provider.assistantMessages += 1;
+    target.providers[message.providerID] = provider;
+}
+export function summarizeMessages(entries, startAt = 0, sessionCount = 1, options) {
+    const summary = emptyUsageSummary();
+    summary.sessionCount = sessionCount;
+    for (const entry of entries) {
+        if (!isAssistant(entry.info))
+            continue;
+        if (!entry.info.time.completed)
+            continue;
+        if (entry.info.time.created < startAt)
+            continue;
+        addMessageUsage(summary, entry.info, options);
+    }
+    return summary;
+}
+/**
+ * P1: Incremental usage aggregation.
+ * Only processes messages newer than the cursor. Returns updated cursor.
+ * If `forceRescan` is true (e.g. after message.removed), does a full rescan.
+ */
+export function summarizeMessagesIncremental(entries, existingUsage, cursor, forceRescan, options) {
+    // If no cursor or force rescan, do full scan
+    if (forceRescan || !cursor?.lastMessageId || !existingUsage) {
+        const usage = summarizeMessages(entries, 0, 1, options);
+        const lastMsg = findLastCompletedAssistant(entries);
+        return {
+            usage,
+            cursor: {
+                lastMessageId: lastMsg?.id,
+                lastMessageTime: lastMsg?.time.completed ?? undefined,
+            },
+        };
+    }
+    // Incremental: start from existing usage, only process new messages
+    const summary = fromCachedSessionUsage(existingUsage, 1);
+    let foundCursor = false;
+    let newCursor = { ...cursor };
+    for (const entry of entries) {
+        if (!isAssistant(entry.info))
+            continue;
+        if (!entry.info.time.completed)
+            continue;
+        // Skip messages we've already processed
+        if (!foundCursor) {
+            if (entry.info.id === cursor.lastMessageId) {
+                foundCursor = true;
+            }
+            continue;
+        }
+        // Process new message
+        addMessageUsage(summary, entry.info, options);
+        newCursor = {
+            lastMessageId: entry.info.id,
+            lastMessageTime: entry.info.time.completed ?? undefined,
+        };
+    }
+    // If we never found the cursor message, the history may have been modified.
+    // Fall back to full rescan.
+    if (!foundCursor) {
+        const usage = summarizeMessages(entries, 0, 1, options);
+        const lastMsg = findLastCompletedAssistant(entries);
+        return {
+            usage,
+            cursor: {
+                lastMessageId: lastMsg?.id,
+                lastMessageTime: lastMsg?.time.completed ?? undefined,
+            },
+        };
+    }
+    return { usage: summary, cursor: newCursor };
+}
+function findLastCompletedAssistant(entries) {
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const msg = entries[i].info;
+        if (isAssistant(msg) && msg.time.completed)
+            return msg;
+    }
+    return undefined;
+}
+export function mergeUsage(target, source) {
+    target.input += source.input;
+    target.output += source.output;
+    target.cacheRead += source.cacheRead;
+    target.cacheWrite += source.cacheWrite;
+    target.total += source.total;
+    target.cost += source.cost;
+    target.apiCost += source.apiCost;
+    target.assistantMessages += source.assistantMessages;
+    target.sessionCount += source.sessionCount;
+    for (const provider of Object.values(source.providers)) {
+        const existing = target.providers[provider.providerID] ||
+            {
+                providerID: provider.providerID,
+                input: 0,
+                output: 0,
+                reasoning: 0,
+                cacheRead: 0,
+                cacheWrite: 0,
+                total: 0,
+                cost: 0,
+                apiCost: 0,
+                assistantMessages: 0,
+            };
+        existing.input += provider.input;
+        existing.output += provider.output;
+        existing.cacheRead += provider.cacheRead;
+        existing.cacheWrite += provider.cacheWrite;
+        existing.total += provider.total;
+        existing.cost += provider.cost;
+        existing.apiCost += provider.apiCost;
+        existing.assistantMessages += provider.assistantMessages;
+        target.providers[provider.providerID] = existing;
+    }
+    return target;
+}
+export function toCachedSessionUsage(summary) {
+    const providers = Object.entries(summary.providers).reduce((acc, [providerID, provider]) => {
+        acc[providerID] = {
+            input: provider.input,
+            output: provider.output,
+            // Legacy persisted field for backward compatibility with old chunks.
+            reasoning: provider.reasoning,
+            cacheRead: provider.cacheRead,
+            cacheWrite: provider.cacheWrite,
+            total: provider.total,
+            cost: provider.cost,
+            apiCost: provider.apiCost,
+            assistantMessages: provider.assistantMessages,
+        };
+        return acc;
+    }, {});
+    return {
+        input: summary.input,
+        output: summary.output,
+        // Legacy persisted field for backward compatibility with old chunks.
+        reasoning: summary.reasoning,
+        cacheRead: summary.cacheRead,
+        cacheWrite: summary.cacheWrite,
+        total: summary.total,
+        cost: summary.cost,
+        apiCost: summary.apiCost,
+        assistantMessages: summary.assistantMessages,
+        providers,
+    };
+}
+export function fromCachedSessionUsage(cached, sessionCount = 1) {
+    // Merge legacy cached reasoning into output for a single output metric.
+    const mergedOutputValue = cached.output + cached.reasoning;
+    return {
+        input: cached.input,
+        output: mergedOutputValue,
+        reasoning: 0,
+        cacheRead: cached.cacheRead,
+        cacheWrite: cached.cacheWrite,
+        total: cached.total,
+        cost: cached.cost,
+        apiCost: cached.apiCost || 0,
+        assistantMessages: cached.assistantMessages,
+        sessionCount,
+        providers: Object.entries(cached.providers).reduce((acc, [providerID, provider]) => {
+            acc[providerID] = {
+                providerID,
+                input: provider.input,
+                output: provider.output + provider.reasoning,
+                reasoning: 0,
+                cacheRead: provider.cacheRead,
+                cacheWrite: provider.cacheWrite,
+                total: provider.total,
+                cost: provider.cost,
+                apiCost: provider.apiCost || 0,
+                assistantMessages: provider.assistantMessages,
+            };
+            return acc;
+        }, {}),
+    };
+}