@leo000001/opencode-quota-sidebar 1.0.0

package/dist/period.d.ts

@@ -0,0 +1 @@
+export declare function periodStart(period: 'day' | 'week' | 'month'): number;

package/dist/period.js

@@ -0,0 +1,14 @@
+export function periodStart(period) {
+    const now = new Date();
+    if (period === 'month') {
+        return new Date(now.getFullYear(), now.getMonth(), 1).getTime();
+    }
+    if (period === 'week') {
+        const day = now.getDay();
+        const shift = day === 0 ? 6 : day - 1;
+        const start = new Date(now.getFullYear(), now.getMonth(), now.getDate() - shift);
+        start.setHours(0, 0, 0, 0);
+        return start.getTime();
+    }
+    return new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+}

package/dist/providers/common.d.ts

@@ -0,0 +1,24 @@
+export declare const OPENAI_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+export declare function fetchWithTimeout(url: string, init: RequestInit | undefined, timeoutMs: number): Promise<Response>;
+export declare function asNumber(value: unknown): number | undefined;
+export declare function normalizePercent(value: unknown): number | undefined;
+export declare function toIso(value: unknown): string | undefined;
+/**
+ * Derive a human-readable window label from `limit_window_seconds`.
+ * Uses fallback label when the limit is missing.
+ */
+export declare function windowLabel(win: Record<string, unknown>, fallback?: string): string;
+export declare function parseRateLimitWindow(win: Record<string, unknown>, fallbackLabel: string): {
+    label: string;
+    remainingPercent: number;
+    usedPercent: number | undefined;
+    resetAt: string | undefined;
+} | undefined;
+export declare function asRecord(value: unknown): Record<string, unknown> | undefined;
+export declare function configuredProviderEnabled(config: {
+    providers?: Record<string, {
+        enabled?: boolean;
+    }>;
+}, adapterID: string, fallback?: boolean): boolean;
+export declare function sanitizeBaseURL(value: unknown): string | undefined;
+export declare function basePathPrefixes(value: unknown): string[];

package/dist/providers/common.js

@@ -0,0 +1,114 @@
+import { asNumber as asNumberShared, isRecord } from '../helpers.js';
+// Public OAuth client ID embedded in the ChatGPT web app (not a private secret).
+// Source: https://github.com/vbgate/opencode-mystatus (reverse-engineered from browser client).
+// If OpenAI rotates this value, update it here or expose it via quota-sidebar.config.json.
+export const OPENAI_OAUTH_CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
+export async function fetchWithTimeout(url, init, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function asNumber(value) {
+    return asNumberShared(value);
+}
+export function normalizePercent(value) {
+    const numeric = asNumber(value);
+    if (numeric === undefined)
+        return undefined;
+    const expanded = numeric >= 0 && numeric <= 1 ? numeric * 100 : numeric;
+    if (Number.isNaN(expanded))
+        return undefined;
+    if (expanded < 0)
+        return 0;
+    if (expanded > 100)
+        return 100;
+    return expanded;
+}
+export function toIso(value) {
+    if (typeof value === 'string') {
+        const time = Date.parse(value);
+        if (!Number.isNaN(time))
+            return new Date(time).toISOString();
+        return value;
+    }
+    const number = asNumber(value);
+    if (number === undefined)
+        return undefined;
+    const milliseconds = number > 10_000_000_000 ? number : number * 1000;
+    return new Date(milliseconds).toISOString();
+}
+/**
+ * Derive a human-readable window label from `limit_window_seconds`.
+ * Uses fallback label when the limit is missing.
+ */
+export function windowLabel(win, fallback = '') {
+    const limitSec = asNumber(win.limit_window_seconds);
+    if (limitSec !== undefined && limitSec > 0) {
+        const hours = limitSec / 3600;
+        if (hours <= 24)
+            return `${Math.round(hours)}h`;
+        const days = hours / 24;
+        if (days <= 6)
+            return `${Math.round(days)}d`;
+        return 'Weekly';
+    }
+    return fallback || 'Window';
+}
+export function parseRateLimitWindow(win, fallbackLabel) {
+    const usedPercent = normalizePercent(win.used_percent);
+    const remainingPercent = normalizePercent(win.remaining_percent) ??
+        (usedPercent === undefined ? undefined : 100 - usedPercent);
+    if (remainingPercent === undefined)
+        return undefined;
+    return {
+        label: windowLabel(win, fallbackLabel),
+        remainingPercent,
+        usedPercent,
+        resetAt: toIso(win.reset_at),
+    };
+}
+export function asRecord(value) {
+    return isRecord(value) ? value : undefined;
+}
+export function configuredProviderEnabled(config, adapterID, fallback = true) {
+    const enabled = config.providers?.[adapterID]?.enabled;
+    if (typeof enabled === 'boolean')
+        return enabled;
+    return fallback;
+}
+export function sanitizeBaseURL(value) {
+    if (typeof value !== 'string' || !value)
+        return undefined;
+    try {
+        const parsed = new URL(value);
+        const pathname = parsed.pathname.replace(/\/+$/, '') || '/';
+        return `${parsed.origin}${pathname}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function basePathPrefixes(value) {
+    const sanitized = sanitizeBaseURL(value);
+    if (!sanitized)
+        return [];
+    try {
+        const parsed = new URL(sanitized);
+        const parts = parsed.pathname.split('/').filter(Boolean);
+        const prefixes = [];
+        for (let i = parts.length; i >= 1; i--) {
+            prefixes.push(`/${parts.slice(0, i).join('/')}`);
+        }
+        if (prefixes.length === 0)
+            prefixes.push('/');
+        return prefixes;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/providers/core/anthropic.d.ts

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

package/dist/providers/core/anthropic.js

@@ -0,0 +1,46 @@
+import { configuredProviderEnabled } from '../common.js';
+export const anthropicAdapter = {
+    id: 'anthropic',
+    label: 'Anthropic',
+    shortLabel: 'Anthropic',
+    sortOrder: 30,
+    matchScore: ({ providerID }) => (providerID === 'anthropic' ? 80 : 0),
+    isEnabled: (config) => configuredProviderEnabled(config.quota, 'anthropic', config.quota.includeAnthropic),
+    fetch: async ({ providerID, auth }) => {
+        const checkedAt = Date.now();
+        if (!auth) {
+            return {
+                providerID,
+                adapterID: 'anthropic',
+                label: 'Anthropic',
+                shortLabel: 'Anthropic',
+                sortOrder: 30,
+                status: 'unavailable',
+                checkedAt,
+                note: 'auth not found',
+            };
+        }
+        if (auth.type === 'api') {
+            return {
+                providerID,
+                adapterID: 'anthropic',
+                label: 'Anthropic',
+                shortLabel: 'Anthropic',
+                sortOrder: 30,
+                status: 'unsupported',
+                checkedAt,
+                note: 'api key has no public quota endpoint',
+            };
+        }
+        return {
+            providerID,
+            adapterID: 'anthropic',
+            label: 'Anthropic',
+            shortLabel: 'Anthropic',
+            sortOrder: 30,
+            status: 'unsupported',
+            checkedAt,
+            note: 'oauth quota endpoint is not publicly documented',
+        };
+    },
+};

package/dist/providers/core/copilot.d.ts

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

package/dist/providers/core/copilot.js

@@ -0,0 +1,117 @@
+import { isRecord, swallow } from '../../helpers.js';
+import { asNumber, configuredProviderEnabled, fetchWithTimeout, normalizePercent, toIso, } from '../common.js';
+async function fetchCopilotQuota(ctx) {
+    const checkedAt = Date.now();
+    const base = {
+        providerID: ctx.providerID,
+        adapterID: 'github-copilot',
+        label: 'GitHub Copilot',
+        shortLabel: 'Copilot',
+        sortOrder: 20,
+    };
+    if (!ctx.auth) {
+        return {
+            ...base,
+            status: 'unavailable',
+            checkedAt,
+            note: 'auth not found',
+        };
+    }
+    if (ctx.auth.type !== 'oauth') {
+        return {
+            ...base,
+            status: 'unsupported',
+            checkedAt,
+            note: 'oauth token required',
+        };
+    }
+    if (typeof ctx.auth.access !== 'string' || !ctx.auth.access) {
+        return {
+            ...base,
+            status: 'unavailable',
+            checkedAt,
+            note: 'missing oauth access token',
+        };
+    }
+    const response = await fetchWithTimeout('https://api.github.com/copilot_internal/user', {
+        headers: {
+            Accept: 'application/json',
+            Authorization: `token ${ctx.auth.access}`,
+            'User-Agent': 'GitHubCopilotChat/0.35.0',
+            'Editor-Version': 'vscode/1.107.0',
+            'Editor-Plugin-Version': 'copilot-chat/0.35.0',
+            'Copilot-Integration-Id': 'vscode-chat',
+        },
+    }, ctx.config.quota.requestTimeoutMs).catch(swallow('fetchCopilotQuota'));
+    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('fetchCopilotQuota:json'));
+    if (!isRecord(payload)) {
+        return {
+            ...base,
+            status: 'error',
+            checkedAt,
+            note: 'invalid response',
+        };
+    }
+    const snapshots = isRecord(payload.quota_snapshots)
+        ? payload.quota_snapshots
+        : {};
+    const premium = isRecord(snapshots.premium_interactions)
+        ? snapshots.premium_interactions
+        : {};
+    const remainingPercent = normalizePercent(premium.percent_remaining) ??
+        (() => {
+            const entitlement = asNumber(premium.entitlement);
+            const remaining = asNumber(premium.remaining);
+            if (entitlement === undefined ||
+                remaining === undefined ||
+                entitlement <= 0) {
+                return undefined;
+            }
+            return normalizePercent(remaining / entitlement);
+        })();
+    const resetAt = toIso(payload.quota_reset_date) ?? toIso(premium.quota_reset_date_utc);
+    const windows = remainingPercent === undefined
+        ? undefined
+        : [
+            {
+                label: 'Monthly',
+                remainingPercent,
+                resetAt,
+            },
+        ];
+    return {
+        ...base,
+        status: remainingPercent === undefined ? 'error' : 'ok',
+        checkedAt,
+        remainingPercent,
+        resetAt,
+        note: remainingPercent === undefined ? 'missing quota fields' : undefined,
+        windows,
+    };
+}
+export const copilotAdapter = {
+    id: 'github-copilot',
+    label: 'GitHub Copilot',
+    shortLabel: 'Copilot',
+    sortOrder: 20,
+    normalizeID: (providerID) => providerID.startsWith('github-copilot') ? 'github-copilot' : undefined,
+    matchScore: ({ providerID }) => providerID.startsWith('github-copilot') ? 80 : 0,
+    isEnabled: (config) => configuredProviderEnabled(config.quota, 'github-copilot', config.quota.includeCopilot),
+    fetch: fetchCopilotQuota,
+};

package/dist/providers/core/openai.d.ts

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

package/dist/providers/core/openai.js

@@ -0,0 +1,159 @@
+import { debug, debugError, isRecord, swallow } from '../../helpers.js';
+import { OPENAI_OAUTH_CLIENT_ID, configuredProviderEnabled, fetchWithTimeout, normalizePercent, parseRateLimitWindow, toIso, } from '../common.js';
+async function fetchOpenAIQuota(ctx) {
+    const checkedAt = Date.now();
+    const base = {
+        providerID: ctx.providerID,
+        adapterID: 'openai',
+        label: 'OpenAI Codex',
+        shortLabel: 'OpenAI',
+        sortOrder: 10,
+    };
+    if (!ctx.auth) {
+        return {
+            ...base,
+            status: 'unavailable',
+            checkedAt,
+            note: 'auth not found',
+        };
+    }
+    if (ctx.auth.type !== 'oauth') {
+        return {
+            ...base,
+            status: 'unsupported',
+            checkedAt,
+            note: 'api key auth has no quota endpoint',
+        };
+    }
+    if (typeof ctx.auth.access !== 'string' || !ctx.auth.access) {
+        return {
+            ...base,
+            status: 'unavailable',
+            checkedAt,
+            note: 'missing oauth access token',
+        };
+    }
+    let access = ctx.auth.access;
+    let refreshWarning;
+    if (ctx.config.quota.refreshAccessToken &&
+        ctx.auth.expires &&
+        typeof ctx.auth.refresh === 'string' &&
+        ctx.auth.refresh &&
+        ctx.auth.expires <= Date.now() + 60_000) {
+        const refreshed = await fetchWithTimeout('https://auth.openai.com/oauth/token', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams({
+                grant_type: 'refresh_token',
+                refresh_token: ctx.auth.refresh,
+                client_id: OPENAI_OAUTH_CLIENT_ID,
+            }).toString(),
+        }, ctx.config.quota.requestTimeoutMs).catch(swallow('fetchOpenAIQuota:refresh'));
+        if (refreshed?.ok) {
+            const payload = await refreshed
+                .json()
+                .catch(swallow('fetchOpenAIQuota:refreshJson'));
+            if (isRecord(payload) && typeof payload.access_token === 'string') {
+                access = payload.access_token;
+                ctx.auth.access = payload.access_token;
+                ctx.auth.refresh =
+                    typeof payload.refresh_token === 'string'
+                        ? payload.refresh_token
+                        : ctx.auth.refresh;
+                ctx.auth.expires =
+                    Date.now() +
+                        (typeof payload.expires_in === 'number' ? payload.expires_in : 3600) *
+                            1000;
+                if (ctx.updateAuth && ctx.auth.refresh && ctx.auth.expires) {
+                    try {
+                        await ctx.updateAuth('openai', {
+                            type: 'oauth',
+                            access: ctx.auth.access,
+                            refresh: ctx.auth.refresh,
+                            expires: ctx.auth.expires,
+                            accountId: ctx.auth.accountId,
+                        });
+                        debug('openai oauth token refreshed and persisted');
+                    }
+                    catch (error) {
+                        debugError('updateAuth:openai', error);
+                        refreshWarning =
+                            'token refreshed but failed to persist; using in-memory token';
+                    }
+                }
+            }
+        }
+    }
+    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);
+    }
+    const response = await fetchWithTimeout('https://chatgpt.com/backend-api/wham/usage', { headers }, ctx.config.quota.requestTimeoutMs).catch(swallow('fetchOpenAIQuota:usage'));
+    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('fetchOpenAIQuota:json'));
+    if (!isRecord(payload)) {
+        return {
+            ...base,
+            status: 'error',
+            checkedAt,
+            note: 'invalid response',
+        };
+    }
+    const rateLimit = isRecord(payload.rate_limit) ? payload.rate_limit : {};
+    const primary = isRecord(rateLimit.primary_window)
+        ? rateLimit.primary_window
+        : {};
+    const usedPercent = normalizePercent(primary.used_percent);
+    const remainingPercent = normalizePercent(primary.remaining_percent) ??
+        (usedPercent === undefined ? undefined : 100 - usedPercent);
+    const resetAt = toIso(primary.reset_at ?? rateLimit.reset_at);
+    const windows = [];
+    if (remainingPercent !== undefined) {
+        const primaryWin = parseRateLimitWindow(primary, '');
+        if (primaryWin)
+            windows.push(primaryWin);
+    }
+    if (isRecord(rateLimit.secondary_window)) {
+        const secondaryWin = parseRateLimitWindow(rateLimit.secondary_window, 'Weekly');
+        if (secondaryWin)
+            windows.push(secondaryWin);
+    }
+    return {
+        ...base,
+        status: remainingPercent === undefined ? 'error' : 'ok',
+        checkedAt,
+        usedPercent,
+        remainingPercent,
+        resetAt,
+        note: remainingPercent === undefined ? 'missing quota fields' : refreshWarning,
+        windows: windows.length > 0 ? windows : undefined,
+    };
+}
+export const openaiAdapter = {
+    id: 'openai',
+    label: 'OpenAI Codex',
+    shortLabel: 'OpenAI',
+    sortOrder: 10,
+    matchScore: ({ providerID }) => (providerID === 'openai' ? 80 : 0),
+    isEnabled: (config) => configuredProviderEnabled(config.quota, 'openai', config.quota.includeOpenAI),
+    fetch: fetchOpenAIQuota,
+};

package/dist/providers/index.d.ts

@@ -0,0 +1,8 @@
+import { anthropicAdapter } from './core/anthropic.js';
+import { copilotAdapter } from './core/copilot.js';
+import { openaiAdapter } from './core/openai.js';
+import { QuotaProviderRegistry } from './registry.js';
+import { rightCodeAdapter } from './third_party/rightcode.js';
+export declare function createDefaultProviderRegistry(): QuotaProviderRegistry;
+export { anthropicAdapter, copilotAdapter, openaiAdapter, rightCodeAdapter, QuotaProviderRegistry, };
+export type { AuthUpdate, AuthValue, ProviderResolveContext, QuotaFetchContext, QuotaProviderAdapter, RefreshedOAuthAuth, } from './types.js';

package/dist/providers/index.js

@@ -0,0 +1,14 @@
+import { anthropicAdapter } from './core/anthropic.js';
+import { copilotAdapter } from './core/copilot.js';
+import { openaiAdapter } from './core/openai.js';
+import { QuotaProviderRegistry } from './registry.js';
+import { rightCodeAdapter } from './third_party/rightcode.js';
+export function createDefaultProviderRegistry() {
+    const registry = new QuotaProviderRegistry();
+    registry.register(rightCodeAdapter);
+    registry.register(openaiAdapter);
+    registry.register(copilotAdapter);
+    registry.register(anthropicAdapter);
+    return registry;
+}
+export { anthropicAdapter, copilotAdapter, openaiAdapter, rightCodeAdapter, QuotaProviderRegistry, };

package/dist/providers/registry.d.ts

@@ -0,0 +1,9 @@
+import type { ProviderMatch, ProviderResolveContext, QuotaProviderAdapter } from './types.js';
+export declare class QuotaProviderRegistry {
+    private adapters;
+    register(adapter: QuotaProviderAdapter): void;
+    all(): QuotaProviderAdapter[];
+    normalizeProviderID(providerID: string): string;
+    resolveWithScore(ctx: ProviderResolveContext): ProviderMatch | undefined;
+    resolve(ctx: ProviderResolveContext): QuotaProviderAdapter | undefined;
+}

package/dist/providers/registry.js

@@ -0,0 +1,38 @@
+export class QuotaProviderRegistry {
+    adapters = [];
+    register(adapter) {
+        this.adapters.push(adapter);
+    }
+    all() {
+        return [...this.adapters];
+    }
+    normalizeProviderID(providerID) {
+        for (const adapter of this.adapters) {
+            if (!adapter.normalizeID)
+                continue;
+            const normalized = adapter.normalizeID(providerID);
+            if (normalized !== undefined)
+                return normalized;
+        }
+        return providerID;
+    }
+    resolveWithScore(ctx) {
+        let best;
+        for (const adapter of this.adapters) {
+            const score = adapter.matchScore(ctx);
+            if (score <= 0)
+                continue;
+            if (!best || score > best.score) {
+                best = { adapter, score };
+                continue;
+            }
+            if (score === best.score && adapter.sortOrder < best.adapter.sortOrder) {
+                best = { adapter, score };
+            }
+        }
+        return best;
+    }
+    resolve(ctx) {
+        return this.resolveWithScore(ctx)?.adapter;
+    }
+}

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

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