opencode-gemini-rotator 1.1.0

package/CHANGELOG.md

@@ -0,0 +1,43 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.1.0](https://github.com/jianlingzhong/opencode-gemini-rotator/compare/v1.0.0...v1.1.0) (2026-05-24)
+
+### Features
+
+- file-based IPC for TUI sidebar cross-process state ([5cdaa61](https://github.com/jianlingzhong/opencode-gemini-rotator/commit/5cdaa61e523088491a7cefd2ed3687ebbf7ca2ef))
+- hide TUI sidebar when no Gemini activity is detected ([346873e](https://github.com/jianlingzhong/opencode-gemini-rotator/commit/346873e97537c26867b5140f9dcaecffc46550aa))
+- initial implementation of opencode-gemini-rotator plugin ([f7000f7](https://github.com/jianlingzhong/opencode-gemini-rotator/commit/f7000f77ebcd7b6a4809a51cc0110e79c65a6c2e))
+- real-time TUI sidebar status using SolidJS and OpenTUI slots ([177f6af](https://github.com/jianlingzhong/opencode-gemini-rotator/commit/177f6af5cec64851e3cf005a178c07c53a5908a6))
+
+### Bug Fixes
+
+- drop stryker JSDoc type import; defer codeql/scorecard to dispatch-only ([02ead5c](https://github.com/jianlingzhong/opencode-gemini-rotator/commit/02ead5c59a1b66947f47160385b8a44db58e88f3))
+- wrap conditional SolidJS Show in a persistent box element ([16ff883](https://github.com/jianlingzhong/opencode-gemini-rotator/commit/16ff8836f993c9006f0ceaed7b22ae55c091b903))
+
+## [1.0.0] - 2026-05-22
+
+Initial release.
+
+### Features
+
+- Transparent `globalThis.fetch` interceptor scoped to
+  `generativelanguage.googleapis.com`.
+- Multi-key pool from inline config, comma-separated string, or
+  `GEMINI_API_KEYS` environment variable.
+- Smart cooldown derived from `Retry-After` header or `reset after Xs`
+  error message; healthy keys are always preferred.
+- Permanent invalidation for `API_KEY_INVALID` responses (per session).
+- OAuth-aware header routing: `ya29.*` / `Bearer`-prefixed values go
+  in `Authorization`; raw API keys go in `x-goog-api-key`.
+- Real-time TUI sidebar showing active key index, masked value, and
+  pool size.
+- Opt-in debug logging via `OPENCODE_GEMINI_DEBUG=1` or the `logFile`
+  plugin option.
+- `zod`-validated plugin options at the trust boundary.
+- Consistent key masking (`prefix…suffix`) across logs, toasts, and
+  the sidebar.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jianling Zhong
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,309 @@
+# opencode-gemini-rotator
+
+[![CI](https://github.com/jianlingzhong/opencode-gemini-rotator/actions/workflows/ci.yml/badge.svg)](https://github.com/jianlingzhong/opencode-gemini-rotator/actions/workflows/ci.yml)
+[![CodeQL](https://github.com/jianlingzhong/opencode-gemini-rotator/actions/workflows/codeql.yml/badge.svg)](https://github.com/jianlingzhong/opencode-gemini-rotator/actions/workflows/codeql.yml)
+[![npm version](https://img.shields.io/npm/v/opencode-gemini-rotator.svg)](https://www.npmjs.com/package/opencode-gemini-rotator)
+[![npm downloads](https://img.shields.io/npm/dm/opencode-gemini-rotator.svg)](https://www.npmjs.com/package/opencode-gemini-rotator)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node](https://img.shields.io/node/v/opencode-gemini-rotator.svg)](https://nodejs.org)
+
+> **Stop hitting Gemini rate limits.** An [OpenCode](https://opencode.ai)
+> plugin that transparently rotates a pool of Google Gemini API keys when
+> requests get rate-limited (HTTP 429) or quota-exhausted (HTTP 403/503
+> `RESOURCE_EXHAUSTED`). Drop in, configure your keys, forget about quotas.
+
+## Table of contents
+
+- [Why](#why)
+- [Features](#features)
+- [Installation](#installation)
+- [Configuration](#configuration)
+- [How it works](#how-it-works)
+- [Debugging](#debugging)
+- [Development](#development)
+- [Troubleshooting](#troubleshooting)
+- [FAQ](#faq)
+- [Security](#security)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Why
+
+[OpenCode](https://opencode.ai) uses your Gemini API key for every request.
+When you hit your per-key per-minute quota, OpenCode stalls. This plugin
+maintains a small pool of keys and rotates to the next healthy one
+automatically — your session keeps moving without you doing anything.
+
+## Features
+
+- **Pool of keys** — pass keys as an array, comma-separated string, or via
+  the `GEMINI_API_KEYS` environment variable.
+- **Smart cooldowns** — exhausted keys are parked for a cooldown derived
+  from the `Retry-After` header or the error message
+  (e.g. `reset after 30s`); healthy keys are always preferred.
+- **Permanent invalidation** — keys returning `API_KEY_INVALID` are removed
+  from the rotation for the rest of the session.
+- **Transparent interception** — monkey-patches `globalThis.fetch`, so the
+  `@opencode-ai/sdk` and any other code Just Works without modification.
+- **OAuth-aware** — `ya29.*` and `Bearer`-prefixed values are sent in
+  the `Authorization` header; raw API keys go in `x-goog-api-key`.
+- **TUI sidebar** — shows the active key index, masked value, and pool size
+  in the OpenCode right-side panel, refreshed in real time.
+- **Scoped impact** — only requests to `generativelanguage.googleapis.com`
+  are touched; everything else passes straight through to the original
+  `fetch`.
+- **No secrets in logs** — keys are masked (`AIza…1234`) everywhere they
+  surface.
+
+## Installation
+
+Requires **Node 18+** (or Bun) and OpenCode `1.4.3` or newer.
+
+### Option A — npm (recommended)
+
+Just add the package name to your OpenCode config; OpenCode auto-installs
+npm plugins on startup using its bundled Bun. See the upstream
+[plugin docs](https://opencode.ai/docs/plugins/#from-npm).
+
+```json
+{
+    "$schema": "https://opencode.ai/config.json",
+    "plugin": ["opencode-gemini-rotator"]
+}
+```
+
+Then export your keys (or use the inline form below):
+
+```bash
+export GEMINI_API_KEYS="AIza...key1,AIza...key2,AIza...key3"
+opencode
+```
+
+### Option B — Local plugin (clone & build)
+
+```bash
+git clone https://github.com/jianlingzhong/opencode-gemini-rotator.git
+cd opencode-gemini-rotator
+bun install
+bun run build
+```
+
+Then point OpenCode at the absolute path:
+
+```json
+{
+    "$schema": "https://opencode.ai/config.json",
+    "plugin": ["/absolute/path/to/opencode-gemini-rotator"]
+}
+```
+
+## Configuration
+
+OpenCode loads plugins via its config file
+(`~/.config/opencode/opencode.json` or project-local
+`.opencode/opencode.json`).
+
+### Inline keys (per-plugin options)
+
+When you want to keep keys in the config file (instead of an env var),
+use the tuple form `[name, options]`:
+
+```json
+{
+    "$schema": "https://opencode.ai/config.json",
+    "plugin": [
+        [
+            "opencode-gemini-rotator",
+            {
+                "keys": ["AIza...your-first-key", "AIza...your-second-key"]
+            }
+        ]
+    ]
+}
+```
+
+Replace `"opencode-gemini-rotator"` with an absolute path if you're
+running from a local clone.
+
+### Plugin options
+
+| Option    | Type                 | Default                               | Description                                         |
+| --------- | -------------------- | ------------------------------------- | --------------------------------------------------- |
+| `keys`    | `string[] \| string` | `process.env.GEMINI_API_KEYS`         | Pool of API keys.                                   |
+| `logFile` | `string` (path)      | _none_ (logging off unless `DEBUG=1`) | When set, debug telemetry is appended to this file. |
+
+## How it works
+
+### Architecture
+
+```mermaid
+flowchart LR
+    A[OpenCode / SDK] -->|fetch| B[globalThis.fetch hook]
+    B -->|other host| C[Original fetch]
+    B -->|Gemini host| D[GeminiRotator]
+    D -->|pick healthy key| E[Original fetch]
+    E --> F{Response}
+    F -->|2xx| G[Return to caller]
+    F -->|429 / 403 / 400 quota| H[Mark cooldown, rotate]
+    F -->|400 invalid key| I[Mark invalid, rotate]
+    H --> D
+    I --> D
+```
+
+### Request lifecycle
+
+```mermaid
+sequenceDiagram
+    participant App as OpenCode
+    participant Hook as globalThis.fetch
+    participant Rot as GeminiRotator
+    participant API as Gemini API
+
+    App->>Hook: fetch(geminiUrl, init)
+    Hook->>Rot: dispatch (host matches)
+    loop while shouldRotate
+        Rot->>Rot: pick healthiest key
+        Rot->>API: fetch(url, headers w/ key)
+        API-->>Rot: response
+        alt 2xx
+            Rot-->>App: response
+        else 429 / quota
+            Rot->>Rot: park key for cooldown
+        else API_KEY_INVALID
+            Rot->>Rot: mark key invalid (session)
+        end
+    end
+```
+
+### Step-by-step
+
+1. **Init.** Each configured key is registered as healthy
+   (`isValid: true, availableAt: 0`).
+2. **Intercept.** The plugin hooks `globalThis.fetch`. Requests to hosts
+   other than `generativelanguage.googleapis.com` pass through unchanged.
+3. **Key selection.** Any key already present on the inbound request
+   (header or `?key=` query param) is added to the candidate pool so
+   OpenCode's native credentials remain in play.
+4. **Header normalization.** Keys starting with `ya29.` or `Bearer` are
+   placed in the `Authorization` header; everything else goes in
+   `x-goog-api-key`. The `?key=` query param is stripped from the URL.
+5. **Failure & rotation.**
+    - `429` → cooldown 60 s, rotate.
+    - `403`/`503` with `RESOURCE_EXHAUSTED` or quota text → cooldown
+      derived from `Retry-After` header or error message
+      (e.g. `reset after 30s`), rotate.
+    - `400` with `API_KEY_INVALID` → mark the key invalid for the session,
+      rotate.
+    - Anything else → response is returned to the caller untouched.
+6. **All-on-cooldown.** If every key is parked, the rotator sleeps until
+   the earliest `availableAt`, then retries.
+7. **Toast notification.** Each rotation pops a transient warning in the
+   OpenCode TUI.
+
+## Debugging
+
+File logging is **opt-in**. Enable it by either:
+
+```bash
+export OPENCODE_GEMINI_DEBUG=1
+```
+
+…or by passing `logFile` in the plugin options:
+
+```json
+["/path/to/opencode-gemini-rotator", { "keys": ["AIza..."], "logFile": "/tmp/gemini-rotator.log" }]
+```
+
+Then tail the log:
+
+```bash
+tail -f /tmp/gemini-rotator-debug.log
+```
+
+The TUI sidebar widget writes a small status JSON to
+`$TMPDIR/gemini-rotator-status.json` so it can poll cross-process state;
+this file is harmless and contains only the current key index, masked
+value, and pool size.
+
+## Development
+
+```bash
+bun install
+bun run test           # unit + property-based tests
+bun run test:coverage  # v8 coverage report
+bun run typecheck      # tsc --noEmit
+bun run format         # prettier --write .
+bun run format:check   # prettier --check .
+bun run build          # produce ./dist
+```
+
+CI runs typecheck, format check, tests, and build on every push and PR
+across Ubuntu and macOS.
+
+## Troubleshooting
+
+**The TUI sidebar doesn't appear.**
+The sidebar only shows once the rotator has been initialized with at
+least one key. Make sure your `opencode.json` either lists keys inline
+or that `GEMINI_API_KEYS` is exported in the shell that launches
+OpenCode. The sidebar reads from `$TMPDIR/gemini-rotator-status.json`;
+delete that file and restart OpenCode if you suspect stale state.
+
+**Rotation toast never shows.**
+Toasts only fire when a key is rotated. If your first key has fresh
+quota, you'll never see one. Force a rotation by temporarily putting an
+obviously bogus key first: `["AIzaBOGUSKEY", "AIza...your-real-key"]`.
+
+**"All provided Gemini keys are invalid" thrown immediately.**
+At least one key in your pool returned `API_KEY_INVALID` and there are
+no others available. Run with `OPENCODE_GEMINI_DEBUG=1` and check
+`/tmp/gemini-rotator-debug.log` for the masked key and the full error
+message.
+
+**`opencode` doesn't pick up the plugin.**
+Confirm OpenCode 1.4.3+ (`opencode --version`). For local installs, the
+path must be absolute. For npm installs, run `bun cache rm` and restart
+to force a reinstall into `~/.cache/opencode/node_modules/`.
+
+**CI for my fork fails on `format:check`.**
+Run `bun run format` locally and commit the result. Prettier config
+lives in `.prettierrc`.
+
+## FAQ
+
+**Does this proxy my prompts somewhere?**
+No. Requests still go directly to `generativelanguage.googleapis.com`.
+The plugin only swaps the auth header and retries on failure.
+
+**Will it work with the OAuth flow / `ya29.` tokens?**
+Yes. OAuth bearer tokens are detected and sent in the `Authorization`
+header. They count as one entry in the pool.
+
+**What happens if all keys are exhausted?**
+The plugin sleeps until the earliest key's cooldown expires, then retries
+— unless the caller aborts the request (`AbortSignal`), in which case the
+promise rejects with `Aborted`.
+
+**Does it touch non-Gemini requests?**
+No. Anything not addressed to `generativelanguage.googleapis.com` is
+passed straight through to the original `fetch`.
+
+**Does it cache or persist anything across sessions?**
+No. All state (cooldowns, invalid-key flags) is in-memory and resets when
+OpenCode restarts.
+
+## Security
+
+Please **do not** commit real API keys to any branch. If you discover a
+vulnerability, see [SECURITY.md](./SECURITY.md) for the private
+disclosure process.
+
+## Contributing
+
+Bug reports, doc fixes, and PRs are welcome. See
+[CONTRIBUTING.md](./CONTRIBUTING.md) for the dev loop, and
+[CODE_OF_CONDUCT.md](./CODE_OF_CONDUCT.md) for expected behavior.
+
+## License
+
+[MIT](./LICENSE) © Jianling Zhong

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { server } from "./server.js";
+export { server };

package/dist/index.js

@@ -0,0 +1,325 @@
+// src/server.ts
+import path from "path";
+import os from "os";
+import fs from "fs";
+import { z } from "zod";
+var statusFile = path.join(os.tmpdir(), "gemini-rotator-status.json");
+var RotatorOptionsSchema = z.object({
+  keys: z.union([z.array(z.string()), z.string()]).optional(),
+  logFile: z.string().optional()
+}).strict();
+var MAX_TRACKED_KEYS = 256;
+var STATUS_WRITE_THROTTLE_MS = 250;
+var lastWriteAt = 0;
+var pendingInfo = null;
+var writeTimer = null;
+function flushStatus() {
+  if (!pendingInfo)
+    return;
+  const info = pendingInfo;
+  pendingInfo = null;
+  lastWriteAt = Date.now();
+  fs.promises.writeFile(statusFile, JSON.stringify(info)).catch(() => {});
+}
+function notifyKeyUpdate(info) {
+  pendingInfo = info;
+  const now = Date.now();
+  const since = now - lastWriteAt;
+  if (since >= STATUS_WRITE_THROTTLE_MS) {
+    flushStatus();
+  } else if (!writeTimer) {
+    writeTimer = setTimeout(() => {
+      writeTimer = null;
+      flushStatus();
+    }, STATUS_WRITE_THROTTLE_MS - since);
+    writeTimer.unref?.();
+  }
+}
+function maskKey(key) {
+  if (key.startsWith("ya29.") || key.startsWith("Bearer "))
+    return "OAuth Token";
+  if (key.length <= 12)
+    return key;
+  return `${key.slice(0, 4)}…${key.slice(-4)}`;
+}
+
+class GeminiRotator {
+  originalFetch;
+  keyStates = new Map;
+  logFile;
+  fallbackKeys = [];
+  client;
+  constructor(client, options = {}) {
+    this.client = client;
+    this.originalFetch = globalThis.fetch;
+    if (options.logFile) {
+      this.logFile = options.logFile;
+    } else if (process.env.OPENCODE_GEMINI_DEBUG === "1") {
+      this.logFile = path.join(os.tmpdir(), "gemini-rotator-debug.log");
+    }
+    if (Array.isArray(options.keys)) {
+      this.fallbackKeys = options.keys;
+    } else if (typeof options.keys === "string") {
+      this.fallbackKeys = options.keys.split(",").map((k) => k.trim());
+    } else if (process.env.GEMINI_API_KEYS) {
+      this.fallbackKeys = process.env.GEMINI_API_KEYS.split(",").map((k) => k.trim());
+    }
+    this.fallbackKeys = this.fallbackKeys.filter((k) => k.length > 0);
+    if (this.fallbackKeys.length > 0) {
+      notifyKeyUpdate({
+        index: 1,
+        maskedKey: maskKey(this.fallbackKeys[0]),
+        total: this.fallbackKeys.length
+      });
+    } else {
+      try {
+        if (fs.existsSync(statusFile))
+          fs.unlinkSync(statusFile);
+      } catch {}
+      notifyKeyUpdate({ index: 0, maskedKey: "None", total: 0 });
+    }
+  }
+  async fileLog(msg) {
+    if (!this.logFile)
+      return;
+    const timestampedMsg = `[${new Date().toISOString()}] ${msg}
+`;
+    try {
+      await fs.promises.appendFile(this.logFile, timestampedMsg);
+    } catch {}
+  }
+  async showToast(message, variant = "info", duration) {
+    try {
+      await this.client.tui?.showToast({
+        body: { message, variant, duration }
+      });
+    } catch {}
+  }
+  sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+      if (signal?.aborted)
+        return reject(new Error("Aborted"));
+      const timer = setTimeout(resolve, ms);
+      signal?.addEventListener("abort", () => {
+        clearTimeout(timer);
+        reject(new Error("Aborted"));
+      });
+    });
+  }
+  async fetch(reqInfo, init) {
+    let urlObj;
+    if (typeof reqInfo === "string") {
+      urlObj = new URL(reqInfo);
+    } else if (reqInfo instanceof URL) {
+      urlObj = new URL(reqInfo.toString());
+    } else if (reqInfo instanceof Request) {
+      urlObj = new URL(reqInfo.url);
+    } else {
+      return this.originalFetch(reqInfo, init);
+    }
+    if (urlObj.hostname !== "generativelanguage.googleapis.com") {
+      return this.originalFetch(reqInfo, init);
+    }
+    const requestHeaders = new Headers(init?.headers);
+    const isRequestObj = reqInfo instanceof Request;
+    if (isRequestObj) {
+      reqInfo.headers.forEach((value, key) => {
+        if (!requestHeaders.has(key)) {
+          requestHeaders.set(key, value);
+        }
+      });
+    }
+    const providedKey = requestHeaders.get("x-goog-api-key") || urlObj.searchParams.get("key") || requestHeaders.get("authorization") || "";
+    let keysToUse = this.fallbackKeys;
+    if (providedKey) {
+      if (providedKey.includes(",")) {
+        keysToUse = providedKey.split(",").map((k) => k.trim()).filter((k) => k.length > 0);
+      } else {
+        if (this.fallbackKeys.length > 0) {
+          keysToUse = [...this.fallbackKeys];
+          if (!keysToUse.includes(providedKey)) {
+            keysToUse.push(providedKey);
+          }
+        } else {
+          keysToUse = [providedKey];
+        }
+      }
+    }
+    if (keysToUse.length === 0) {
+      return this.originalFetch(reqInfo, init);
+    }
+    urlObj.searchParams.delete("key");
+    const newUrlStr = urlObj.toString();
+    await this.fileLog(`--- Intercepting Gemini Request: ${urlObj.pathname} ---`);
+    keysToUse.forEach((k) => {
+      if (!this.keyStates.has(k)) {
+        if (this.keyStates.size >= MAX_TRACKED_KEYS) {
+          const firstKey = this.keyStates.keys().next().value;
+          if (firstKey !== undefined)
+            this.keyStates.delete(firstKey);
+        }
+        this.keyStates.set(k, { isValid: true, availableAt: 0 });
+      }
+    });
+    while (true) {
+      if (init?.signal?.aborted) {
+        await this.fileLog(`Request aborted by user.`);
+        throw new Error("Aborted");
+      }
+      const validKeys = keysToUse.filter((k) => {
+        const state = this.keyStates.get(k);
+        return state && state.isValid !== false;
+      });
+      if (validKeys.length === 0) {
+        await this.fileLog(`All keys marked as invalid!`);
+        this.showToast(`All provided Gemini keys are invalid!`, "error", 1e4);
+        throw new Error("All provided Gemini keys are invalid");
+      }
+      const now = Date.now();
+      validKeys.sort((a, b) => {
+        const stateA = this.keyStates.get(a);
+        const stateB = this.keyStates.get(b);
+        const isAvailableA = stateA.availableAt <= now;
+        const isAvailableB = stateB.availableAt <= now;
+        if (isAvailableA && isAvailableB) {
+          return keysToUse.indexOf(a) - keysToUse.indexOf(b);
+        } else if (isAvailableA) {
+          return -1;
+        } else if (isAvailableB) {
+          return 1;
+        } else {
+          return stateA.availableAt - stateB.availableAt;
+        }
+      });
+      const activeKey = validKeys[0];
+      const activeState = this.keyStates.get(activeKey);
+      const activeKeyMasked = maskKey(activeKey);
+      notifyKeyUpdate({
+        index: keysToUse.indexOf(activeKey) + 1,
+        maskedKey: activeKeyMasked,
+        total: keysToUse.length
+      });
+      if (activeState.availableAt > now) {
+        const sleepMs = activeState.availableAt - now;
+        await this.fileLog(`All keys exhausted. Sleeping ${sleepMs}ms until ${activeKeyMasked} available.`);
+        this.showToast(`All keys on cooldown. Waiting ${Math.ceil(sleepMs / 1000)}s…`, "warning", sleepMs);
+        await this.sleep(sleepMs, init?.signal ?? undefined);
+      }
+      const fetchHeaders = new Headers(requestHeaders);
+      if (activeKey.startsWith("Bearer ") || activeKey.startsWith("ya29.")) {
+        fetchHeaders.set("Authorization", activeKey.startsWith("Bearer ") ? activeKey : `Bearer ${activeKey}`);
+        fetchHeaders.delete("x-goog-api-key");
+      } else {
+        fetchHeaders.set("x-goog-api-key", activeKey);
+        fetchHeaders.delete("Authorization");
+      }
+      let fetchInput;
+      let fetchInit;
+      if (isRequestObj) {
+        const clonedReq = reqInfo.clone();
+        fetchInput = new Request(newUrlStr, {
+          method: clonedReq.method,
+          headers: fetchHeaders,
+          body: clonedReq.body,
+          mode: clonedReq.mode,
+          credentials: clonedReq.credentials,
+          cache: clonedReq.cache,
+          redirect: clonedReq.redirect,
+          referrer: clonedReq.referrer,
+          referrerPolicy: clonedReq.referrerPolicy,
+          integrity: clonedReq.integrity,
+          keepalive: clonedReq.keepalive,
+          signal: clonedReq.signal
+        });
+        fetchInit = init || {};
+      } else {
+        fetchInput = newUrlStr;
+        fetchInit = { ...init, headers: fetchHeaders };
+      }
+      let response;
+      try {
+        await this.fileLog(`Trying key (${activeKeyMasked})`);
+        response = await this.originalFetch(fetchInput, fetchInit);
+        await this.fileLog(`Response Status: ${response.status}`);
+      } catch (error) {
+        await this.fileLog(`Fetch threw an error: ${error}`);
+        throw error;
+      }
+      let shouldRotate = false;
+      let isInvalid = false;
+      let delayMs = 1e4;
+      if (response.status === 429) {
+        shouldRotate = true;
+        await this.fileLog(`Rate limited (429).`);
+        delayMs = 60000;
+      } else if (!response.ok && (response.status === 403 || response.status === 400 || response.status === 503)) {
+        const cloned = response.clone();
+        try {
+          const errorData = await cloned.json();
+          const msg = errorData?.error?.message?.toLowerCase() || "";
+          const firstDetail = errorData?.error?.details?.[0];
+          const reason = firstDetail?.reason?.toLowerCase() || "";
+          const errorStatus = errorData?.error?.status?.toLowerCase() || "";
+          await this.fileLog(`Error: msg="${msg}", reason="${reason}", status="${errorStatus}"`);
+          if (msg.includes("api key not valid") || reason.includes("api_key_invalid")) {
+            isInvalid = true;
+            shouldRotate = true;
+          } else if (msg.includes("quota") || msg.includes("rate limit") || reason.includes("rate_limit") || reason.includes("quota_exceeded") || errorStatus === "resource_exhausted" || errorStatus === "unavailable") {
+            shouldRotate = true;
+            const retryAfter = response.headers.get("retry-after");
+            if (retryAfter) {
+              const parsed = parseInt(retryAfter, 10);
+              if (!isNaN(parsed))
+                delayMs = parsed * 1000;
+            } else {
+              const afterMatch = msg.match(/reset after\s+([0-9.]+)(s|m|h)/i);
+              if (afterMatch) {
+                const val = parseFloat(afterMatch[1]);
+                const unit = afterMatch[2].toLowerCase();
+                if (unit === "s")
+                  delayMs = val * 1000;
+                if (unit === "m")
+                  delayMs = val * 60 * 1000;
+                if (unit === "h")
+                  delayMs = val * 3600 * 1000;
+              }
+            }
+          }
+        } catch {}
+      }
+      if (isInvalid) {
+        activeState.isValid = false;
+        this.showToast(`Key (${activeKeyMasked}) is invalid.`, "error", 5000);
+        continue;
+      }
+      if (shouldRotate) {
+        activeState.availableAt = Date.now() + delayMs;
+        this.showToast(`Rotating from ${activeKeyMasked} (Cooldown: ${Math.ceil(delayMs / 1000)}s)`, "warning", 3000);
+        continue;
+      }
+      return response;
+    }
+  }
+  patch() {
+    globalThis.fetch = this.fetch.bind(this);
+  }
+  unpatch() {
+    globalThis.fetch = this.originalFetch;
+  }
+}
+var rotator = null;
+var server = async ({ client }, options) => {
+  if (rotator)
+    rotator.unpatch();
+  const parsed = RotatorOptionsSchema.safeParse(options ?? {});
+  const opts = parsed.success ? parsed.data : {};
+  if (!parsed.success) {
+    console.warn("[opencode-gemini-rotator] Invalid plugin options; falling back to defaults:", parsed.error.issues);
+  }
+  rotator = new GeminiRotator(client, opts);
+  rotator.patch();
+  return {};
+};
+export {
+  server
+};

package/dist/server.d.ts

@@ -0,0 +1,54 @@
+import { type Plugin } from "@opencode-ai/plugin";
+import { z } from "zod";
+/**
+ * Zod schema for the plugin options object as it appears in
+ * `opencode.json`. Keeping validation at the boundary protects us from
+ * prototype pollution and stops obvious config typos like `key:` (no s).
+ */
+export declare const RotatorOptionsSchema: z.ZodObject<{
+    keys: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodString]>>;
+    logFile: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RotatorOptions = z.infer<typeof RotatorOptionsSchema>;
+interface ToastClient {
+    tui?: {
+        showToast: (args: {
+            body: {
+                message: string;
+                variant?: "info" | "warning" | "success" | "error";
+                duration?: number;
+            };
+        }) => Promise<unknown>;
+    };
+}
+/**
+ * Render a key safely for display in logs, toasts, and the TUI sidebar.
+ * - OAuth bearer tokens (`ya29.*`) are labeled rather than truncated.
+ * - Standard API keys show a 4-char prefix and 4-char suffix so the user
+ *   can distinguish keys in their pool without exposing the secret middle.
+ * - Very short identifiers (test fakes) are shown verbatim.
+ */
+export declare function maskKey(key: string): string;
+export declare class GeminiRotator {
+    private originalFetch;
+    private keyStates;
+    private logFile;
+    private fallbackKeys;
+    private client;
+    constructor(client: ToastClient, options?: RotatorOptions);
+    private fileLog;
+    private showToast;
+    private sleep;
+    fetch(reqInfo: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+    patch(): void;
+    unpatch(): void;
+}
+/**
+ * Reset the singleton (test-only helper). Restores the original
+ * `globalThis.fetch` so test files don't leak state between suites.
+ * @internal
+ */
+export declare function _resetForTesting(): void;
+export declare const id = "gemini-key-rotator";
+export declare const server: Plugin;
+export {};

package/dist/server.js

@@ -0,0 +1,337 @@
+// src/server.ts
+import path from "path";
+import os from "os";
+import fs from "fs";
+import { z } from "zod";
+var statusFile = path.join(os.tmpdir(), "gemini-rotator-status.json");
+var RotatorOptionsSchema = z.object({
+  keys: z.union([z.array(z.string()), z.string()]).optional(),
+  logFile: z.string().optional()
+}).strict();
+var MAX_TRACKED_KEYS = 256;
+var STATUS_WRITE_THROTTLE_MS = 250;
+var lastWriteAt = 0;
+var pendingInfo = null;
+var writeTimer = null;
+function flushStatus() {
+  if (!pendingInfo)
+    return;
+  const info = pendingInfo;
+  pendingInfo = null;
+  lastWriteAt = Date.now();
+  fs.promises.writeFile(statusFile, JSON.stringify(info)).catch(() => {});
+}
+function notifyKeyUpdate(info) {
+  pendingInfo = info;
+  const now = Date.now();
+  const since = now - lastWriteAt;
+  if (since >= STATUS_WRITE_THROTTLE_MS) {
+    flushStatus();
+  } else if (!writeTimer) {
+    writeTimer = setTimeout(() => {
+      writeTimer = null;
+      flushStatus();
+    }, STATUS_WRITE_THROTTLE_MS - since);
+    writeTimer.unref?.();
+  }
+}
+function maskKey(key) {
+  if (key.startsWith("ya29.") || key.startsWith("Bearer "))
+    return "OAuth Token";
+  if (key.length <= 12)
+    return key;
+  return `${key.slice(0, 4)}…${key.slice(-4)}`;
+}
+
+class GeminiRotator {
+  originalFetch;
+  keyStates = new Map;
+  logFile;
+  fallbackKeys = [];
+  client;
+  constructor(client, options = {}) {
+    this.client = client;
+    this.originalFetch = globalThis.fetch;
+    if (options.logFile) {
+      this.logFile = options.logFile;
+    } else if (process.env.OPENCODE_GEMINI_DEBUG === "1") {
+      this.logFile = path.join(os.tmpdir(), "gemini-rotator-debug.log");
+    }
+    if (Array.isArray(options.keys)) {
+      this.fallbackKeys = options.keys;
+    } else if (typeof options.keys === "string") {
+      this.fallbackKeys = options.keys.split(",").map((k) => k.trim());
+    } else if (process.env.GEMINI_API_KEYS) {
+      this.fallbackKeys = process.env.GEMINI_API_KEYS.split(",").map((k) => k.trim());
+    }
+    this.fallbackKeys = this.fallbackKeys.filter((k) => k.length > 0);
+    if (this.fallbackKeys.length > 0) {
+      notifyKeyUpdate({
+        index: 1,
+        maskedKey: maskKey(this.fallbackKeys[0]),
+        total: this.fallbackKeys.length
+      });
+    } else {
+      try {
+        if (fs.existsSync(statusFile))
+          fs.unlinkSync(statusFile);
+      } catch {}
+      notifyKeyUpdate({ index: 0, maskedKey: "None", total: 0 });
+    }
+  }
+  async fileLog(msg) {
+    if (!this.logFile)
+      return;
+    const timestampedMsg = `[${new Date().toISOString()}] ${msg}
+`;
+    try {
+      await fs.promises.appendFile(this.logFile, timestampedMsg);
+    } catch {}
+  }
+  async showToast(message, variant = "info", duration) {
+    try {
+      await this.client.tui?.showToast({
+        body: { message, variant, duration }
+      });
+    } catch {}
+  }
+  sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+      if (signal?.aborted)
+        return reject(new Error("Aborted"));
+      const timer = setTimeout(resolve, ms);
+      signal?.addEventListener("abort", () => {
+        clearTimeout(timer);
+        reject(new Error("Aborted"));
+      });
+    });
+  }
+  async fetch(reqInfo, init) {
+    let urlObj;
+    if (typeof reqInfo === "string") {
+      urlObj = new URL(reqInfo);
+    } else if (reqInfo instanceof URL) {
+      urlObj = new URL(reqInfo.toString());
+    } else if (reqInfo instanceof Request) {
+      urlObj = new URL(reqInfo.url);
+    } else {
+      return this.originalFetch(reqInfo, init);
+    }
+    if (urlObj.hostname !== "generativelanguage.googleapis.com") {
+      return this.originalFetch(reqInfo, init);
+    }
+    const requestHeaders = new Headers(init?.headers);
+    const isRequestObj = reqInfo instanceof Request;
+    if (isRequestObj) {
+      reqInfo.headers.forEach((value, key) => {
+        if (!requestHeaders.has(key)) {
+          requestHeaders.set(key, value);
+        }
+      });
+    }
+    const providedKey = requestHeaders.get("x-goog-api-key") || urlObj.searchParams.get("key") || requestHeaders.get("authorization") || "";
+    let keysToUse = this.fallbackKeys;
+    if (providedKey) {
+      if (providedKey.includes(",")) {
+        keysToUse = providedKey.split(",").map((k) => k.trim()).filter((k) => k.length > 0);
+      } else {
+        if (this.fallbackKeys.length > 0) {
+          keysToUse = [...this.fallbackKeys];
+          if (!keysToUse.includes(providedKey)) {
+            keysToUse.push(providedKey);
+          }
+        } else {
+          keysToUse = [providedKey];
+        }
+      }
+    }
+    if (keysToUse.length === 0) {
+      return this.originalFetch(reqInfo, init);
+    }
+    urlObj.searchParams.delete("key");
+    const newUrlStr = urlObj.toString();
+    await this.fileLog(`--- Intercepting Gemini Request: ${urlObj.pathname} ---`);
+    keysToUse.forEach((k) => {
+      if (!this.keyStates.has(k)) {
+        if (this.keyStates.size >= MAX_TRACKED_KEYS) {
+          const firstKey = this.keyStates.keys().next().value;
+          if (firstKey !== undefined)
+            this.keyStates.delete(firstKey);
+        }
+        this.keyStates.set(k, { isValid: true, availableAt: 0 });
+      }
+    });
+    while (true) {
+      if (init?.signal?.aborted) {
+        await this.fileLog(`Request aborted by user.`);
+        throw new Error("Aborted");
+      }
+      const validKeys = keysToUse.filter((k) => {
+        const state = this.keyStates.get(k);
+        return state && state.isValid !== false;
+      });
+      if (validKeys.length === 0) {
+        await this.fileLog(`All keys marked as invalid!`);
+        this.showToast(`All provided Gemini keys are invalid!`, "error", 1e4);
+        throw new Error("All provided Gemini keys are invalid");
+      }
+      const now = Date.now();
+      validKeys.sort((a, b) => {
+        const stateA = this.keyStates.get(a);
+        const stateB = this.keyStates.get(b);
+        const isAvailableA = stateA.availableAt <= now;
+        const isAvailableB = stateB.availableAt <= now;
+        if (isAvailableA && isAvailableB) {
+          return keysToUse.indexOf(a) - keysToUse.indexOf(b);
+        } else if (isAvailableA) {
+          return -1;
+        } else if (isAvailableB) {
+          return 1;
+        } else {
+          return stateA.availableAt - stateB.availableAt;
+        }
+      });
+      const activeKey = validKeys[0];
+      const activeState = this.keyStates.get(activeKey);
+      const activeKeyMasked = maskKey(activeKey);
+      notifyKeyUpdate({
+        index: keysToUse.indexOf(activeKey) + 1,
+        maskedKey: activeKeyMasked,
+        total: keysToUse.length
+      });
+      if (activeState.availableAt > now) {
+        const sleepMs = activeState.availableAt - now;
+        await this.fileLog(`All keys exhausted. Sleeping ${sleepMs}ms until ${activeKeyMasked} available.`);
+        this.showToast(`All keys on cooldown. Waiting ${Math.ceil(sleepMs / 1000)}s…`, "warning", sleepMs);
+        await this.sleep(sleepMs, init?.signal ?? undefined);
+      }
+      const fetchHeaders = new Headers(requestHeaders);
+      if (activeKey.startsWith("Bearer ") || activeKey.startsWith("ya29.")) {
+        fetchHeaders.set("Authorization", activeKey.startsWith("Bearer ") ? activeKey : `Bearer ${activeKey}`);
+        fetchHeaders.delete("x-goog-api-key");
+      } else {
+        fetchHeaders.set("x-goog-api-key", activeKey);
+        fetchHeaders.delete("Authorization");
+      }
+      let fetchInput;
+      let fetchInit;
+      if (isRequestObj) {
+        const clonedReq = reqInfo.clone();
+        fetchInput = new Request(newUrlStr, {
+          method: clonedReq.method,
+          headers: fetchHeaders,
+          body: clonedReq.body,
+          mode: clonedReq.mode,
+          credentials: clonedReq.credentials,
+          cache: clonedReq.cache,
+          redirect: clonedReq.redirect,
+          referrer: clonedReq.referrer,
+          referrerPolicy: clonedReq.referrerPolicy,
+          integrity: clonedReq.integrity,
+          keepalive: clonedReq.keepalive,
+          signal: clonedReq.signal
+        });
+        fetchInit = init || {};
+      } else {
+        fetchInput = newUrlStr;
+        fetchInit = { ...init, headers: fetchHeaders };
+      }
+      let response;
+      try {
+        await this.fileLog(`Trying key (${activeKeyMasked})`);
+        response = await this.originalFetch(fetchInput, fetchInit);
+        await this.fileLog(`Response Status: ${response.status}`);
+      } catch (error) {
+        await this.fileLog(`Fetch threw an error: ${error}`);
+        throw error;
+      }
+      let shouldRotate = false;
+      let isInvalid = false;
+      let delayMs = 1e4;
+      if (response.status === 429) {
+        shouldRotate = true;
+        await this.fileLog(`Rate limited (429).`);
+        delayMs = 60000;
+      } else if (!response.ok && (response.status === 403 || response.status === 400 || response.status === 503)) {
+        const cloned = response.clone();
+        try {
+          const errorData = await cloned.json();
+          const msg = errorData?.error?.message?.toLowerCase() || "";
+          const firstDetail = errorData?.error?.details?.[0];
+          const reason = firstDetail?.reason?.toLowerCase() || "";
+          const errorStatus = errorData?.error?.status?.toLowerCase() || "";
+          await this.fileLog(`Error: msg="${msg}", reason="${reason}", status="${errorStatus}"`);
+          if (msg.includes("api key not valid") || reason.includes("api_key_invalid")) {
+            isInvalid = true;
+            shouldRotate = true;
+          } else if (msg.includes("quota") || msg.includes("rate limit") || reason.includes("rate_limit") || reason.includes("quota_exceeded") || errorStatus === "resource_exhausted" || errorStatus === "unavailable") {
+            shouldRotate = true;
+            const retryAfter = response.headers.get("retry-after");
+            if (retryAfter) {
+              const parsed = parseInt(retryAfter, 10);
+              if (!isNaN(parsed))
+                delayMs = parsed * 1000;
+            } else {
+              const afterMatch = msg.match(/reset after\s+([0-9.]+)(s|m|h)/i);
+              if (afterMatch) {
+                const val = parseFloat(afterMatch[1]);
+                const unit = afterMatch[2].toLowerCase();
+                if (unit === "s")
+                  delayMs = val * 1000;
+                if (unit === "m")
+                  delayMs = val * 60 * 1000;
+                if (unit === "h")
+                  delayMs = val * 3600 * 1000;
+              }
+            }
+          }
+        } catch {}
+      }
+      if (isInvalid) {
+        activeState.isValid = false;
+        this.showToast(`Key (${activeKeyMasked}) is invalid.`, "error", 5000);
+        continue;
+      }
+      if (shouldRotate) {
+        activeState.availableAt = Date.now() + delayMs;
+        this.showToast(`Rotating from ${activeKeyMasked} (Cooldown: ${Math.ceil(delayMs / 1000)}s)`, "warning", 3000);
+        continue;
+      }
+      return response;
+    }
+  }
+  patch() {
+    globalThis.fetch = this.fetch.bind(this);
+  }
+  unpatch() {
+    globalThis.fetch = this.originalFetch;
+  }
+}
+var rotator = null;
+function _resetForTesting() {
+  if (rotator) {
+    rotator.unpatch();
+    rotator = null;
+  }
+}
+var id = "gemini-key-rotator";
+var server = async ({ client }, options) => {
+  if (rotator)
+    rotator.unpatch();
+  const parsed = RotatorOptionsSchema.safeParse(options ?? {});
+  const opts = parsed.success ? parsed.data : {};
+  if (!parsed.success) {
+    console.warn("[opencode-gemini-rotator] Invalid plugin options; falling back to defaults:", parsed.error.issues);
+  }
+  rotator = new GeminiRotator(client, opts);
+  rotator.patch();
+  return {};
+};
+export {
+  server,
+  maskKey,
+  id,
+  _resetForTesting,
+  RotatorOptionsSchema,
+  GeminiRotator
+};

package/dist/shared.d.ts

@@ -0,0 +1,6 @@
+export interface KeyInfo {
+    index: number;
+    maskedKey: string;
+    total: number;
+}
+export declare const initialKeyInfo: KeyInfo;

package/dist/tui.d.ts

@@ -0,0 +1,8 @@
+import { type TuiPlugin } from "@opencode-ai/plugin/tui";
+export declare const tui: TuiPlugin;
+export declare const id = "gemini-rotator-tui";
+declare const _default: {
+    id: string;
+    tui: TuiPlugin;
+};
+export default _default;

package/dist/tui.js

@@ -0,0 +1,162 @@
+// src/tui.tsx
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { effect as _$effect } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { createSignal, onMount, onCleanup, Show } from "solid-js";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+// src/shared.ts
+var initialKeyInfo = { index: 0, maskedKey: "None", total: 0 };
+
+// src/tui.tsx
+var statusFile = path.join(os.tmpdir(), "gemini-rotator-status.json");
+var DEBUG = process.env.OPENCODE_GEMINI_DEBUG === "1";
+var debugLogFile = path.join(os.tmpdir(), "gemini-rotator-tui.log");
+function debugLog(msg) {
+  if (!DEBUG)
+    return;
+  try {
+    fs.appendFileSync(debugLogFile, `[${new Date().toISOString()}] ${msg}
+`);
+  } catch {}
+}
+function SidebarView(props) {
+  const [info, setInfo] = createSignal(initialKeyInfo);
+  const theme = () => props.api.theme.current;
+  const readStatus = () => {
+    try {
+      if (fs.existsSync(statusFile)) {
+        const content = fs.readFileSync(statusFile, "utf-8");
+        const data = JSON.parse(content);
+        setInfo(data);
+      }
+    } catch (e) {
+      debugLog(`error reading status: ${e}`);
+    }
+  };
+  onMount(() => {
+    debugLog(`config keys: ${Object.keys(props.api.state.config).join(", ")}`);
+    readStatus();
+    let watcher;
+    try {
+      watcher = fs.watch(statusFile, {
+        persistent: false
+      }, () => readStatus());
+      watcher.on("error", (err) => debugLog(`fs.watch error: ${err}`));
+    } catch (e) {
+      debugLog(`fs.watch unavailable, falling back to polling: ${e}`);
+    }
+    const interval = setInterval(readStatus, 5000);
+    onCleanup(() => {
+      clearInterval(interval);
+      watcher?.close();
+    });
+  });
+  const isGeminiActive = () => info().total > 0;
+  return (() => {
+    var _el$ = _$createElement("box");
+    _$insert(_el$, _$createComponent(Show, {
+      get when() {
+        return isGeminiActive();
+      },
+      get children() {
+        var _el$2 = _$createElement("box"), _el$3 = _$createElement("box"), _el$4 = _$createElement("text"), _el$5 = _$createElement("b");
+        _$insertNode(_el$2, _el$3);
+        _$setProp(_el$2, "paddingX", 1);
+        _$setProp(_el$2, "marginBottom", 1);
+        _$insertNode(_el$3, _el$4);
+        _$setProp(_el$3, "flexDirection", "row");
+        _$setProp(_el$3, "gap", 1);
+        _$insertNode(_el$4, _el$5);
+        _$insertNode(_el$5, _$createTextNode(`GEMINI ROTATOR`));
+        _$insert(_el$2, _$createComponent(Show, {
+          get when() {
+            return info().maskedKey !== "None";
+          },
+          get fallback() {
+            return (() => {
+              var _el$15 = _$createElement("text");
+              _$insertNode(_el$15, _$createTextNode(`Waiting for request...`));
+              _$effect((_$p) => _$setProp(_el$15, "fg", theme().textMuted, _$p));
+              return _el$15;
+            })();
+          },
+          get children() {
+            return [(() => {
+              var _el$7 = _$createElement("box"), _el$8 = _$createElement("text"), _el$0 = _$createElement("text"), _el$1 = _$createTextNode(`#`), _el$10 = _$createElement("text"), _el$11 = _$createTextNode(`(`), _el$12 = _$createTextNode(`)`);
+              _$insertNode(_el$7, _el$8);
+              _$insertNode(_el$7, _el$0);
+              _$insertNode(_el$7, _el$10);
+              _$setProp(_el$7, "flexDirection", "row");
+              _$setProp(_el$7, "gap", 1);
+              _$insertNode(_el$8, _$createTextNode(`Active Key:`));
+              _$insertNode(_el$0, _el$1);
+              _$insert(_el$0, () => info().index, null);
+              _$insertNode(_el$10, _el$11);
+              _$insertNode(_el$10, _el$12);
+              _$insert(_el$10, () => info().maskedKey, _el$12);
+              _$effect((_p$) => {
+                var _v$ = theme().text, _v$2 = theme().success, _v$3 = theme().textMuted;
+                _v$ !== _p$.e && (_p$.e = _$setProp(_el$8, "fg", _v$, _p$.e));
+                _v$2 !== _p$.t && (_p$.t = _$setProp(_el$0, "fg", _v$2, _p$.t));
+                _v$3 !== _p$.a && (_p$.a = _$setProp(_el$10, "fg", _v$3, _p$.a));
+                return _p$;
+              }, {
+                e: undefined,
+                t: undefined,
+                a: undefined
+              });
+              return _el$7;
+            })(), (() => {
+              var _el$13 = _$createElement("text"), _el$14 = _$createTextNode(`Pool size: `);
+              _$insertNode(_el$13, _el$14);
+              _$insert(_el$13, () => info().total, null);
+              _$effect((_$p) => _$setProp(_el$13, "fg", theme().textMuted, _$p));
+              return _el$13;
+            })()];
+          }
+        }), null);
+        _$effect((_$p) => _$setProp(_el$4, "fg", theme().primary, _$p));
+        return _el$2;
+      }
+    }));
+    return _el$;
+  })();
+}
+var tui = async (api) => {
+  try {
+    api.slots.register({
+      order: 100,
+      slots: {
+        home_prompt_right() {
+          return _$createComponent(SidebarView, {
+            api
+          });
+        },
+        sidebar_content() {
+          return _$createComponent(SidebarView, {
+            api
+          });
+        }
+      }
+    });
+  } catch (e) {
+    debugLog(`failed to register slots: ${e}`);
+  }
+};
+var id = "gemini-rotator-tui";
+var tui_default = {
+  id,
+  tui
+};
+export {
+  tui,
+  id,
+  tui_default as default
+};

package/package.json

@@ -0,0 +1,108 @@
+{
+    "name": "opencode-gemini-rotator",
+    "version": "1.1.0",
+    "overrides": {
+        "qs": "^6.15.2"
+    },
+    "description": "OpenCode plugin that rotates multiple Google Gemini API keys to bypass per-key rate limits (HTTP 429) and quota exhaustion (HTTP 403/503 RESOURCE_EXHAUSTED) — drop-in, transparent fetch interceptor with cooldown and TUI sidebar.",
+    "keywords": [
+        "opencode",
+        "opencode-plugin",
+        "opencode-ai",
+        "gemini",
+        "gemini-api",
+        "gemini-pro",
+        "google-gemini",
+        "google-ai",
+        "generative-ai",
+        "api-key",
+        "api-key-rotation",
+        "key-rotation",
+        "rate-limit",
+        "rate-limiting",
+        "quota",
+        "rotator",
+        "fallback",
+        "retry",
+        "fetch",
+        "interceptor",
+        "llm",
+        "ai-tools",
+        "developer-tools",
+        "tui"
+    ],
+    "homepage": "https://github.com/jianlingzhong/opencode-gemini-rotator#readme",
+    "bugs": {
+        "url": "https://github.com/jianlingzhong/opencode-gemini-rotator/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/jianlingzhong/opencode-gemini-rotator.git"
+    },
+    "license": "MIT",
+    "author": "Jianling Zhong <jianlingzh@gmail.com>",
+    "type": "module",
+    "main": "dist/index.js",
+    "tui": "dist/tui.js",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
+        },
+        "./tui": {
+            "types": "./dist/tui.d.ts",
+            "default": "./dist/tui.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "files": [
+        "dist",
+        "LICENSE",
+        "README.md",
+        "CHANGELOG.md"
+    ],
+    "engines": {
+        "node": ">=18"
+    },
+    "scripts": {
+        "build": "rm -rf dist && tsc --emitDeclarationOnly && bun build.ts",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "test:coverage": "vitest run --coverage",
+        "test:mutation": "stryker run",
+        "typecheck": "tsc --noEmit",
+        "lint": "eslint .",
+        "lint:fix": "eslint . --fix",
+        "format": "prettier --write .",
+        "format:check": "prettier --check .",
+        "deadcode": "knip",
+        "size": "node scripts/check-size.mjs",
+        "audit:full": "bun audit && osv-scanner --lockfile=bun.lock",
+        "prepublishOnly": "bun run lint && bun run typecheck && bun run test && bun run build && bun run size && bun audit"
+    },
+    "dependencies": {
+        "@opencode-ai/plugin": "^1.15.9",
+        "zod": "^4.4.3"
+    },
+    "devDependencies": {
+        "@eslint/js": "^10.0.1",
+        "@opentui/core": "^0.2.15",
+        "@opentui/solid": "^0.2.15",
+        "@stryker-mutator/core": "^9.6.1",
+        "@stryker-mutator/vitest-runner": "^9.6.1",
+        "@types/node": "^22",
+        "@vitest/coverage-v8": "^4.1.7",
+        "eslint": "^10.4.0",
+        "eslint-plugin-n": "^18.0.1",
+        "eslint-plugin-promise": "^7.3.0",
+        "eslint-plugin-security": "^4.0.0",
+        "fast-check": "^4.8.0",
+        "knip": "^6.14.2",
+        "prettier": "^3.8.3",
+        "solid-js": "^1.9.13",
+        "typescript": "^5",
+        "typescript-eslint": "^8.59.4",
+        "vitest": "^4.1.7"
+    }
+}