@leo000001/opencode-quota-sidebar 2.0.1 → 2.0.4

package/dist/providers/core/kimi_for_coding.js

@@ -0,0 +1,219 @@
+import { isRecord, swallow } from '../../helpers.js';
+import { asNumber, configuredProviderEnabled, fetchWithTimeout, sanitizeBaseURL, toIso, } from '../common.js';
+const KIMI_FOR_CODING_BASE_URL = 'https://api.kimi.com/coding/v1';
+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 isKimiCodingBaseURL(value) {
+    const normalized = sanitizeBaseURL(value);
+    if (!normalized)
+        return false;
+    try {
+        const parsed = new URL(normalized);
+        if (parsed.protocol !== 'https:')
+            return false;
+        const pathname = parsed.pathname.replace(/\/+$/, '');
+        return parsed.host === 'api.kimi.com' && pathname === '/coding/v1';
+    }
+    catch {
+        return false;
+    }
+}
+function usagesUrl(baseURL) {
+    const normalized = sanitizeBaseURL(baseURL);
+    if (isKimiCodingBaseURL(normalized)) {
+        return `${normalized}/usages`;
+    }
+    return `${KIMI_FOR_CODING_BASE_URL}/usages`;
+}
+function percentFromQuota(limit, remaining) {
+    const total = asNumber(limit) ??
+        (typeof limit === 'string' && limit.trim() ? Number(limit) : undefined);
+    const left = asNumber(remaining) ??
+        (typeof remaining === 'string' && remaining.trim()
+            ? Number(remaining)
+            : undefined);
+    if (total === undefined || left === undefined || total <= 0)
+        return undefined;
+    if (!Number.isFinite(total) || !Number.isFinite(left))
+        return undefined;
+    return Math.max(0, Math.min(100, (left / total) * 100));
+}
+function windowLabel(duration, timeUnit) {
+    if (timeUnit === 'TIME_UNIT_MINUTE' && duration === 300)
+        return '5h';
+    if (timeUnit === 'TIME_UNIT_DAY' && duration === 7)
+        return 'Weekly';
+    if (timeUnit === 'TIME_UNIT_MINUTE' && duration && duration > 0) {
+        const hours = duration / 60;
+        if (hours <= 24)
+            return `${Math.round(hours)}h`;
+    }
+    if (timeUnit === 'TIME_UNIT_HOUR' && duration && duration > 0) {
+        if (duration <= 24)
+            return `${Math.round(duration)}h`;
+        const days = duration / 24;
+        if (days <= 6)
+            return `${Math.round(days)}d`;
+    }
+    if (timeUnit === 'TIME_UNIT_DAY' && duration && duration > 0) {
+        if (duration <= 6)
+            return `${Math.round(duration)}d`;
+        if (duration === 7)
+            return 'Weekly';
+    }
+    return undefined;
+}
+function parseWindow(value) {
+    if (!isRecord(value))
+        return undefined;
+    const window = isRecord(value.window) ? value.window : undefined;
+    const detail = isRecord(value.detail) ? value.detail : undefined;
+    if (!window || !detail)
+        return undefined;
+    const duration = asNumber(window.duration);
+    const timeUnit = typeof window.timeUnit === 'string' ? window.timeUnit : undefined;
+    const label = windowLabel(duration, timeUnit);
+    const remainingPercent = percentFromQuota(detail.limit, detail.remaining);
+    if (!label || remainingPercent === undefined)
+        return undefined;
+    return {
+        label,
+        remainingPercent,
+        resetAt: toIso(detail.resetTime),
+    };
+}
+function dedupeWindows(windows) {
+    const seen = new Set();
+    const deduped = [];
+    for (const window of windows) {
+        const key = `${window.label}|${window.resetAt || ''}|${window.remainingPercent ?? ''}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(window);
+    }
+    return deduped;
+}
+async function fetchKimiForCodingQuota({ providerID, providerOptions, auth, config, }) {
+    const checkedAt = Date.now();
+    const base = {
+        providerID,
+        adapterID: 'kimi-for-coding',
+        label: 'Kimi For Coding',
+        shortLabel: 'Kimi',
+        sortOrder: 15,
+    };
+    const apiKey = resolveApiKey(auth, providerOptions);
+    if (!apiKey) {
+        return {
+            ...base,
+            status: 'unavailable',
+            checkedAt,
+            note: 'missing api key',
+        };
+    }
+    const response = await fetchWithTimeout(usagesUrl(providerOptions?.baseURL), {
+        method: 'GET',
+        headers: {
+            Accept: 'application/json',
+            Authorization: `Bearer ${apiKey}`,
+            'User-Agent': 'opencode-quota-sidebar',
+        },
+    }, config.quota.requestTimeoutMs).catch(swallow('fetchKimiForCodingQuota: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('fetchKimiForCodingQuota:json'));
+    if (!isRecord(payload)) {
+        return {
+            ...base,
+            status: 'error',
+            checkedAt,
+            note: 'invalid response',
+        };
+    }
+    const windows = Array.isArray(payload.limits)
+        ? payload.limits.map((item) => parseWindow(item)).filter(Boolean)
+        : [];
+    const usage = isRecord(payload.usage) ? payload.usage : undefined;
+    const topLevelRemainingPercent = usage
+        ? percentFromQuota(usage.limit, usage.remaining)
+        : undefined;
+    const topLevelResetAt = usage ? toIso(usage.resetTime) : undefined;
+    const allWindows = dedupeWindows([
+        ...windows,
+        topLevelRemainingPercent !== undefined
+            ? {
+                label: 'Weekly',
+                remainingPercent: topLevelRemainingPercent,
+                resetAt: topLevelResetAt,
+            }
+            : undefined,
+    ].filter((value) => Boolean(value))).sort((left, right) => {
+        const order = (label) => {
+            if (label === '5h')
+                return 0;
+            if (label === 'Weekly')
+                return 1;
+            return 2;
+        };
+        return order(left.label) - order(right.label);
+    });
+    const primary = allWindows[0];
+    return {
+        ...base,
+        status: primary ? 'ok' : 'error',
+        checkedAt,
+        remainingPercent: primary?.remainingPercent,
+        resetAt: primary?.resetAt,
+        note: primary ? undefined : 'missing quota fields',
+        windows: allWindows.length > 0 ? allWindows : undefined,
+    };
+}
+export const kimiForCodingAdapter = {
+    id: 'kimi-for-coding',
+    label: 'Kimi For Coding',
+    shortLabel: 'Kimi',
+    sortOrder: 15,
+    normalizeID: (providerID) => providerID === 'kimi-for-coding' ? 'kimi-for-coding' : undefined,
+    matchScore: ({ providerID, providerOptions }) => {
+        if (providerID === 'kimi-for-coding')
+            return 100;
+        return isKimiCodingBaseURL(providerOptions?.baseURL) ? 95 : 0;
+    },
+    isEnabled: (config) => configuredProviderEnabled(config.quota, 'kimi-for-coding', true),
+    fetch: fetchKimiForCodingQuota,
+};

package/dist/providers/index.d.ts

@@ -1,9 +1,10 @@
 import { anthropicAdapter } from './core/anthropic.js';
 import { buzzAdapter } from './third_party/buzz.js';
 import { copilotAdapter } from './core/copilot.js';
+import { kimiForCodingAdapter } from './core/kimi_for_coding.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, buzzAdapter, copilotAdapter, openaiAdapter, rightCodeAdapter, QuotaProviderRegistry, };
+export { anthropicAdapter, buzzAdapter, copilotAdapter, kimiForCodingAdapter, openaiAdapter, rightCodeAdapter, QuotaProviderRegistry, };
 export type { AuthUpdate, AuthValue, ProviderResolveContext, QuotaFetchContext, QuotaProviderAdapter, RefreshedOAuthAuth, } from './types.js';

package/dist/providers/index.js

@@ -1,6 +1,7 @@
 import { anthropicAdapter } from './core/anthropic.js';
 import { buzzAdapter } from './third_party/buzz.js';
 import { copilotAdapter } from './core/copilot.js';
+import { kimiForCodingAdapter } from './core/kimi_for_coding.js';
 import { openaiAdapter } from './core/openai.js';
 import { QuotaProviderRegistry } from './registry.js';
 import { rightCodeAdapter } from './third_party/rightcode.js';
@@ -8,9 +9,10 @@ export function createDefaultProviderRegistry() {
     const registry = new QuotaProviderRegistry();
     registry.register(rightCodeAdapter);
     registry.register(buzzAdapter);
+    registry.register(kimiForCodingAdapter);
     registry.register(openaiAdapter);
     registry.register(copilotAdapter);
     registry.register(anthropicAdapter);
     return registry;
 }
-export { anthropicAdapter, buzzAdapter, copilotAdapter, openaiAdapter, rightCodeAdapter, QuotaProviderRegistry, };
+export { anthropicAdapter, buzzAdapter, copilotAdapter, kimiForCodingAdapter, openaiAdapter, rightCodeAdapter, QuotaProviderRegistry, };

package/dist/quota.js

@@ -33,7 +33,7 @@ export function quotaSort(left, right) {
 }
 export function listDefaultQuotaProviderIDs() {
     // Keep default report behavior stable for built-in subscription providers.
-    return ['openai', 'github-copilot', 'anthropic'];
+    return ['openai', 'kimi-for-coding', 'github-copilot', 'anthropic'];
 }
 export function createQuotaRuntime() {
     const providerRegistry = createDefaultProviderRegistry();

package/dist/quota_render.js

@@ -1,5 +1,6 @@
 const PROVIDER_SHORT_LABELS = {
     openai: 'OpenAI',
+    'kimi-for-coding': 'Kimi',
     'github-copilot': 'Copilot',
     anthropic: 'Anthropic',
     rightcode: 'RC',

package/dist/quota_service.js

@@ -11,6 +11,7 @@ export function createQuotaService(deps) {
     const authCache = new TtlValueCache();
     const providerOptionsCache = new TtlValueCache();
     const inFlight = new Map();
+    let lastSuccessfulProviderOptionsMap = {};
     const authFingerprint = (auth) => {
         if (!auth || typeof auth !== 'object')
             return undefined;
@@ -46,7 +47,7 @@ export function createQuotaService(deps) {
         if (cached)
             return cached;
         const value = await loadAuthMap(deps.authPath);
-        return authCache.set(value, 30_000);
+        return authCache.set(value, 5_000);
     };
     const getProviderOptionsMap = async () => {
         const cached = providerOptionsCache.get();
@@ -58,23 +59,142 @@ export function createQuotaService(deps) {
         }
         // Newer runtimes expose config.providers; older clients may only expose
         // provider.list with a slightly different response shape.
-        const response = await (client.config?.providers
-            ? client.config.providers({
+        let response;
+        let fromConfigProviders = false;
+        if (client.config?.providers) {
+            fromConfigProviders = true;
+            response = await client.config
+                .providers({
                 query: { directory: deps.directory },
                 throwOnError: true,
             })
-            : client.provider.list({
+                .catch(swallow('getProviderOptionsMap:configProviders'));
+        }
+        if (!response && client.provider?.list) {
+            response = await client.provider
+                .list({
                 query: { directory: deps.directory },
                 throwOnError: true,
-            })).catch(swallow('getProviderOptionsMap'));
-        const data = isRecord(response) && isRecord(response.data) ? response.data : undefined;
-        const list = Array.isArray(data?.providers)
-            ? data.providers
-            : Array.isArray(data?.all)
-                ? data.all
+            })
+                .catch(swallow('getProviderOptionsMap:providerList'));
+        }
+        const data = isRecord(response) && Object.prototype.hasOwnProperty.call(response, 'data')
+            ? response.data
+            : undefined;
+        if (!response || data === undefined) {
+            if (client.provider?.list && fromConfigProviders) {
+                response = await client.provider
+                    .list({
+                    query: { directory: deps.directory },
+                    throwOnError: true,
+                })
+                    .catch(swallow('getProviderOptionsMap:providerListNoDataFallback'));
+                const fallbackData = isRecord(response) && Object.prototype.hasOwnProperty.call(response, 'data')
+                    ? response.data
+                    : undefined;
+                const fallbackRecord = isRecord(fallbackData) ? fallbackData : undefined;
+                const fallbackList = Array.isArray(fallbackRecord?.providers)
+                    ? fallbackRecord.providers
+                    : Array.isArray(fallbackRecord?.all)
+                        ? fallbackRecord.all
+                        : Array.isArray(fallbackData)
+                            ? fallbackData
+                            : undefined;
+                const map = Array.isArray(fallbackList)
+                    ? fallbackList.reduce((acc, item) => {
+                        if (!item || typeof item !== 'object')
+                            return acc;
+                        const record = item;
+                        const id = record.id;
+                        const options = record.options;
+                        const key = record.key;
+                        if (typeof id !== 'string')
+                            return acc;
+                        if (!options || typeof options !== 'object' || Array.isArray(options)) {
+                            acc[id] =
+                                typeof key === 'string' && key ? { apiKey: key } : {};
+                            return acc;
+                        }
+                        const optionsRecord = options;
+                        acc[id] = {
+                            ...optionsRecord,
+                            ...(typeof key === 'string' && key && optionsRecord.apiKey === undefined
+                                ? { apiKey: key }
+                                : {}),
+                        };
+                        return acc;
+                    }, {})
+                    : {};
+                if (Object.keys(map).length > 0) {
+                    lastSuccessfulProviderOptionsMap = map;
+                    return providerOptionsCache.set(map, 5_000);
+                }
+            }
+            return Object.keys(lastSuccessfulProviderOptionsMap).length > 0
+                ? lastSuccessfulProviderOptionsMap
+                : {};
+        }
+        const dataRecord = isRecord(data) ? data : undefined;
+        const list = Array.isArray(dataRecord?.providers)
+            ? dataRecord.providers
+            : Array.isArray(dataRecord?.all)
+                ? dataRecord.all
                 : Array.isArray(data)
                     ? data
                     : undefined;
+        if (!list && fromConfigProviders && client.provider?.list) {
+            response = await client.provider
+                .list({
+                query: { directory: deps.directory },
+                throwOnError: true,
+            })
+                .catch(swallow('getProviderOptionsMap:providerListFallback'));
+            const fallbackData = isRecord(response) && Object.prototype.hasOwnProperty.call(response, 'data')
+                ? response.data
+                : undefined;
+            const fallbackRecord = isRecord(fallbackData) ? fallbackData : undefined;
+            const fallbackList = Array.isArray(fallbackRecord?.providers)
+                ? fallbackRecord.providers
+                : Array.isArray(fallbackRecord?.all)
+                    ? fallbackRecord.all
+                    : Array.isArray(fallbackData)
+                        ? fallbackData
+                        : undefined;
+            const map = Array.isArray(fallbackList)
+                ? fallbackList.reduce((acc, item) => {
+                    if (!item || typeof item !== 'object')
+                        return acc;
+                    const record = item;
+                    const id = record.id;
+                    const options = record.options;
+                    const key = record.key;
+                    if (typeof id !== 'string')
+                        return acc;
+                    if (!options || typeof options !== 'object' || Array.isArray(options)) {
+                        acc[id] = typeof key === 'string' && key ? { apiKey: key } : {};
+                        return acc;
+                    }
+                    const optionsRecord = options;
+                    acc[id] = {
+                        ...optionsRecord,
+                        ...(typeof key === 'string' && key && optionsRecord.apiKey === undefined
+                            ? { apiKey: key }
+                            : {}),
+                    };
+                    return acc;
+                }, {})
+                : {};
+            if (Object.keys(map).length > 0) {
+                lastSuccessfulProviderOptionsMap = map;
+                return providerOptionsCache.set(map, 5_000);
+            }
+            if (!Array.isArray(fallbackList)) {
+                return Object.keys(lastSuccessfulProviderOptionsMap).length > 0
+                    ? lastSuccessfulProviderOptionsMap
+                    : {};
+            }
+            return providerOptionsCache.set(map, 5_000);
+        }
         const map = Array.isArray(list)
             ? list.reduce((acc, item) => {
                 if (!item || typeof item !== 'object')
@@ -82,18 +202,34 @@ export function createQuotaService(deps) {
                 const record = item;
                 const id = record.id;
                 const options = record.options;
+                const key = record.key;
                 if (typeof id !== 'string')
                     return acc;
                 if (!options ||
                     typeof options !== 'object' ||
                     Array.isArray(options)) {
-                    acc[id] = {};
+                    acc[id] = typeof key === 'string' && key ? { apiKey: key } : {};
                     return acc;
                 }
-                acc[id] = options;
+                const optionsRecord = options;
+                acc[id] = {
+                    ...optionsRecord,
+                    ...(typeof key === 'string' && key && optionsRecord.apiKey === undefined
+                        ? { apiKey: key }
+                        : {}),
+                };
                 return acc;
             }, {})
             : {};
+        if (Object.keys(map).length > 0) {
+            lastSuccessfulProviderOptionsMap = map;
+            return providerOptionsCache.set(map, 5_000);
+        }
+        if (!Array.isArray(list)) {
+            return Object.keys(lastSuccessfulProviderOptionsMap).length > 0
+                ? lastSuccessfulProviderOptionsMap
+                : providerOptionsCache.set(map, 5_000);
+        }
         return providerOptionsCache.set(map, 5_000);
     };
     const isValidQuotaCache = (snapshot) => {
@@ -276,7 +412,11 @@ export function createQuotaService(deps) {
                     body: next,
                     throwOnError: true,
                 })
-                    .catch(swallow('getQuotaSnapshots:authSet'));
+                    .catch((error) => {
+                    swallow('getQuotaSnapshots:authSet')(error);
+                    throw error;
+                });
+                authCache.clear();
             }, providerOptions)
                 .then((latest) => {
                 if (!latest)

package/dist/storage_parse.js

@@ -27,6 +27,7 @@ function parseProviderUsage(value) {
         cost: asNumber(value.cost, 0),
         apiCost: asNumber(value.apiCost, 0),
         assistantMessages: asNumber(value.assistantMessages, 0),
+        cacheBuckets: parseCacheUsageBuckets(value.cacheBuckets),
     };
 }
 function parseCacheUsageBucket(value) {

package/dist/title_apply.d.ts

@@ -17,16 +17,32 @@ export declare function createTitleApplicator(deps: {
     scheduleParentRefreshIfSafe: (sessionID: string, parentID?: string) => void;
     restoreConcurrency: number;
 }): {
-    applyTitle: (sessionID: string) => Promise<void>;
+    applyTitle: (sessionID: string) => Promise<boolean>;
     handleSessionUpdatedTitle: (args: {
         sessionID: string;
         incomingTitle: string;
         sessionState: SessionState;
         scheduleRefresh: (sessionID: string, delay?: number) => void;
     }) => Promise<void>;
-    restoreSessionTitle: (sessionID: string) => Promise<void>;
-    restoreAllVisibleTitles: () => Promise<void>;
-    refreshAllTouchedTitles: () => Promise<void>;
-    refreshAllVisibleTitles: () => Promise<void>;
+    restoreSessionTitle: (sessionID: string, options?: {
+        abortIfEnabled?: boolean;
+    }) => Promise<boolean>;
+    restoreAllVisibleTitles: (options?: {
+        abortIfEnabled?: boolean;
+    }) => Promise<{
+        attempted: number;
+        restored: number;
+        listFailed: boolean;
+    }>;
+    refreshAllTouchedTitles: () => Promise<{
+        attempted: number;
+        refreshed: number;
+        listFailed: boolean;
+    }>;
+    refreshAllVisibleTitles: () => Promise<{
+        attempted: number;
+        refreshed: number;
+        listFailed: boolean;
+    }>;
     forgetSession: (sessionID: string) => void;
 };