@leo000001/opencode-quota-sidebar 2.0.2 → 2.0.5

package/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+- Add built-in `kimi-for-coding` subscription quota support via `GET https://api.kimi.com/coding/v1/usages`.
+- Parse Kimi's `5h` and `Weekly` windows, including reset timestamps, and render them like other subscription providers.
+- Accept OpenCode provider discovery responses that expose Kimi API keys through provider `key` fields.
 - Add Buzz API balance support for OpenAI-compatible providers that use a Buzz `baseURL`.
 - Document Buzz configuration, rendering, and outbound billing endpoints.
 - Keep session measured cost aligned with OpenCode root-session `message.cost` while still including descendant subagent usage in API-equivalent cost.

package/CONTRIBUTING.md

@@ -19,6 +19,7 @@ The plugin now uses a provider adapter registry, so adding a new provider does n
 - `baseURL` match: best for OpenAI-compatible relays such as RightCode or Buzz
 - Prefix/variant normalization: best when one provider has multiple runtime IDs
 - Balance-only providers should prefer `balance` over inventing fake percent windows
+- Built-in API-key providers such as `kimi-for-coding` may need both: direct ID matching for the canonical provider and support for OpenCode's discovered `key -> options.apiKey` bridge
 
 ## Add a new provider
 
@@ -70,6 +71,10 @@ If your provider is an OpenAI-compatible relay, prefer matching on
 `providerOptions.baseURL` instead of the runtime `providerID`; that keeps custom
 aliases working without extra user config.
 
+If your provider is built into OpenCode and already has a stable runtime ID
+(for example `kimi-for-coding`), prefer a direct provider-ID match first, then
+add a `baseURL` fallback only when it helps older/custom runtime shapes.
+
 If the new provider should appear in default `quota_summary` reports even when
 it has not yet been used in the current session, also update
 `listDefaultQuotaProviderIDs()` in `src/quota.ts`.
@@ -98,7 +103,7 @@ At minimum:
 - format output if using special fields (e.g. `balance`)
 - cache compatibility if the change replaces an older snapshot shape
 - mixed-provider rendering if the new provider will commonly appear next to
-  OpenAI/Copilot/RightCode in sidebar or toast output
+  OpenAI/Copilot/Kimi/RightCode in sidebar or toast output
 
 If the provider introduces new rendering rules or multi-window behavior, add
 coverage in both `src/__tests__/quota.test.ts` and `src/__tests__/format.test.ts`.

package/README.md

@@ -41,13 +41,15 @@ On Windows, use forward slashes: `"file:///D:/Lab/opencode-quota-sidebar/dist/in
 
 ## Supported quota providers
 
-| Provider       | Endpoint                               | Auth            | Status                                  |
-| -------------- | -------------------------------------- | --------------- | --------------------------------------- |
-| OpenAI Codex   | `chatgpt.com/backend-api/wham/usage`   | OAuth (ChatGPT) | Multi-window (short-term + weekly)      |
-| GitHub Copilot | `api.github.com/copilot_internal/user` | OAuth           | Monthly quota                           |
-| RightCode      | `www.right.codes/account/summary`      | API key         | Subscription or balance (by prefix)     |
-| Buzz           | `buzzai.cc/v1/dashboard/billing/*`     | API key         | Balance only (computed from total-used) |
-| Anthropic      | `api.anthropic.com/api/oauth/usage`    | OAuth           | Multi-window (5h + weekly / plan-based) |
+| Provider        | Endpoint                               | Auth                  | Status                                  |
+| --------------- | -------------------------------------- | --------------------- | --------------------------------------- |
+| OpenAI Codex    | `chatgpt.com/backend-api/wham/usage`   | OAuth (ChatGPT)       | Multi-window (short-term + weekly)      |
+| GitHub Copilot  | `api.github.com/copilot_internal/user` | OAuth                 | Monthly quota                           |
+| Kimi For Coding | `api.kimi.com/coding/v1/usages`        | API key               | Multi-window subscription (5h + weekly) |
+| RightCode       | `www.right.codes/account/summary`      | API key               | Subscription or balance (by prefix)     |
+| Buzz            | `buzzai.cc/v1/dashboard/billing/*`     | API key               | Balance only (computed from total-used) |
+| Anthropic       | `api.anthropic.com/api/oauth/usage`    | OAuth                 | Multi-window (5h + weekly / plan-based) |
+| XYAI Vibe       | `new.xychatai.com/frontend-api/*`      | Login -> session auth | Daily balance quota with reset time     |
 
 Want to add support for another provider (Google Antigravity, Zhipu AI, Firmware AI, etc.)? See [CONTRIBUTING.md](CONTRIBUTING.md).
 
@@ -62,25 +64,45 @@ Want to add support for another provider (Google Antigravity, Zhipu AI, Firmware
   - next lines: `Cache Coverage` (read/write cache models) and `Cache Read Coverage` (read-only cache models) when enough cache telemetry is available; mixed sessions can show both
   - next line: `$X.XX as API cost` (equivalent API billing for subscription-auth providers)
   - quota lines: quota text like `OpenAI 5h 80% Rst 16:20`; short windows (`5h`, `1d`, `Daily`) show `HH:MM` on same-day resets and `MM-DD HH:MM` when crossing days, while longer windows continue to show `MM-DD`
-  - RightCode daily quota shows `$remaining/$dailyTotal` + expiry (e.g. `RC Daily $105/$60 Exp 02-27`, without trailing percent) and also shows balance on the next indented line when available; `Exp` remains date-only
+  - RightCode daily quota shows `$remaining/$dailyTotal` without trailing percent, and shows balance on the next indented line when available
+  - XYAI daily quota follows the same balance-style layout and prefers the real reset time (for example `XYAI Daily $70.2/$90 Rst 22:18`)
 - Session-scoped usage/quota can include descendant subagent sessions (enabled by default via `sidebar.includeChildren=true`). Traversal is bounded by `childrenMaxDepth` (default 6), `childrenMaxSessions` (default 128), and `childrenConcurrency` (default 5); truncation is logged when `OPENCODE_QUOTA_DEBUG=1`. Day/week/month ranges never merge children — only session scope does.
 - Toast message can include four sections: `Token Usage`, `Cost as API` (per provider), `Provider Cache` (when provider-level cache coverage is available), and `Quota`
+- Expiry reminders are shown in a separate `Expiry Soon` toast section only for providers with real subscription expiry timestamps, and each session shows that auto-reminder at most once
 - `quota_summary` markdown / toast also include `Cache Coverage` and `Cache Read Coverage` summary lines when available
 - Quota snapshots are de-duplicated before rendering to avoid repeated provider lines
 - Custom tools:
   - `quota_summary` — generate usage report for session/day/week/month (markdown + toast)
 - `quota_show` — toggle sidebar title display on/off (state persists across sessions)
 - After startup, titles are restored immediately when persisted display mode is OFF; when persisted display mode is ON, touched titles refresh on startup and the rest update on the next relevant session/message event or when `quota_show` is toggled
-- Quota connectors:
-  - OpenAI Codex OAuth (`/backend-api/wham/usage`)
-  - GitHub Copilot OAuth (`/copilot_internal/user`)
-  - RightCode API key (`/account/summary`)
-  - Buzz API key (`/v1/dashboard/billing/subscription` + `/v1/dashboard/billing/usage`)
-  - Anthropic Claude OAuth (`/api/oauth/usage`, with beta header)
+- Quota connectors:
+  - OpenAI Codex OAuth (`/backend-api/wham/usage`)
+  - GitHub Copilot OAuth (`/copilot_internal/user`)
+  - Kimi For Coding API key (`/usages`, built-in `kimi-for-coding` provider)
+  - RightCode API key (`/account/summary`)
+  - Buzz API key (`/v1/dashboard/billing/subscription` + `/v1/dashboard/billing/usage`)
+  - Anthropic Claude OAuth (`/api/oauth/usage`, with beta header)
+  - XYAI Vibe account login (`/frontend-api/login` -> cached `share-session` -> `/frontend-api/vibe-code/quota`)
 - OpenAI OAuth quota checks auto-refresh expired access token (using refresh token)
-- API key providers still show usage aggregation (quota only applies to subscription providers)
-- Incremental usage aggregation — only processes new messages since last cursor
-- Sidebar token units are adaptive (`k`/`m` with one decimal where applicable)
+- API key providers still show usage aggregation (quota only applies to subscription providers)
+- Incremental usage aggregation — only processes new messages since last cursor
+- Sidebar token units are adaptive (`k`/`m` with one decimal where applicable)
+
+### Kimi For Coding notes
+
+- OpenCode's built-in provider ID is `kimi-for-coding` and its runtime base URL is `https://api.kimi.com/coding/v1`.
+- The plugin treats Kimi as a subscription quota source, not a balance source.
+- Quota data is read from `GET https://api.kimi.com/coding/v1/usages`.
+- The current implementation maps the short rolling window in `limits[]` to `5h` and the top-level `usage` block to `Weekly`.
+- Rendering follows the same compact reset formatting as OpenAI: short windows show `Rst MM-DD HH:MM` when they cross days, and longer windows show `Rst MM-DD`.
+
+### XYAI Vibe notes
+
+- Enable it explicitly under `quota.providers.xyai-vibe.enabled`; it is not enabled by default.
+- Configure login credentials in `quota-sidebar.config.json`, not in source code.
+- The adapter logs in via `POST https://new.xychatai.com/frontend-api/login`, caches the returned `share-session`, and retries quota fetches with that session.
+- Quota data is read from `GET https://new.xychatai.com/frontend-api/vibe-code/quota`.
+- Compact displays show the daily balance and the true reset time when present; expiry stays as secondary report/toast metadata.
 
 ## Storage layout
 
@@ -94,6 +116,7 @@ The plugin stores lightweight global state and date-partitioned session chunks.
   - per-session title state (`baseTitle`, `lastAppliedTitle`)
   - `createdAt`
   - `parentID` (when the session is a subagent child session)
+  - `expiryToastShown` (session-level dedupe for automatic expiry reminders)
   - cached usage summary used by `quota_summary`, including session-level and provider-level `cacheBuckets` for cache coverage reporting
   - incremental aggregation cursor
 
@@ -238,7 +261,7 @@ Quota defaults:
 - `quota.includeOpenAI`: `true`
 - `quota.includeCopilot`: `true`
 - `quota.includeAnthropic`: `true`
-- `quota.providers`: `{}` (per-adapter switches, for example `rightcode.enabled` or `buzz.enabled`)
+- `quota.providers`: `{}` (per-adapter switches and adapter-specific config, for example `rightcode.enabled` or `xyai-vibe.login.username/password`)
 - `quota.refreshAccessToken`: `false`
 - `quota.requestTimeoutMs`: `8000` (clamped to `>=1000`)
 
@@ -455,12 +478,13 @@ Set `OPENCODE_QUOTA_DEBUG=1` to enable debug logging to stderr. This logs:
 ## Security & privacy notes
 
 - The plugin reads OpenCode credentials from `<opencode-data>/auth.json`.
-- If enabled, quota checks call external endpoints:
-  - OpenAI Codex: `https://chatgpt.com/backend-api/wham/usage`
-  - GitHub Copilot: `https://api.github.com/copilot_internal/user`
-  - RightCode: `https://www.right.codes/account/summary`
-  - Buzz: `https://buzzai.cc/v1/dashboard/billing/subscription` and `https://buzzai.cc/v1/dashboard/billing/usage`
-  - Anthropic: `https://api.anthropic.com/api/oauth/usage`
+- If enabled, quota checks call external endpoints:
+  - OpenAI Codex: `https://chatgpt.com/backend-api/wham/usage`
+  - GitHub Copilot: `https://api.github.com/copilot_internal/user`
+  - Kimi For Coding: `https://api.kimi.com/coding/v1/usages`
+  - RightCode: `https://www.right.codes/account/summary`
+  - Buzz: `https://buzzai.cc/v1/dashboard/billing/subscription` and `https://buzzai.cc/v1/dashboard/billing/usage`
+  - Anthropic: `https://api.anthropic.com/api/oauth/usage`
 - **Screen-sharing warning**: Session titles and toasts surface usage/quota
   information. If you are screen-sharing or recording, consider toggling the
   sidebar display off (`/qtoggle` or `quota_show` tool) to avoid leaking
@@ -470,8 +494,9 @@ Set `OPENCODE_QUOTA_DEBUG=1` to enable debug logging to stderr. This logs:
 - OpenAI OAuth token refresh is disabled by default; set
   `quota.refreshAccessToken=true` if you want the plugin to refresh access
   tokens when expired.
-- Anthropic quota currently uses a beta/internal-style OAuth usage endpoint and
-  request header; response fields may change without notice.
+- Anthropic quota currently uses a beta/internal-style OAuth usage endpoint and
+  request header; response fields may change without notice.
+- Kimi For Coding quota uses the current `/usages` response shape exposed by the Kimi coding service; if Kimi changes that payload, window parsing may need to be updated.
 - State/chunk file writes refuse to write through symlinked targets (best-effort defense-in-depth).
 - The `OPENCODE_QUOTA_DATA_HOME` env var overrides the OpenCode data directory
   path (for testing); do not set this in production.

package/SECURITY.md

@@ -25,7 +25,7 @@ We will acknowledge reports as quickly as possible and provide a remediation tim
 - Keep debug logs free of secrets.
 - Prefer fail-closed behavior for writes (already enforced via symlink checks and atomic writes).
 - Quota fetching may contact provider-operated endpoints such as OpenAI, GitHub,
-  RightCode, Buzz, and Anthropic; review any new provider integration for
+  Kimi, RightCode, Buzz, and Anthropic; review any new provider integration for
   outbound data exposure and header/token handling.
 - Some quota integrations rely on beta or internal-style endpoints; document
   instability risks clearly and avoid assuming long-term API compatibility.

package/dist/format.js

@@ -444,6 +444,36 @@ function dateLine(iso) {
         return iso;
     return new Date(time).toLocaleString();
 }
+function expiryAlertLine(iso, nowMs = Date.now()) {
+    if (!iso)
+        return undefined;
+    const timestamp = Date.parse(iso);
+    if (Number.isNaN(timestamp) || timestamp <= nowMs)
+        return undefined;
+    const remainingMs = timestamp - nowMs;
+    const thresholdMs = 3 * 24 * 60 * 60 * 1000;
+    if (remainingMs > thresholdMs)
+        return undefined;
+    const value = new Date(timestamp);
+    const now = new Date(nowMs);
+    const sameDay = value.getFullYear() === now.getFullYear() &&
+        value.getMonth() === now.getMonth() &&
+        value.getDate() === now.getDate();
+    const two = (num) => `${num}`.padStart(2, '0');
+    const hhmm = `${two(value.getHours())}:${two(value.getMinutes())}`;
+    if (sameDay)
+        return `Exp today ${hhmm}`;
+    return `Exp ${two(value.getMonth() + 1)}-${two(value.getDate())} ${hhmm}`;
+}
+function quotaExpiryPairs(quotas, nowMs = Date.now()) {
+    return collapseQuotaSnapshots(quotas)
+        .filter((item) => item.status === 'ok')
+        .map((item) => ({
+        label: quotaDisplayLabel(item),
+        value: expiryAlertLine(item.expiresAt, nowMs),
+    }))
+        .filter((item) => Boolean(item.value));
+}
 function reportResetLine(iso, resetLabel, windowLabel) {
     const compact = compactReset(iso, resetLabel, windowLabel);
     if (compact)
@@ -582,13 +612,14 @@ export function renderMarkdownReport(period, usage, quotas, options) {
         // Multi-window detail
         if (quota.windows && quota.windows.length > 0 && quota.status === 'ok') {
             const windowLines = quota.windows.map((win) => {
+                const extraNote = win === quota.windows?.[0] && quota.note ? ` | ${quota.note}` : '';
                 if (win.showPercent === false) {
                     const winLabel = win.label ? ` (${win.label})` : '';
-                    return mdCell(`- ${displayLabel}${winLabel}: ${quota.status} | reset ${reportResetLine(win.resetAt, win.resetLabel, win.label)}`);
+                    return mdCell(`- ${displayLabel}${winLabel}: ${quota.status} | reset ${reportResetLine(win.resetAt, win.resetLabel, win.label)}${extraNote}`);
                 }
                 const remaining = formatQuotaPercent(win.remainingPercent);
                 const winLabel = win.label ? ` (${win.label})` : '';
-                return mdCell(`- ${displayLabel}${winLabel}: ${quota.status} | remaining ${remaining} | reset ${reportResetLine(win.resetAt, win.resetLabel, win.label)}`);
+                return mdCell(`- ${displayLabel}${winLabel}: ${quota.status} | remaining ${remaining} | reset ${reportResetLine(win.resetAt, win.resetLabel, win.label)}${extraNote}`);
             });
             if (quota.balance) {
                 windowLines.push(mdCell(`- ${displayLabel}: ${quota.status} | balance ${formatCurrency(quota.balance.amount, quota.balance.currency)}`));
@@ -785,5 +816,11 @@ export function renderToastMessage(period, usage, quotas, options) {
         lines.push(fitLine('Quota', width));
         lines.push(...alignPairs(quotaPairs).map((line) => fitLine(line, width)));
     }
+    const expiryPairs = quotaExpiryPairs(quotas);
+    if (expiryPairs.length > 0) {
+        lines.push('');
+        lines.push(fitLine('Expiry Soon', width));
+        lines.push(...alignPairs(expiryPairs).map((line) => fitLine(line, width)));
+    }
     return lines.join('\n');
 }

package/dist/index.js

@@ -81,6 +81,7 @@ export async function QuotaSidebarPlugin(input) {
             baseTitle: normalizeBaseTitle(title),
             lastAppliedTitle: undefined,
             parentID: parentID ?? undefined,
+            expiryToastShown: false,
             usage: undefined,
             cursor: undefined,
         };
@@ -236,6 +237,66 @@ export async function QuotaSidebarPlugin(input) {
         })
             .catch(swallow('showToast'));
     };
+    const expiryAlertText = (iso, nowMs = Date.now()) => {
+        if (!iso)
+            return undefined;
+        const timestamp = Date.parse(iso);
+        if (Number.isNaN(timestamp) || timestamp <= nowMs)
+            return undefined;
+        const remainingMs = timestamp - nowMs;
+        const thresholdMs = 3 * 24 * 60 * 60 * 1000;
+        if (remainingMs > thresholdMs)
+            return undefined;
+        const value = new Date(timestamp);
+        const now = new Date(nowMs);
+        const two = (num) => `${num}`.padStart(2, '0');
+        const hhmm = `${two(value.getHours())}:${two(value.getMinutes())}`;
+        const sameDay = value.getFullYear() === now.getFullYear() &&
+            value.getMonth() === now.getMonth() &&
+            value.getDate() === now.getDate();
+        return sameDay
+            ? `Exp today ${hhmm}`
+            : `Exp ${two(value.getMonth() + 1)}-${two(value.getDate())} ${hhmm}`;
+    };
+    const expiryToastInflight = new Set();
+    const maybeShowExpiryToast = async (sessionID) => {
+        const sessionState = state.sessions[sessionID];
+        if (!sessionState)
+            return;
+        if (sessionState.expiryToastShown || expiryToastInflight.has(sessionID)) {
+            return;
+        }
+        expiryToastInflight.add(sessionID);
+        try {
+            const quotas = await getQuotaSnapshots([], { allowDefault: true });
+            const nowMs = Date.now();
+            const expiryLines = quotas
+                .filter((item) => item.status === 'ok')
+                .map((item) => ({
+                label: item.shortLabel || item.label,
+                value: expiryAlertText(item.expiresAt, nowMs),
+            }))
+                .filter((item) => Boolean(item.value));
+            if (expiryLines.length === 0)
+                return;
+            sessionState.expiryToastShown = true;
+            const dateKey = state.sessionDateMap[sessionID] || dateKeyFromTimestamp(sessionState.createdAt);
+            state.sessionDateMap[sessionID] = dateKey;
+            markDirty(dateKey);
+            scheduleSave();
+            const body = [
+                'Expiry Soon',
+                ...expiryLines.map((item) => `${item.label} ${item.value}`),
+            ].join('\n');
+            await showToast('session', body);
+        }
+        catch (error) {
+            debug(`expiry toast check failed: ${String(error)}`);
+        }
+        finally {
+            expiryToastInflight.delete(sessionID);
+        }
+    };
     const dispatchEvent = createEventDispatcher({
         onSessionCreated: async (session) => {
             ensureSessionState(session.id, session.title, session.time.created, session.parentID ?? null);
@@ -295,6 +356,7 @@ export async function QuotaSidebarPlugin(input) {
         onAssistantMessageCompleted: async (message) => {
             usageService.markSessionDirty(message.sessionID);
             titleRefresh.schedule(message.sessionID);
+            void maybeShowExpiryToast(message.sessionID);
         },
     });
     return {

package/dist/providers/common.d.ts

@@ -18,6 +18,7 @@ export declare function asRecord(value: unknown): Record<string, unknown> | unde
 export declare function configuredProviderEnabled(config: {
     providers?: Record<string, {
         enabled?: boolean;
+        [key: string]: unknown;
     }>;
 }, adapterID: string, fallback?: boolean): boolean;
 export declare function sanitizeBaseURL(value: unknown): string | undefined;

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

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

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,11 @@
 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';
+import { xyaiVibeAdapter } from './third_party/xyai_vibe.js';
 export declare function createDefaultProviderRegistry(): QuotaProviderRegistry;
-export { anthropicAdapter, buzzAdapter, copilotAdapter, openaiAdapter, rightCodeAdapter, QuotaProviderRegistry, };
+export { anthropicAdapter, buzzAdapter, copilotAdapter, kimiForCodingAdapter, openaiAdapter, rightCodeAdapter, xyaiVibeAdapter, QuotaProviderRegistry, };
 export type { AuthUpdate, AuthValue, ProviderResolveContext, QuotaFetchContext, QuotaProviderAdapter, RefreshedOAuthAuth, } from './types.js';

package/dist/providers/index.js

@@ -1,16 +1,20 @@
 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';
+import { xyaiVibeAdapter } from './third_party/xyai_vibe.js';
 export function createDefaultProviderRegistry() {
     const registry = new QuotaProviderRegistry();
     registry.register(rightCodeAdapter);
     registry.register(buzzAdapter);
+    registry.register(xyaiVibeAdapter);
+    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, xyaiVibeAdapter, QuotaProviderRegistry, };

package/dist/providers/third_party/rightcode.js

@@ -182,8 +182,6 @@ async function fetchRightCodeQuota(ctx) {
                 label: `Daily $${formatQuotaValue(dailyRemaining)}/$${formatQuotaValue(dailyTotal)}`,
                 showPercent: false,
                 remainingPercent: dailyPercent,
-                resetAt: expiry,
-                resetLabel: hasMultipleExpiries ? 'Exp+' : 'Exp',
             },
         ];
         const names = matched.map((subscription) => subscription.name).join(', ');
@@ -192,6 +190,7 @@ async function fetchRightCodeQuota(ctx) {
             status: dailyPercent === undefined ? 'error' : 'ok',
             checkedAt,
             remainingPercent: dailyPercent,
+            expiresAt: expiry,
             balance: balance === undefined
                 ? undefined
                 : {
@@ -201,7 +200,7 @@ async function fetchRightCodeQuota(ctx) {
             windows,
             note: dailyPercent === undefined
                 ? 'matched subscription has no daily quota fields'
-                : `subscription daily quota: ${names}`,
+                : `subscription daily quota: ${names}${expiry ? ` | exp ${expiry.slice(5, 10)}` : ''}${hasMultipleExpiries ? '+' : ''}`,
         };
     }
     if (balance !== undefined) {

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

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

package/dist/providers/third_party/xyai_vibe.js

@@ -0,0 +1,314 @@
+import { debugError, isRecord, swallow } from '../../helpers.js';
+import { asNumber, configuredProviderEnabled, fetchWithTimeout, sanitizeBaseURL, toIso, } from '../common.js';
+const XYAI_BASE_URL = 'https://new.xychatai.com';
+function resolveSiteOrigin(value) {
+    const normalized = sanitizeBaseURL(value);
+    if (!normalized)
+        return XYAI_BASE_URL;
+    try {
+        return new URL(normalized).origin;
+    }
+    catch {
+        return XYAI_BASE_URL;
+    }
+}
+function isXyaiBaseURL(value) {
+    const normalized = sanitizeBaseURL(value);
+    if (!normalized)
+        return false;
+    try {
+        const parsed = new URL(normalized);
+        return parsed.protocol === 'https:' && parsed.host === 'new.xychatai.com';
+    }
+    catch {
+        return false;
+    }
+}
+function providerConfigFor(config, providerIDs) {
+    for (const providerID of providerIDs) {
+        if (!providerID)
+            continue;
+        const value = config.quota.providers?.[providerID];
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function resolveSessionCookie(auth, providerConfig) {
+    if (typeof providerConfig?.sessionCookie === 'string' &&
+        providerConfig.sessionCookie) {
+        return providerConfig.sessionCookie;
+    }
+    if (!auth)
+        return undefined;
+    if (auth.type === 'wellknown') {
+        if (typeof auth.token === 'string' && auth.token)
+            return auth.token;
+    }
+    return undefined;
+}
+function resolveServiceType(providerConfig) {
+    return providerConfig?.serviceType === 'claudecode' ? 'claudecode' : 'codex';
+}
+function resolveLogin(providerConfig) {
+    const login = providerConfig?.login;
+    if (!login || typeof login !== 'object' || Array.isArray(login)) {
+        return undefined;
+    }
+    const username = typeof login.username === 'string' ? login.username.trim() : '';
+    const password = typeof login.password === 'string' ? login.password : '';
+    if (!username || !password)
+        return undefined;
+    return { username, password };
+}
+function headerCookies(response) {
+    const headers = response.headers;
+    if (typeof headers.getSetCookie === 'function') {
+        return headers.getSetCookie().filter(Boolean);
+    }
+    const joined = response.headers.get('set-cookie');
+    return joined ? [joined] : [];
+}
+function extractShareSession(response) {
+    for (const value of headerCookies(response)) {
+        const match = value.match(/share-session=("?)([^;"]+)\1/);
+        if (match?.[2])
+            return match[2];
+    }
+    return undefined;
+}
+async function loginAndPersistSession(siteOrigin, login, providerID, updateAuth, timeoutMs) {
+    const response = await fetchWithTimeout(`${siteOrigin}/frontend-api/login`, {
+        method: 'POST',
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+            'User-Agent': 'opencode-quota-sidebar',
+        },
+        body: JSON.stringify({
+            userToken: login.username,
+            password: login.password,
+            token: '',
+        }),
+    }, timeoutMs).catch(swallow('fetchXyaiVibeQuota:login'));
+    if (!response) {
+        return { error: 'login request failed' };
+    }
+    if (!response.ok) {
+        return { error: `login http ${response.status}` };
+    }
+    const payload = await response.json().catch(swallow('fetchXyaiVibeQuota:loginJson'));
+    if (!isRecord(payload)) {
+        return { error: 'invalid login response' };
+    }
+    if (payload.code !== 1) {
+        const msg = typeof payload.msg === 'string' && payload.msg ? payload.msg : 'login failed';
+        return { error: msg };
+    }
+    const session = extractShareSession(response);
+    if (!session) {
+        return { error: 'missing share-session cookie' };
+    }
+    if (updateAuth) {
+        try {
+            await updateAuth(providerID, { type: 'wellknown', token: session });
+        }
+        catch (error) {
+            debugError('updateAuth:xyai-vibe', error);
+            return {
+                session,
+                warning: 'session refreshed but failed to persist; using in-memory session',
+            };
+        }
+    }
+    return { session };
+}
+async function fetchQuotaPayload(siteOrigin, session, timeoutMs) {
+    const response = await fetchWithTimeout(`${siteOrigin}/frontend-api/vibe-code/quota`, {
+        headers: {
+            Accept: 'application/json',
+            Cookie: `share-session=${session}`,
+            'User-Agent': 'opencode-quota-sidebar',
+        },
+    }, timeoutMs).catch(swallow('fetchXyaiVibeQuota:quota'));
+    if (!response)
+        return { error: 'network request failed' };
+    if (!response.ok)
+        return { error: `http ${response.status}` };
+    const payload = await response.json().catch(swallow('fetchXyaiVibeQuota:quotaJson'));
+    if (!isRecord(payload))
+        return { error: 'invalid response' };
+    return { payload };
+}
+function isAuthFailure(payload) {
+    return payload.code === -1 || payload.msg === '认证失败，请重新登录';
+}
+function formatAmount(value) {
+    if (!Number.isFinite(value))
+        return '0';
+    if (Math.abs(value) >= 10) {
+        const one = value.toFixed(1);
+        return one.endsWith('.0') ? one.slice(0, -2) : one;
+    }
+    return value.toFixed(2);
+}
+function pickServicePayload(payload, preferred) {
+    const source = isRecord(payload.data) ? payload.data : payload;
+    const ordered = preferred === 'claudecode' ? ['claudecode', 'codex'] : ['codex', 'claudecode'];
+    for (const key of ordered) {
+        const value = source[key];
+        if (isRecord(value))
+            return { serviceType: key, value };
+    }
+    return undefined;
+}
+function parseQuotaSnapshot(args) {
+    const base = {
+        providerID: args.providerID,
+        adapterID: 'xyai-vibe',
+        label: 'XYAI Vibe',
+        shortLabel: 'XYAI',
+        sortOrder: 7,
+    };
+    const subscriptions = isRecord(args.payload.subscriptions)
+        ? args.payload.subscriptions
+        : undefined;
+    const usage = isRecord(args.payload.currentUsage) ? args.payload.currentUsage : undefined;
+    const amountLimit = asNumber(subscriptions?.amountLimit);
+    const remainingAmount = asNumber(subscriptions?.remainingAmount);
+    const periodResetTime = toIso(subscriptions?.periodResetTime);
+    const expireTime = toIso(subscriptions?.expireTime);
+    if (amountLimit === undefined || remainingAmount === undefined) {
+        return {
+            ...base,
+            status: 'error',
+            checkedAt: args.checkedAt,
+            note: 'missing quota fields',
+        };
+    }
+    const remainingPercent = amountLimit > 0 ? Math.max(0, Math.min(100, (remainingAmount / amountLimit) * 100)) : undefined;
+    const windows = [
+        {
+            label: `Daily $${formatAmount(remainingAmount)}/$${formatAmount(amountLimit)}`,
+            showPercent: false,
+            remainingPercent,
+            resetAt: periodResetTime,
+            resetLabel: 'Rst',
+        },
+    ];
+    const noteParts = [
+        expireTime ? `exp ${expireTime.slice(5, 10)}` : undefined,
+        args.serviceType === 'claudecode' ? 'service=claudecode' : undefined,
+        args.warning,
+    ].filter((value) => Boolean(value));
+    return {
+        ...base,
+        status: 'ok',
+        checkedAt: args.checkedAt,
+        remainingPercent,
+        resetAt: periodResetTime,
+        expiresAt: expireTime,
+        note: noteParts.join(' | ') || undefined,
+        windows,
+    };
+}
+async function fetchXyaiVibeQuota(ctx) {
+    const checkedAt = Date.now();
+    const runtimeProviderID = typeof ctx.sourceProviderID === 'string' && ctx.sourceProviderID
+        ? ctx.sourceProviderID
+        : ctx.providerID;
+    const providerConfig = providerConfigFor(ctx.config, [
+        runtimeProviderID,
+        ctx.providerID,
+        'xyai-vibe',
+    ]);
+    const siteOrigin = resolveSiteOrigin(providerConfig?.baseURL ?? ctx.providerOptions?.baseURL);
+    const serviceType = resolveServiceType(providerConfig);
+    const base = {
+        providerID: runtimeProviderID,
+        adapterID: 'xyai-vibe',
+        label: 'XYAI Vibe',
+        shortLabel: 'XYAI',
+        sortOrder: 7,
+    };
+    let session = resolveSessionCookie(ctx.auth, providerConfig);
+    const login = resolveLogin(providerConfig);
+    let warning;
+    if (!session && login) {
+        const loginResult = await loginAndPersistSession(siteOrigin, login, ctx.providerID, ctx.updateAuth, ctx.config.quota.requestTimeoutMs);
+        if ('error' in loginResult) {
+            return {
+                ...base,
+                status: 'unavailable',
+                checkedAt,
+                note: loginResult.error,
+            };
+        }
+        session = loginResult.session;
+        warning = loginResult.warning;
+    }
+    if (!session) {
+        return {
+            ...base,
+            status: 'unavailable',
+            checkedAt,
+            note: 'missing share-session or login credentials',
+        };
+    }
+    let quotaResult = await fetchQuotaPayload(siteOrigin, session, ctx.config.quota.requestTimeoutMs);
+    if (!('error' in quotaResult) && isAuthFailure(quotaResult.payload) && login) {
+        const loginResult = await loginAndPersistSession(siteOrigin, login, ctx.providerID, ctx.updateAuth, ctx.config.quota.requestTimeoutMs);
+        if (!('error' in loginResult)) {
+            session = loginResult.session;
+            warning = loginResult.warning ?? warning;
+            quotaResult = await fetchQuotaPayload(siteOrigin, session, ctx.config.quota.requestTimeoutMs);
+        }
+    }
+    if ('error' in quotaResult) {
+        return {
+            ...base,
+            status: 'error',
+            checkedAt,
+            note: quotaResult.error,
+        };
+    }
+    if (isAuthFailure(quotaResult.payload)) {
+        return {
+            ...base,
+            status: 'unavailable',
+            checkedAt,
+            note: 'auth expired',
+        };
+    }
+    const service = pickServicePayload(quotaResult.payload, serviceType);
+    if (!service) {
+        return {
+            ...base,
+            status: 'error',
+            checkedAt,
+            note: 'missing service payload',
+        };
+    }
+    return parseQuotaSnapshot({
+        providerID: runtimeProviderID,
+        serviceType: service.serviceType,
+        payload: service.value,
+        checkedAt,
+        warning,
+    });
+}
+export const xyaiVibeAdapter = {
+    id: 'xyai-vibe',
+    label: 'XYAI Vibe',
+    shortLabel: 'XYAI',
+    sortOrder: 7,
+    normalizeID: (providerID) => (providerID === 'xyai-vibe' ? 'xyai-vibe' : undefined),
+    matchScore: ({ providerID, providerOptions }) => {
+        if (providerID === 'xyai-vibe')
+            return 100;
+        return isXyaiBaseURL(providerOptions?.baseURL) ? 95 : 0;
+    },
+    isEnabled: (config) => configuredProviderEnabled(config.quota, 'xyai-vibe', false),
+    fetch: fetchXyaiVibeQuota,
+};

package/dist/providers/types.d.ts

@@ -25,7 +25,7 @@ export type RefreshedOAuthAuth = {
     accountId?: string;
     enterpriseUrl?: string;
 };
-export type AuthUpdate = (providerID: string, auth: RefreshedOAuthAuth) => Promise<void>;
+export type AuthUpdate = (providerID: string, auth: AuthValue) => Promise<void>;
 export type ProviderResolveContext = {
     providerID: string;
     providerOptions?: Record<string, unknown>;

package/dist/quota.d.ts

@@ -17,6 +17,7 @@ export declare function createQuotaRuntime(): {
         remainingPercent?: number;
         usedPercent?: number;
         resetAt?: string;
+        expiresAt?: string;
         balance?: {
             amount: number;
             currency: string;
@@ -40,6 +41,7 @@ export declare function fetchQuotaSnapshot(providerID: string, authMap: Record<s
     remainingPercent?: number;
     usedPercent?: number;
     resetAt?: string;
+    expiresAt?: string;
     balance?: {
         amount: number;
         currency: string;

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

@@ -107,13 +107,21 @@ 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;
                     }, {})
                     : {};
@@ -159,13 +167,20 @@ 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;
                 }, {})
                 : {};
@@ -187,15 +202,22 @@ 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;
             }, {})
             : {};

package/dist/storage.js

@@ -56,9 +56,27 @@ export async function loadConfig(paths) {
             ...Object.entries(providers).reduce((acc, [id, value]) => {
                 if (!isRecord(value))
                     return acc;
-                if (typeof value.enabled === 'boolean') {
-                    acc[id] = { enabled: value.enabled };
-                }
+                const baseProvider = isRecord(base.quota.providers?.[id])
+                    ? base.quota.providers?.[id]
+                    : {};
+                const baseLogin = isRecord(baseProvider.login)
+                    ? baseProvider.login
+                    : undefined;
+                const nextLogin = isRecord(value.login)
+                    ? value.login
+                    : undefined;
+                acc[id] = {
+                    ...baseProvider,
+                    ...value,
+                    ...(baseLogin || nextLogin
+                        ? {
+                            login: {
+                                ...(baseLogin || {}),
+                                ...(nextLogin || {}),
+                            },
+                        }
+                        : {}),
+                };
                 return acc;
             }, {}),
         };

package/dist/storage_parse.js

@@ -116,6 +116,7 @@ export function parseSessionState(value) {
         ...title,
         createdAt,
         parentID: typeof value.parentID === 'string' ? value.parentID : undefined,
+        expiryToastShown: value.expiryToastShown === true,
         usage: parseCachedUsage(value.usage),
         dirty: value.dirty === true,
         cursor: parseCursor(value.cursor),
@@ -182,6 +183,7 @@ export function parseQuotaCache(value) {
                 : undefined,
             usedPercent: typeof item.usedPercent === 'number' ? item.usedPercent : undefined,
             resetAt: typeof item.resetAt === 'string' ? item.resetAt : undefined,
+            expiresAt: typeof item.expiresAt === 'string' ? item.expiresAt : undefined,
             balance,
             note: typeof item.note === 'string' ? item.note : undefined,
             windows,

package/dist/types.d.ts

@@ -23,6 +23,7 @@ export type QuotaSnapshot = {
     remainingPercent?: number;
     usedPercent?: number;
     resetAt?: string;
+    expiresAt?: string;
     /** Balance-style quota (for providers that expose balance instead of percent). */
     balance?: {
         amount: number;
@@ -32,6 +33,10 @@ export type QuotaSnapshot = {
     /** Multi-window quota (e.g. OpenAI short-term + weekly). */
     windows?: QuotaWindow[];
 };
+export type QuotaProviderConfig = {
+    enabled?: boolean;
+    [key: string]: unknown;
+};
 export type SessionTitleState = {
     baseTitle: string;
     lastAppliedTitle?: string;
@@ -111,6 +116,8 @@ export type SessionState = SessionTitleState & {
     createdAt: number;
     /** Parent session ID for subagent child sessions. */
     parentID?: string;
+    /** Whether this session has already shown an auto expiry toast. */
+    expiryToastShown?: boolean;
     usage?: CachedSessionUsage;
     /** Persisted dirtiness flag so descendant aggregation survives restart. */
     dirty?: boolean;
@@ -161,9 +168,7 @@ export type QuotaSidebarConfig = {
         includeCopilot: boolean;
         includeAnthropic: boolean;
         /** Generic per-adapter switches (e.g. rightcode). */
-        providers?: Record<string, {
-            enabled?: boolean;
-        }>;
+        providers?: Record<string, QuotaProviderConfig>;
         /** When true, refreshes OpenAI OAuth access token using refresh token */
         refreshAccessToken: boolean;
         /** Timeout for external quota fetches */

package/package.json

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

package/quota-sidebar.config.example.json

@@ -19,6 +19,15 @@
     "providers": {
       "rightcode": {
         "enabled": true
+      },
+      "xyai-vibe": {
+        "enabled": false,
+        "baseURL": "https://new.xychatai.com",
+        "serviceType": "codex",
+        "login": {
+          "username": "your-account@example.com",
+          "password": "your-password"
+        }
       }
     },
     "refreshAccessToken": false,