@leo000001/opencode-quota-sidebar 1.0.0

package/dist/providers/third_party/rightcode.js

@@ -0,0 +1,230 @@
+import { isRecord, swallow } from '../../helpers.js';
+import { asNumber, basePathPrefixes, configuredProviderEnabled, fetchWithTimeout, sanitizeBaseURL, toIso, } from '../common.js';
+function isRightCodeBaseURL(value) {
+    const normalized = sanitizeBaseURL(value);
+    if (!normalized)
+        return false;
+    try {
+        const parsed = new URL(normalized);
+        if (parsed.protocol !== 'https:')
+            return false;
+        return parsed.host === 'www.right.codes' || parsed.host === 'right.codes';
+    }
+    catch {
+        return false;
+    }
+}
+function resolveApiKey(auth, providerOptions) {
+    const optionKey = providerOptions?.apiKey;
+    if (typeof optionKey === 'string' && optionKey)
+        return optionKey;
+    if (!auth)
+        return undefined;
+    if (auth.type === 'api' && typeof auth.key === 'string' && auth.key) {
+        return auth.key;
+    }
+    if (auth.type === 'wellknown') {
+        if (typeof auth.key === 'string' && auth.key)
+            return auth.key;
+        if (typeof auth.token === 'string' && auth.token)
+            return auth.token;
+    }
+    if (auth.type === 'oauth' && typeof auth.access === 'string' && auth.access) {
+        return auth.access;
+    }
+    return undefined;
+}
+function matchesSubscriptionPrefix(providerPrefixes, availablePrefixes) {
+    if (providerPrefixes.length === 0 || availablePrefixes.length === 0) {
+        return false;
+    }
+    for (const providerPrefix of providerPrefixes) {
+        for (const availablePrefix of availablePrefixes) {
+            if (providerPrefix === availablePrefix)
+                return true;
+            if (providerPrefix.startsWith(`${availablePrefix}/`))
+                return true;
+        }
+    }
+    return false;
+}
+function formatQuotaValue(value) {
+    if (!Number.isFinite(value))
+        return '0';
+    const rounded = Number(value.toFixed(2));
+    return Number.isInteger(rounded) ? `${Math.trunc(rounded)}` : `${rounded}`;
+}
+function parseSubscription(value) {
+    const total = asNumber(value.total_quota);
+    const remaining = asNumber(value.remaining_quota);
+    // Ignore tiny/non-primary plans (badges, gifts, etc.).
+    if (total === undefined || remaining === undefined || total < 10) {
+        return undefined;
+    }
+    // RightCode daily quota semantics:
+    // - reset_today=true  => normal same-day ratio: remaining / total
+    // - reset_today=false => include today's fresh quota: (remaining + total) / total
+    const resetToday = value.reset_today === true;
+    const dailyRemaining = resetToday ? remaining : remaining + total;
+    // Intentionally not using normalizePercent(): daily ratio can exceed 100%.
+    const remainingPercent = (dailyRemaining / total) * 100;
+    return {
+        name: typeof value.name === 'string' ? value.name : 'Subscription',
+        dailyTotal: total,
+        dailyRemaining,
+        remainingPercent,
+        expiresAt: toIso(value.expired_at),
+    };
+}
+function extractPrefixes(value) {
+    const raw = value.available_prefixes;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((item) => typeof item === 'string' && !!item);
+}
+async function fetchRightCodeQuota(ctx) {
+    const checkedAt = Date.now();
+    const sourceProviderID = typeof ctx.sourceProviderID === 'string' && ctx.sourceProviderID
+        ? ctx.sourceProviderID
+        : ctx.providerID;
+    const shortLabel = sourceProviderID.startsWith('rightcode-')
+        ? `RC-${sourceProviderID.slice('rightcode-'.length)}`
+        : 'RC';
+    const base = {
+        providerID: sourceProviderID,
+        adapterID: 'rightcode',
+        label: 'RightCode',
+        shortLabel,
+        sortOrder: 5,
+    };
+    const apiKey = resolveApiKey(ctx.auth, ctx.providerOptions);
+    if (!apiKey) {
+        return {
+            ...base,
+            status: 'unavailable',
+            checkedAt,
+            note: 'missing api key',
+        };
+    }
+    const response = await fetchWithTimeout('https://www.right.codes/account/summary', {
+        headers: {
+            Accept: 'application/json',
+            Authorization: `Bearer ${apiKey}`,
+            'User-Agent': 'opencode-quota-sidebar',
+        },
+    }, ctx.config.quota.requestTimeoutMs).catch(swallow('fetchRightCodeQuota'));
+    if (!response) {
+        return {
+            ...base,
+            status: 'error',
+            checkedAt,
+            note: 'network request failed',
+        };
+    }
+    if (!response.ok) {
+        return {
+            ...base,
+            status: 'error',
+            checkedAt,
+            note: `http ${response.status}`,
+        };
+    }
+    const payload = await response
+        .json()
+        .catch(swallow('fetchRightCodeQuota:json'));
+    if (!isRecord(payload)) {
+        return {
+            ...base,
+            status: 'error',
+            checkedAt,
+            note: 'invalid response',
+        };
+    }
+    const balance = asNumber(payload.balance);
+    const providerPrefixes = basePathPrefixes(ctx.providerOptions?.baseURL);
+    if (providerPrefixes.length === 0) {
+        providerPrefixes.push(`/${ctx.providerID}`);
+    }
+    const subscriptions = Array.isArray(payload.subscriptions)
+        ? payload.subscriptions.filter((item) => isRecord(item))
+        : [];
+    const matched = subscriptions
+        .filter((subscription) => {
+        const available = extractPrefixes(subscription);
+        return matchesSubscriptionPrefix(providerPrefixes, available);
+    })
+        .map((subscription) => parseSubscription(subscription))
+        .filter((subscription) => Boolean(subscription));
+    if (matched.length > 0) {
+        const dailyTotal = matched.reduce((sum, subscription) => sum + subscription.dailyTotal, 0);
+        const dailyRemaining = matched.reduce((sum, subscription) => sum + subscription.dailyRemaining, 0);
+        const dailyPercent = dailyTotal > 0 ? (dailyRemaining / dailyTotal) * 100 : undefined;
+        const expiry = matched.reduce((acc, subscription) => {
+            if (!subscription.expiresAt)
+                return acc;
+            const current = Date.parse(subscription.expiresAt);
+            if (Number.isNaN(current))
+                return acc;
+            if (!acc)
+                return subscription.expiresAt;
+            const existing = Date.parse(acc);
+            if (Number.isNaN(existing) || current < existing) {
+                return subscription.expiresAt;
+            }
+            return acc;
+        }, undefined);
+        const windows = [
+            {
+                label: `Daily $${formatQuotaValue(dailyRemaining)}/$${formatQuotaValue(dailyTotal)}`,
+                showPercent: false,
+                remainingPercent: dailyPercent,
+                resetAt: expiry,
+                resetLabel: 'Exp',
+            },
+        ];
+        const names = matched.map((subscription) => subscription.name).join(', ');
+        return {
+            ...base,
+            status: dailyPercent === undefined ? 'error' : 'ok',
+            checkedAt,
+            remainingPercent: dailyPercent,
+            balance: balance === undefined
+                ? undefined
+                : {
+                    amount: balance,
+                    currency: '$',
+                },
+            windows,
+            note: dailyPercent === undefined
+                ? 'matched subscription has no daily quota fields'
+                : `subscription daily quota: ${names}`,
+        };
+    }
+    if (balance !== undefined) {
+        return {
+            ...base,
+            status: 'ok',
+            checkedAt,
+            balance: {
+                amount: balance,
+                currency: '$',
+            },
+            note: 'no matching subscription for provider prefix',
+        };
+    }
+    return {
+        ...base,
+        status: 'error',
+        checkedAt,
+        note: 'missing balance and subscription fields',
+    };
+}
+export const rightCodeAdapter = {
+    id: 'rightcode',
+    label: 'RightCode',
+    shortLabel: 'RC',
+    sortOrder: 5,
+    matchScore: ({ providerOptions }) => isRightCodeBaseURL(providerOptions?.baseURL) ? 100 : 0,
+    isEnabled: (config) => configuredProviderEnabled(config.quota, 'rightcode', true),
+    fetch: fetchRightCodeQuota,
+};

package/dist/providers/types.d.ts

@@ -0,0 +1,58 @@
+import type { QuotaSidebarConfig, QuotaSnapshot } from '../types.js';
+export type OAuthAuth = {
+    type: 'oauth';
+    access?: string;
+    refresh?: string;
+    expires?: number;
+    accountId?: string;
+    enterpriseUrl?: string;
+};
+export type ApiAuth = {
+    type: 'api';
+    key?: string;
+};
+export type WellKnownAuth = {
+    type: 'wellknown';
+    key?: string;
+    token?: string;
+};
+export type AuthValue = OAuthAuth | ApiAuth | WellKnownAuth;
+export type RefreshedOAuthAuth = {
+    type: 'oauth';
+    access: string;
+    refresh: string;
+    expires: number;
+    accountId?: string;
+    enterpriseUrl?: string;
+};
+export type AuthUpdate = (providerID: string, auth: RefreshedOAuthAuth) => Promise<void>;
+export type ProviderResolveContext = {
+    providerID: string;
+    providerOptions?: Record<string, unknown>;
+};
+export type QuotaFetchContext = {
+    /** Original provider ID before normalization (useful for adapter variants). */
+    sourceProviderID?: string;
+    providerID: string;
+    providerOptions?: Record<string, unknown>;
+    auth: AuthValue | undefined;
+    config: QuotaSidebarConfig;
+    updateAuth?: AuthUpdate;
+};
+export type QuotaProviderAdapter = {
+    id: string;
+    label: string;
+    shortLabel: string;
+    sortOrder: number;
+    /** Higher score wins. 0 means no match. */
+    matchScore: (ctx: ProviderResolveContext) => number;
+    /** Resolve provider ID variants to a canonical id when needed. */
+    normalizeID?: (providerID: string) => string | undefined;
+    /** Provider-specific enable switch (supports backward-compatible flags). */
+    isEnabled: (config: QuotaSidebarConfig) => boolean;
+    fetch: (ctx: QuotaFetchContext) => Promise<QuotaSnapshot>;
+};
+export type ProviderMatch = {
+    adapter: QuotaProviderAdapter;
+    score: number;
+};

package/dist/providers/types.js

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

package/dist/quota.d.ts

@@ -0,0 +1,49 @@
+import type { AuthUpdate, AuthValue } from './providers/types.js';
+import type { QuotaSidebarConfig, QuotaSnapshot } from './types.js';
+export declare function quotaSort(left: QuotaSnapshot, right: QuotaSnapshot): number;
+export declare function listDefaultQuotaProviderIDs(): string[];
+export declare function createQuotaRuntime(): {
+    normalizeProviderID: (providerID: string) => string;
+    resolveQuotaAdapter: (providerID: string, providerOptions?: Record<string, unknown>) => import("./providers/types.js").QuotaProviderAdapter | undefined;
+    quotaCacheKey: (providerID: string, providerOptions?: Record<string, unknown>) => string;
+    fetchQuotaSnapshot: (providerID: string, authMap: Record<string, AuthValue>, config: QuotaSidebarConfig, updateAuth?: AuthUpdate, providerOptions?: Record<string, unknown>) => Promise<{
+        adapterID: string;
+        shortLabel: string;
+        sortOrder: number;
+        label: string;
+        providerID: string;
+        status: import("./types.js").QuotaStatus;
+        checkedAt: number;
+        remainingPercent?: number;
+        usedPercent?: number;
+        resetAt?: string;
+        balance?: {
+            amount: number;
+            currency: string;
+        };
+        note?: string;
+        windows?: import("./types.js").QuotaWindow[];
+    } | undefined>;
+};
+export declare function normalizeProviderID(providerID: string): string;
+export declare function resolveQuotaAdapter(providerID: string, providerOptions?: Record<string, unknown>): import("./providers/types.js").QuotaProviderAdapter | undefined;
+export declare function quotaCacheKey(providerID: string, providerOptions?: Record<string, unknown>): string;
+export declare function loadAuthMap(authPath: string): Promise<Record<string, AuthValue>>;
+export declare function fetchQuotaSnapshot(providerID: string, authMap: Record<string, AuthValue>, config: QuotaSidebarConfig, updateAuth?: AuthUpdate, providerOptions?: Record<string, unknown>): Promise<{
+    adapterID: string;
+    shortLabel: string;
+    sortOrder: number;
+    label: string;
+    providerID: string;
+    status: import("./types.js").QuotaStatus;
+    checkedAt: number;
+    remainingPercent?: number;
+    usedPercent?: number;
+    resetAt?: string;
+    balance?: {
+        amount: number;
+        currency: string;
+    };
+    note?: string;
+    windows?: import("./types.js").QuotaWindow[];
+} | undefined>;

package/dist/quota.js

@@ -0,0 +1,116 @@
+import fs from 'node:fs/promises';
+import { isRecord, swallow } from './helpers.js';
+import { createDefaultProviderRegistry } from './providers/index.js';
+import { sanitizeBaseURL } from './providers/common.js';
+function resolveContext(providerID, providerOptions) {
+    return { providerID, providerOptions };
+}
+function authCandidates(providerID, normalizedProviderID, adapterID) {
+    const candidates = new Set([
+        providerID,
+        normalizedProviderID,
+        adapterID,
+    ]);
+    if (adapterID === 'github-copilot') {
+        candidates.add('github-copilot-enterprise');
+    }
+    return [...candidates];
+}
+function pickAuth(providerID, normalizedProviderID, adapterID, authMap) {
+    for (const key of authCandidates(providerID, normalizedProviderID, adapterID)) {
+        const auth = authMap[key];
+        if (auth)
+            return auth;
+    }
+    return undefined;
+}
+export function quotaSort(left, right) {
+    const leftOrder = left.sortOrder ?? 99;
+    const rightOrder = right.sortOrder ?? 99;
+    if (leftOrder !== rightOrder)
+        return leftOrder - rightOrder;
+    const leftKey = left.adapterID || left.providerID;
+    const rightKey = right.adapterID || right.providerID;
+    return leftKey.localeCompare(rightKey);
+}
+export function listDefaultQuotaProviderIDs() {
+    // Keep default report behavior stable for built-in subscription providers.
+    return ['openai', 'github-copilot', 'anthropic'];
+}
+export function createQuotaRuntime() {
+    const providerRegistry = createDefaultProviderRegistry();
+    const normalizeProviderID = (providerID) => providerRegistry.normalizeProviderID(providerID);
+    const resolveQuotaAdapter = (providerID, providerOptions) => {
+        return providerRegistry.resolve(resolveContext(providerID, providerOptions));
+    };
+    const quotaCacheKey = (providerID, providerOptions) => {
+        const adapter = resolveQuotaAdapter(providerID, providerOptions);
+        const normalizedProviderID = normalizeProviderID(providerID);
+        const baseURL = sanitizeBaseURL(providerOptions?.baseURL);
+        const keyBase = adapter?.id || normalizedProviderID;
+        return baseURL ? `${keyBase}@${baseURL}` : keyBase;
+    };
+    const fetchQuotaSnapshot = async (providerID, authMap, config, updateAuth, providerOptions) => {
+        const context = resolveContext(providerID, providerOptions);
+        const adapter = providerRegistry.resolve(context);
+        if (!adapter)
+            return undefined;
+        if (!adapter.isEnabled(config))
+            return undefined;
+        const normalizedProviderID = adapter.normalizeID?.(providerID) ?? normalizeProviderID(providerID);
+        const auth = pickAuth(providerID, normalizedProviderID, adapter.id, authMap);
+        const snapshot = await adapter.fetch({
+            sourceProviderID: providerID,
+            providerID: normalizedProviderID,
+            providerOptions,
+            auth,
+            config,
+            updateAuth,
+        });
+        return {
+            ...snapshot,
+            adapterID: snapshot.adapterID || adapter.id,
+            shortLabel: snapshot.shortLabel || adapter.shortLabel,
+            sortOrder: snapshot.sortOrder ?? adapter.sortOrder,
+            label: snapshot.label || adapter.label,
+        };
+    };
+    return {
+        normalizeProviderID,
+        resolveQuotaAdapter,
+        quotaCacheKey,
+        fetchQuotaSnapshot,
+    };
+}
+function withRuntime(fn) {
+    return fn(createQuotaRuntime());
+}
+export function normalizeProviderID(providerID) {
+    return withRuntime((runtime) => runtime.normalizeProviderID(providerID));
+}
+export function resolveQuotaAdapter(providerID, providerOptions) {
+    return withRuntime((runtime) => runtime.resolveQuotaAdapter(providerID, providerOptions));
+}
+export function quotaCacheKey(providerID, providerOptions) {
+    return withRuntime((runtime) => runtime.quotaCacheKey(providerID, providerOptions));
+}
+export async function loadAuthMap(authPath) {
+    const parsed = await fs
+        .readFile(authPath, 'utf8')
+        .then((value) => JSON.parse(value))
+        .catch(swallow('loadAuthMap'));
+    if (!isRecord(parsed))
+        return {};
+    return Object.entries(parsed).reduce((acc, [key, value]) => {
+        if (!isRecord(value))
+            return acc;
+        const type = value.type;
+        if (type !== 'oauth' && type !== 'api' && type !== 'wellknown')
+            return acc;
+        acc[key] = value;
+        return acc;
+    }, {});
+}
+export async function fetchQuotaSnapshot(providerID, authMap, config, updateAuth, providerOptions) {
+    return withRuntime((runtime) => runtime.fetchQuotaSnapshot(providerID, authMap, config, updateAuth, providerOptions));
+}

package/dist/quota_render.d.ts

@@ -0,0 +1,5 @@
+import type { QuotaSnapshot } from './types.js';
+export declare function canonicalProviderID(providerID: string): string;
+export declare function displayShortLabel(providerID: string): string;
+export declare function quotaDisplayLabel(quota: QuotaSnapshot): string;
+export declare function collapseQuotaSnapshots(quotas: QuotaSnapshot[]): QuotaSnapshot[];

package/dist/quota_render.js

@@ -0,0 +1,85 @@
+const PROVIDER_SHORT_LABELS = {
+    openai: 'OpenAI',
+    'github-copilot': 'Copilot',
+    anthropic: 'Anthropic',
+    rightcode: 'RC',
+};
+export function canonicalProviderID(providerID) {
+    if (providerID.startsWith('github-copilot'))
+        return 'github-copilot';
+    return providerID;
+}
+export function displayShortLabel(providerID) {
+    const canonical = canonicalProviderID(providerID);
+    const direct = PROVIDER_SHORT_LABELS[canonical];
+    if (direct)
+        return direct;
+    if (canonical.startsWith('rightcode-')) {
+        return `RC-${canonical.slice('rightcode-'.length)}`;
+    }
+    return providerID;
+}
+export function quotaDisplayLabel(quota) {
+    if (quota.shortLabel)
+        return quota.shortLabel;
+    if (quota.adapterID) {
+        const adapterLabel = displayShortLabel(quota.adapterID);
+        if (adapterLabel !== quota.adapterID)
+            return adapterLabel;
+    }
+    return displayShortLabel(quota.providerID);
+}
+function quotaKey(quota) {
+    if (quota.adapterID === 'rightcode')
+        return `rightcode:${quota.providerID}`;
+    return `${quota.adapterID || quota.providerID}:${quota.providerID}`;
+}
+function quotaScore(quota) {
+    let score = 0;
+    if (quota.status === 'ok')
+        score += 10;
+    if (quota.windows && quota.windows.length > 0) {
+        score += 5 + quota.windows.length;
+    }
+    if (quota.balance)
+        score += 3;
+    if (quota.remainingPercent !== undefined)
+        score += 1;
+    return score;
+}
+export function collapseQuotaSnapshots(quotas) {
+    const grouped = new Map();
+    const hasRightCodeBase = quotas.some((quota) => quota.adapterID === 'rightcode' && quotaDisplayLabel(quota) === 'RC');
+    for (const quota of quotas) {
+        // If both RC (balance) and RC-variant (subscription) exist,
+        // treat balance as owned by RC.
+        const normalizedQuota = hasRightCodeBase &&
+            quota.adapterID === 'rightcode' &&
+            quotaDisplayLabel(quota).startsWith('RC-')
+            ? { ...quota, balance: undefined }
+            : quota;
+        const key = quotaKey(normalizedQuota);
+        const existing = grouped.get(key);
+        if (!existing) {
+            grouped.set(key, normalizedQuota);
+            continue;
+        }
+        const primary = quotaScore(normalizedQuota) >= quotaScore(existing)
+            ? normalizedQuota
+            : existing;
+        const secondary = primary === normalizedQuota ? existing : normalizedQuota;
+        grouped.set(key, {
+            ...primary,
+            windows: primary.windows && primary.windows.length > 0
+                ? primary.windows
+                : secondary.windows,
+            balance: primary.balance || secondary.balance,
+            remainingPercent: primary.remainingPercent !== undefined
+                ? primary.remainingPercent
+                : secondary.remainingPercent,
+            resetAt: primary.resetAt || secondary.resetAt,
+            note: primary.note || secondary.note,
+        });
+    }
+    return [...grouped.values()];
+}

package/dist/storage.d.ts

@@ -0,0 +1,32 @@
+import { dateKeyFromTimestamp, normalizeTimestampMs } from './storage_dates.js';
+import { authFilePath, resolveOpencodeDataDir, stateFilePath } from './storage_paths.js';
+import type { QuotaSidebarConfig, QuotaSidebarState, SessionState } from './types.js';
+export { authFilePath, dateKeyFromTimestamp, normalizeTimestampMs, resolveOpencodeDataDir, stateFilePath, };
+export declare const defaultConfig: QuotaSidebarConfig;
+export declare function defaultState(): QuotaSidebarState;
+export declare function loadConfig(paths: string[]): Promise<QuotaSidebarConfig>;
+export declare function loadState(statePath: string): Promise<QuotaSidebarState>;
+/**
+ * H1 fix: when dirtyDateKeys is empty and writeAll is not set, skip chunk writes entirely.
+ * M11 fix: only iterate sessions belonging to dirty date keys (not all sessions).
+ * M4 fix: atomic writes via safeWriteFile.
+ * P4 fix: sessionDateMap dirty flag tracked externally.
+ */
+export declare function saveState(statePath: string, state: QuotaSidebarState, options?: {
+    dirtyDateKeys?: string[];
+    writeAll?: boolean;
+}): Promise<void>;
+/**
+ * M2 fix: evict sessions older than retentionDays from memory.
+ * Chunk files remain on disk for historical range scans.
+ */
+export declare function evictOldSessions(state: QuotaSidebarState, retentionDays: number): number;
+/**
+ * M9 fix: scan from in-memory state first, only read disk for date keys
+ * not represented in memory.
+ */
+export declare function scanSessionsByCreatedRange(statePath: string, startAt: number, endAt?: number, memoryState?: QuotaSidebarState): Promise<{
+    sessionID: string;
+    dateKey: string;
+    state: SessionState;
+}[]>;