@elvatis_com/openclaw-cli-bridge-elvatis 0.2.29 → 0.2.30

package/README.md

@@ -2,7 +2,7 @@
 
 > OpenClaw plugin that bridges locally installed AI CLIs (Codex, Gemini, Claude Code) as model providers — with slash commands for instant model switching, restore, health testing, and model listing.
 
-**Current version:** `0.2.29`
+**Current version:** `0.2.30`
 
 ---
 
@@ -287,6 +287,14 @@ npm test            # vitest run (45 tests)
 
 ## Changelog
 
+### v0.2.30
+- **feat:** `gemini-browser.ts` — gemini.google.com DOM-automation (Quill editor + message-content polling)
+- **feat:** `web-gemini/*` models in proxy (gemini-2-5-pro, gemini-2-5-flash, gemini-3-pro, gemini-3-flash)
+- **feat:** `/gemini-login`, `/gemini-status`, `/gemini-logout` commands + cookie-expiry tracking
+- **fix:** Singleton CDP connection — no more zombie Chromium processes
+- **fix:** `cleanupBrowsers()` called on plugin stop — all browser resources released
+- **test:** 90/90 tests green (+6 gemini-proxy tests)
+
 ### v0.2.29
 - **feat:** `claude-browser.ts` — claude.ai DOM-automation (ProseMirror + `[data-test-render-count]` polling)
 - **feat:** `web-claude/*` models in proxy (web-claude/claude-sonnet, claude-opus, claude-haiku)

package/SKILL.md

@@ -53,4 +53,4 @@ Each command runs `openclaw models set <model>` atomically and replies with a co
 
 See `README.md` for full configuration reference and architecture diagram.
 
-**Version:** 0.2.29
+**Version:** 0.2.30

package/index.ts

@@ -89,6 +89,38 @@ let grokContext: BrowserContext | null = null;
 // Persistent profile dir — survives gateway restarts, keeps cookies intact
 const GROK_PROFILE_DIR = join(homedir(), ".openclaw", "grok-profile");
 
+// ── Gemini web-session state ──────────────────────────────────────────────────
+let geminiContext: BrowserContext | null = null;
+const GEMINI_EXPIRY_FILE = join(homedir(), ".openclaw", "gemini-cookie-expiry.json");
+
+interface GeminiExpiryInfo { expiresAt: number; loginAt: number; cookieName: string; }
+
+function saveGeminiExpiry(info: GeminiExpiryInfo): void {
+  try { writeFileSync(GEMINI_EXPIRY_FILE, JSON.stringify(info, null, 2)); } catch { /* ignore */ }
+}
+function loadGeminiExpiry(): GeminiExpiryInfo | null {
+  try { return JSON.parse(readFileSync(GEMINI_EXPIRY_FILE, "utf-8")) as GeminiExpiryInfo; } catch { return null; }
+}
+function formatGeminiExpiry(info: GeminiExpiryInfo): string {
+  const daysLeft = Math.floor((info.expiresAt - Date.now()) / 86_400_000);
+  const dateStr = new Date(info.expiresAt).toISOString().substring(0, 10);
+  if (daysLeft < 0)   return `⚠️ EXPIRED (${dateStr}) — run /gemini-login`;
+  if (daysLeft <= 7)  return `🚨 expires in ${daysLeft}d (${dateStr}) — run /gemini-login NOW`;
+  if (daysLeft <= 14) return `⚠️ expires in ${daysLeft}d (${dateStr}) — run /gemini-login soon`;
+  return `✅ valid for ${daysLeft} more days (expires ${dateStr})`;
+}
+async function scanGeminiCookieExpiry(ctx: BrowserContext): Promise<GeminiExpiryInfo | null> {
+  try {
+    const cookies = await ctx.cookies(["https://gemini.google.com", "https://accounts.google.com"]);
+    const auth = cookies.filter(c => ["__Secure-1PSID", "__Secure-3PSID", "SID"].includes(c.name) && c.expires && c.expires > 0);
+    if (!auth.length) return null;
+    auth.sort((a, b) => (a.expires ?? 0) - (b.expires ?? 0));
+    const earliest = auth[0];
+    return { expiresAt: (earliest.expires ?? 0) * 1000, loginAt: Date.now(), cookieName: earliest.name };
+  } catch { return null; }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+
 // ── Claude web-session state ──────────────────────────────────────────────────
 let claudeContext: BrowserContext | null = null;
 const CLAUDE_EXPIRY_FILE = join(homedir(), ".openclaw", "claude-cookie-expiry.json");
@@ -172,60 +204,96 @@ async function scanCookieExpiry(ctx: import("playwright").BrowserContext): Promi
   } catch { return null; }
 }
 
+// Singleton CDP connection — one browser object shared across grok + claude
+let _cdpBrowser: import("playwright").Browser | null = null;
+let _cdpBrowserLaunchPromise: Promise<import("playwright").BrowserContext | null> | null = null;
+
 /**
- * Launch (or reuse) a persistent headless Chromium context for grok.com.
- * Uses launchPersistentContext so cookies survive gateway restarts.
- * The profile lives at ~/.openclaw/grok-profile/
+ * Connect to the OpenClaw managed browser (CDP port 18800).
+ * Singleton: reuses the same connection. Falls back to persistent Chromium for Grok only.
+ * NEVER launches a new browser for Claude — Claude requires the OpenClaw browser.
  */
-async function getOrLaunchGrokContext(
+async function connectToOpenClawBrowser(
   log: (msg: string) => void
 ): Promise<BrowserContext | null> {
-  // Already have a live context?
-  if (grokContext) {
+  // Reuse existing CDP connection if still alive
+  if (_cdpBrowser) {
     try {
-      // Quick check: can we still enumerate pages?
-      grokContext.pages();
-      return grokContext;
+      _cdpBrowser.contexts(); // ping
+      return _cdpBrowser.contexts()[0] ?? null;
     } catch {
-      grokContext = null;
+      _cdpBrowser = null;
     }
   }
-
   const { chromium } = await import("playwright");
-
-  // 1. Try connecting to the OpenClaw managed browser first (user may have grok.com open)
   try {
-    const browser = await chromium.connectOverCDP("http://127.0.0.1:18800", { timeout: 2000 });
-    grokBrowser = browser;
-    const ctx = browser.contexts()[0];
-    if (ctx) {
-      log("[cli-bridge:grok] connected to OpenClaw browser");
-      return ctx;
-    }
+    const browser = await chromium.connectOverCDP("http://127.0.0.1:18800", { timeout: 3000 });
+    _cdpBrowser = browser;
+    browser.on("disconnected", () => { _cdpBrowser = null; log("[cli-bridge] OpenClaw browser disconnected"); });
+    log("[cli-bridge] connected to OpenClaw browser via CDP");
+    return browser.contexts()[0] ?? null;
   } catch {
-    // OpenClaw browser not available — fall through to persistent context
-  }
-
-  // 2. Launch our own persistent headless Chromium with saved profile
-  log("[cli-bridge:grok] launching persistent Chromium…");
-  try {
-    const ctx = await chromium.launchPersistentContext(GROK_PROFILE_DIR, {
-      headless: true,
-      args: ["--no-sandbox", "--disable-setuid-sandbox"],
-    });
-    grokContext = ctx;
-    log("[cli-bridge:grok] persistent context ready");
-    return ctx;
-  } catch (err) {
-    log(`[cli-bridge:grok] failed to launch browser: ${(err as Error).message}`);
+    log("[cli-bridge] OpenClaw browser not available (CDP 18800)");
     return null;
   }
 }
 
-async function connectToOpenClawBrowser(
+/**
+ * Launch (or reuse) a persistent headless Chromium context for grok.com.
+ * ONLY used for Grok — Grok has a saved persistent profile with cookies.
+ * Claude does NOT use this — it requires the OpenClaw browser.
+ */
+async function getOrLaunchGrokContext(
   log: (msg: string) => void
 ): Promise<BrowserContext | null> {
-  return getOrLaunchGrokContext(log);
+  // Already have a live context?
+  if (grokContext) {
+    try { grokContext.pages(); return grokContext; } catch { grokContext = null; }
+  }
+
+  // Try OpenClaw browser first (singleton CDP)
+  const cdpCtx = await connectToOpenClawBrowser(log);
+  if (cdpCtx) return cdpCtx;
+
+  // Coalesce concurrent launch requests into one
+  if (_cdpBrowserLaunchPromise) return _cdpBrowserLaunchPromise;
+
+  _cdpBrowserLaunchPromise = (async () => {
+    const { chromium } = await import("playwright");
+    log("[cli-bridge:grok] launching persistent Chromium…");
+    try {
+      const ctx = await chromium.launchPersistentContext(GROK_PROFILE_DIR, {
+        headless: true,
+        args: ["--no-sandbox", "--disable-setuid-sandbox"],
+      });
+      grokContext = ctx;
+      // Auto-cleanup on browser crash
+      ctx.on("close", () => { grokContext = null; log("[cli-bridge:grok] persistent context closed"); });
+      log("[cli-bridge:grok] persistent context ready");
+      return ctx;
+    } catch (err) {
+      log(`[cli-bridge:grok] failed to launch browser: ${(err as Error).message}`);
+      return null;
+    } finally {
+      _cdpBrowserLaunchPromise = null;
+    }
+  })();
+  return _cdpBrowserLaunchPromise;
+}
+
+/** Clean up all browser resources — call on plugin teardown */
+async function cleanupBrowsers(log: (msg: string) => void): Promise<void> {
+  if (grokContext) {
+    try { await grokContext.close(); } catch { /* ignore */ }
+    grokContext = null;
+  }
+  if (_cdpBrowser) {
+    try { await _cdpBrowser.close(); } catch { /* ignore */ }
+    _cdpBrowser = null;
+  }
+  claudeContext = null;
+  geminiContext = null;
+  log("[cli-bridge] browser resources cleaned up");
 }
 
 async function tryRestoreGrokSession(
@@ -583,7 +651,7 @@ function proxyTestRequest(
 const plugin = {
   id: "openclaw-cli-bridge-elvatis",
   name: "OpenClaw CLI Bridge",
-  version: "0.2.29",
+  version: "0.2.30",
   description:
     "Phase 1: openai-codex auth bridge. " +
     "Phase 2: HTTP proxy for gemini/claude CLIs. " +
@@ -717,6 +785,17 @@ const plugin = {
               }
               return null;
             },
+            getGeminiContext: () => geminiContext,
+            connectGeminiContext: async () => {
+              const ctx = await connectToOpenClawBrowser((msg) => api.logger.info(msg));
+              if (ctx) {
+                const { getOrCreateGeminiPage } = await import("./src/gemini-browser.js");
+                const { page } = await getOrCreateGeminiPage(ctx);
+                const editor = await page.locator(".ql-editor").isVisible().catch(() => false);
+                if (editor) { geminiContext = ctx; return ctx; }
+              }
+              return null;
+            },
           });
           proxyServer = server;
           api.logger.info(
@@ -760,6 +839,17 @@ const plugin = {
                   }
                   return null;
                 },
+                getGeminiContext: () => geminiContext,
+                connectGeminiContext: async () => {
+                  const ctx = await connectToOpenClawBrowser((msg) => api.logger.info(msg));
+                  if (ctx) {
+                    const { getOrCreateGeminiPage } = await import("./src/gemini-browser.js");
+                    const { page } = await getOrCreateGeminiPage(ctx);
+                    const editor = await page.locator(".ql-editor").isVisible().catch(() => false);
+                    if (editor) { geminiContext = ctx; return ctx; }
+                  }
+                  return null;
+                },
               });
               proxyServer = server;
               api.logger.info(`[cli-bridge] proxy ready on :${port} (retry)`);
@@ -781,6 +871,9 @@ const plugin = {
       id: "cli-bridge-proxy",
       start: async () => { /* proxy already started above */ },
       stop: async () => {
+        // Clean up browser resources first
+        await cleanupBrowsers((msg) => api.logger.info(msg));
+
         if (proxyServer) {
           // closeAllConnections() forcefully terminates keep-alive connections
           // so that server.close() releases the port immediately rather than
@@ -1113,23 +1206,8 @@ const plugin = {
         }
 
         api.logger.info("[cli-bridge:claude] /claude-login: connecting to OpenClaw browser…");
-        const { chromium } = await import("playwright");
-
-        // Import cookies from OpenClaw browser
-        let importedCookies: unknown[] = [];
-        try {
-          const ocBrowser = await chromium.connectOverCDP("http://127.0.0.1:18800", { timeout: 3000 });
-          const ocCtx = ocBrowser.contexts()[0];
-          if (ocCtx) {
-            importedCookies = await ocCtx.cookies(["https://claude.ai", "https://anthropic.com"]);
-            api.logger.info(`[cli-bridge:claude] imported ${importedCookies.length} cookies`);
-          }
-          await ocBrowser.close().catch(() => {});
-        } catch {
-          api.logger.info("[cli-bridge:claude] OpenClaw browser not available");
-        }
 
-        // Connect to OpenClaw browser context for session
+        // Connect to OpenClaw browser context for session (singleton CDP)
         const ctx = await connectToOpenClawBrowser((msg) => api.logger.info(msg));
         if (!ctx) return { text: "❌ Could not connect to OpenClaw browser.\nMake sure claude.ai is open in your browser." };
 
@@ -1192,6 +1270,82 @@ const plugin = {
         return { text: "✅ Disconnected from claude.ai. Run `/claude-login` to reconnect." };
       },
     } satisfies OpenClawPluginCommandDefinition);
+
+    // ── Gemini web-session commands ───────────────────────────────────────────
+    api.registerCommand({
+      name: "gemini-login",
+      description: "Authenticate gemini.google.com: imports session from OpenClaw browser",
+      handler: async (): Promise<PluginCommandResult> => {
+        if (geminiContext) {
+          const { getOrCreateGeminiPage } = await import("./src/gemini-browser.js");
+          try {
+            const { page } = await getOrCreateGeminiPage(geminiContext);
+            const editor = await page.locator(".ql-editor").isVisible().catch(() => false);
+            if (editor) return { text: "✅ Already connected to gemini.google.com. Use `/gemini-logout` first to reset." };
+          } catch { /* fall through */ }
+          geminiContext = null;
+        }
+
+        api.logger.info("[cli-bridge:gemini] /gemini-login: connecting to OpenClaw browser…");
+        const ctx = await connectToOpenClawBrowser((msg) => api.logger.info(msg));
+        if (!ctx) return { text: "❌ Could not connect to OpenClaw browser.\nMake sure gemini.google.com is open in your browser." };
+
+        const { getOrCreateGeminiPage } = await import("./src/gemini-browser.js");
+        let page;
+        try {
+          ({ page } = await getOrCreateGeminiPage(ctx));
+        } catch (err) {
+          return { text: `❌ Failed to open gemini.google.com: ${(err as Error).message}` };
+        }
+
+        const editor = await page.locator(".ql-editor").isVisible().catch(() => false);
+        if (!editor) {
+          return { text: "❌ Gemini editor not visible — are you logged in?\nOpen gemini.google.com in your browser and try again." };
+        }
+
+        geminiContext = ctx;
+
+        const expiry = await scanGeminiCookieExpiry(ctx);
+        if (expiry) {
+          saveGeminiExpiry(expiry);
+          api.logger.info(`[cli-bridge:gemini] cookie expiry: ${new Date(expiry.expiresAt).toISOString()}`);
+        }
+        const expiryLine = expiry ? `\n\n🕐 Cookie expiry: ${formatGeminiExpiry(expiry)}` : "";
+
+        return { text: `✅ Gemini session ready!\n\nModels available:\n• \`vllm/web-gemini/gemini-2-5-pro\`\n• \`vllm/web-gemini/gemini-2-5-flash\`\n• \`vllm/web-gemini/gemini-3-pro\`\n• \`vllm/web-gemini/gemini-3-flash\`${expiryLine}` };
+      },
+    } satisfies OpenClawPluginCommandDefinition);
+
+    api.registerCommand({
+      name: "gemini-status",
+      description: "Check gemini.google.com session status",
+      handler: async (): Promise<PluginCommandResult> => {
+        if (!geminiContext) {
+          return { text: "❌ No active gemini.google.com session\nRun `/gemini-login` to authenticate." };
+        }
+        const { getOrCreateGeminiPage } = await import("./src/gemini-browser.js");
+        try {
+          const { page } = await getOrCreateGeminiPage(geminiContext);
+          const editor = await page.locator(".ql-editor").isVisible().catch(() => false);
+          if (editor) {
+            const expiry = loadGeminiExpiry();
+            const expiryLine = expiry ? `\n🕐 ${formatGeminiExpiry(expiry)}` : "";
+            return { text: `✅ gemini.google.com session active\nProxy: \`127.0.0.1:${port}\`\nModels: web-gemini/gemini-2-5-pro, gemini-2-5-flash, gemini-3-pro, gemini-3-flash${expiryLine}` };
+          }
+        } catch { /* fall through */ }
+        geminiContext = null;
+        return { text: "❌ Session lost — run `/gemini-login` to re-authenticate." };
+      },
+    } satisfies OpenClawPluginCommandDefinition);
+
+    api.registerCommand({
+      name: "gemini-logout",
+      description: "Disconnect from gemini.google.com session",
+      handler: async (): Promise<PluginCommandResult> => {
+        geminiContext = null;
+        return { text: "✅ Disconnected from gemini.google.com. Run `/gemini-login` to reconnect." };
+      },
+    } satisfies OpenClawPluginCommandDefinition);
     // ─────────────────────────────────────────────────────────────────────────
 
     const allCommands = [
@@ -1205,6 +1359,9 @@ const plugin = {
       "/claude-login",
       "/claude-status",
       "/claude-logout",
+      "/gemini-login",
+      "/gemini-status",
+      "/gemini-logout",
     ];
     api.logger.info(`[cli-bridge] registered ${allCommands.length} commands: ${allCommands.join(", ")}`);
   },

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-cli-bridge-elvatis",
   "name": "OpenClaw CLI Bridge",
-  "version": "0.2.29",
+  "version": "0.2.30",
   "description": "Phase 1: openai-codex auth bridge. Phase 2: local HTTP proxy routing model calls through gemini/claude CLIs (vllm provider).",
   "providers": [
     "openai-codex"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elvatis_com/openclaw-cli-bridge-elvatis",
-  "version": "0.2.29",
+  "version": "0.2.30",
   "description": "Bridges gemini, claude, and codex CLI tools as OpenClaw model providers. Reads existing CLI auth without re-login.",
   "type": "module",
   "openclaw": {

package/src/gemini-browser.ts

@@ -0,0 +1,242 @@
+/**
+ * gemini-browser.ts
+ *
+ * Gemini web automation via Playwright DOM-polling.
+ * Strategy identical to grok-client.ts / claude-browser.ts.
+ *
+ * DOM structure (confirmed 2026-03-11):
+ *   Editor:   .ql-editor (Quill — use page.type(), NOT execCommand)
+ *   Response: message-content (custom element, innerText = clean response)
+ *   Also:     .markdown (same content, markdown-rendered)
+ */
+
+import type { BrowserContext, Page } from "playwright";
+
+export interface ChatMessage {
+  role: "system" | "user" | "assistant";
+  content: string;
+}
+
+export interface GeminiBrowserOptions {
+  messages: ChatMessage[];
+  model?: string;
+  timeoutMs?: number;
+}
+
+export interface GeminiBrowserResult {
+  content: string;
+  model: string;
+  finishReason: string;
+}
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+const STABLE_CHECKS = 3;
+const STABLE_INTERVAL_MS = 600; // slightly longer — Gemini streams slower
+const GEMINI_HOME = "https://gemini.google.com/app";
+
+const MODEL_MAP: Record<string, string> = {
+  "gemini-2-5-pro":        "gemini-2.5-pro",
+  "gemini-2-5-flash":      "gemini-2.5-flash",
+  "gemini-flash":          "gemini-flash",
+  "gemini-pro":            "gemini-pro",
+  "gemini-3-pro":          "gemini-3-pro",
+  "gemini-3-flash":        "gemini-3-flash",
+};
+
+function resolveModel(m?: string): string {
+  const clean = (m ?? "gemini-2-5-pro").replace("web-gemini/", "").replace(/\./g, "-");
+  return MODEL_MAP[clean] ?? "gemini-2.5-pro";
+}
+
+function flattenMessages(messages: ChatMessage[]): string {
+  if (messages.length === 1) return messages[0].content;
+  return messages
+    .map((m) => {
+      if (m.role === "system") return `[System]: ${m.content}`;
+      if (m.role === "assistant") return `[Assistant]: ${m.content}`;
+      return m.content;
+    })
+    .join("\n\n");
+}
+
+/**
+ * Get or create a Gemini page in the given context.
+ */
+export async function getOrCreateGeminiPage(
+  context: BrowserContext
+): Promise<{ page: Page; owned: boolean }> {
+  const existing = context.pages().filter((p) => p.url().startsWith("https://gemini.google.com"));
+  if (existing.length > 0) return { page: existing[0], owned: false };
+  const page = await context.newPage();
+  await page.goto(GEMINI_HOME, { waitUntil: "domcontentloaded", timeout: 15_000 });
+  await new Promise((r) => setTimeout(r, 2_000));
+  return { page, owned: true };
+}
+
+/**
+ * Count model-response elements on the page (= number of assistant turns).
+ */
+async function countResponses(page: Page): Promise<number> {
+  return page.evaluate(() => document.querySelectorAll("model-response").length);
+}
+
+/**
+ * Get the text of the last model-response via message-content element.
+ * Uses message-content (cleanest, no "Gemini hat gesagt" prefix).
+ */
+async function getLastResponseText(page: Page): Promise<string> {
+  return page.evaluate(() => {
+    const els = [...document.querySelectorAll("message-content")];
+    if (!els.length) return "";
+    return els[els.length - 1].textContent?.trim() ?? "";
+  });
+}
+
+/**
+ * Check if Gemini is still generating (streaming indicator present).
+ */
+async function isStreaming(page: Page): Promise<boolean> {
+  return page.evaluate(() => {
+    // Gemini shows a stop button while streaming
+    const stopBtn = document.querySelector('button[aria-label*="stop"], button[aria-label*="Stop"], button[aria-label*="stopp"]');
+    return !!stopBtn;
+  });
+}
+
+/**
+ * Send a message and wait for a stable response via DOM-polling.
+ */
+async function sendAndWait(
+  page: Page,
+  message: string,
+  timeoutMs: number,
+  log: (msg: string) => void
+): Promise<string> {
+  const countBefore = await countResponses(page);
+
+  // Quill editor: use page.type() (not execCommand — Quill ignores it)
+  const editor = page.locator(".ql-editor");
+  await editor.click();
+  await editor.type(message, { delay: 10 });
+  await new Promise((r) => setTimeout(r, 300));
+  await page.keyboard.press("Enter");
+
+  log(`gemini-browser: message sent (${message.length} chars), waiting…`);
+
+  const deadline = Date.now() + timeoutMs;
+  let lastText = "";
+  let stableCount = 0;
+
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, STABLE_INTERVAL_MS));
+
+    // Wait for new response to appear
+    const currentCount = await countResponses(page);
+    if (currentCount <= countBefore) continue;
+
+    // Still streaming? Don't start stable-check yet
+    const streaming = await isStreaming(page);
+    if (streaming) {
+      stableCount = 0;
+      lastText = await getLastResponseText(page);
+      continue;
+    }
+
+    const text = await getLastResponseText(page);
+    if (!text) continue;
+
+    if (text === lastText) {
+      stableCount++;
+      if (stableCount >= STABLE_CHECKS) {
+        log(`gemini-browser: response stable (${text.length} chars)`);
+        return text;
+      }
+    } else {
+      stableCount = 0;
+      lastText = text;
+    }
+  }
+
+  throw new Error(`gemini.google.com response timeout after ${timeoutMs}ms`);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+export async function geminiComplete(
+  context: BrowserContext,
+  opts: GeminiBrowserOptions,
+  log: (msg: string) => void
+): Promise<GeminiBrowserResult> {
+  const { page, owned } = await getOrCreateGeminiPage(context);
+  const model = resolveModel(opts.model);
+  const prompt = flattenMessages(opts.messages);
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+
+  log(`gemini-browser: complete model=${model}`);
+
+  try {
+    const content = await sendAndWait(page, prompt, timeoutMs, log);
+    return { content, model, finishReason: "stop" };
+  } finally {
+    if (owned) await page.close().catch(() => {});
+  }
+}
+
+export async function geminiCompleteStream(
+  context: BrowserContext,
+  opts: GeminiBrowserOptions,
+  onToken: (token: string) => void,
+  log: (msg: string) => void
+): Promise<GeminiBrowserResult> {
+  const { page, owned } = await getOrCreateGeminiPage(context);
+  const model = resolveModel(opts.model);
+  const prompt = flattenMessages(opts.messages);
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+
+  log(`gemini-browser: stream model=${model}`);
+
+  const countBefore = await countResponses(page);
+
+  const editor = page.locator(".ql-editor");
+  await editor.click();
+  await editor.type(prompt, { delay: 10 });
+  await new Promise((r) => setTimeout(r, 300));
+  await page.keyboard.press("Enter");
+
+  const deadline = Date.now() + timeoutMs;
+  let emittedLength = 0;
+  let lastText = "";
+  let stableCount = 0;
+
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, STABLE_INTERVAL_MS));
+
+    const currentCount = await countResponses(page);
+    if (currentCount <= countBefore) continue;
+
+    const text = await getLastResponseText(page);
+
+    if (text.length > emittedLength) {
+      onToken(text.slice(emittedLength));
+      emittedLength = text.length;
+    }
+
+    const streaming = await isStreaming(page);
+    if (streaming) { stableCount = 0; continue; }
+
+    if (text && text === lastText) {
+      stableCount++;
+      if (stableCount >= STABLE_CHECKS) {
+        log(`gemini-browser: stream done (${text.length} chars)`);
+        if (owned) await page.close().catch(() => {});
+        return { content: text, model, finishReason: "stop" };
+      }
+    } else {
+      stableCount = 0;
+      lastText = text;
+    }
+  }
+
+  if (owned) await page.close().catch(() => {});
+  throw new Error(`gemini.google.com stream timeout after ${timeoutMs}ms`);
+}

package/src/proxy-server.ts

@@ -14,6 +14,7 @@ import { type ChatMessage, routeToCliRunner } from "./cli-runner.js";
 import { scheduleTokenRefresh, setAuthLogger, stopTokenRefresh } from "./claude-auth.js";
 import { grokComplete, grokCompleteStream, type ChatMessage as GrokChatMessage } from "./grok-client.js";
 import { claudeComplete, claudeCompleteStream, type ChatMessage as ClaudeBrowserChatMessage } from "./claude-browser.js";
+import { geminiComplete, geminiCompleteStream, type ChatMessage as GeminiBrowserChatMessage } from "./gemini-browser.js";
 import type { BrowserContext } from "playwright";
 
 export type GrokCompleteOptions = Parameters<typeof grokComplete>[1];
@@ -42,6 +43,14 @@ export interface ProxyServerOptions {
   _claudeComplete?: typeof claudeComplete;
   /** Override for testing — replaces claudeCompleteStream */
   _claudeCompleteStream?: typeof claudeCompleteStream;
+  /** Returns the current authenticated Gemini BrowserContext (null if not logged in) */
+  getGeminiContext?: () => BrowserContext | null;
+  /** Async lazy connect — called when getGeminiContext returns null */
+  connectGeminiContext?: () => Promise<BrowserContext | null>;
+  /** Override for testing — replaces geminiComplete */
+  _geminiComplete?: typeof geminiComplete;
+  /** Override for testing — replaces geminiCompleteStream */
+  _geminiCompleteStream?: typeof geminiCompleteStream;
 }
 
 /** Available CLI bridge models for GET /v1/models */
@@ -91,6 +100,11 @@ export const CLI_MODELS = [
   { id: "web-claude/claude-sonnet",   name: "Claude Sonnet (web session)",   contextWindow: 200_000, maxTokens: 8192 },
   { id: "web-claude/claude-opus",     name: "Claude Opus (web session)",     contextWindow: 200_000, maxTokens: 8192 },
   { id: "web-claude/claude-haiku",    name: "Claude Haiku (web session)",    contextWindow: 200_000, maxTokens: 8192 },
+  // Gemini web-session models (requires /gemini-login)
+  { id: "web-gemini/gemini-2-5-pro",   name: "Gemini 2.5 Pro (web session)",   contextWindow: 1_000_000, maxTokens: 8192 },
+  { id: "web-gemini/gemini-2-5-flash", name: "Gemini 2.5 Flash (web session)", contextWindow: 1_000_000, maxTokens: 8192 },
+  { id: "web-gemini/gemini-3-pro",     name: "Gemini 3 Pro (web session)",     contextWindow: 1_000_000, maxTokens: 8192 },
+  { id: "web-gemini/gemini-3-flash",   name: "Gemini 3 Flash (web session)",   contextWindow: 1_000_000, maxTokens: 8192 },
 ];
 
 // ──────────────────────────────────────────────────────────────────────────────
@@ -311,6 +325,55 @@ async function handleRequest(
     }
     // ─────────────────────────────────────────────────────────────────────────
 
+    // ── Gemini web-session routing ────────────────────────────────────────────
+    if (model.startsWith("web-gemini/")) {
+      let geminiCtx = opts.getGeminiContext?.() ?? null;
+      if (!geminiCtx && opts.connectGeminiContext) {
+        geminiCtx = await opts.connectGeminiContext();
+      }
+      if (!geminiCtx) {
+        res.writeHead(503, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: { message: "No active gemini.google.com session. Use /gemini-login to authenticate.", code: "no_gemini_session" } }));
+        return;
+      }
+      const timeoutMs = opts.timeoutMs ?? 120_000;
+      const geminiMessages = messages as GeminiBrowserChatMessage[];
+      const doGeminiComplete = opts._geminiComplete ?? geminiComplete;
+      const doGeminiCompleteStream = opts._geminiCompleteStream ?? geminiCompleteStream;
+      try {
+        if (stream) {
+          res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive", ...corsHeaders() });
+          sendSseChunk(res, { id, created, model, delta: { role: "assistant" }, finish_reason: null });
+          const result = await doGeminiCompleteStream(
+            geminiCtx,
+            { messages: geminiMessages, model, timeoutMs },
+            (token) => sendSseChunk(res, { id, created, model, delta: { content: token }, finish_reason: null }),
+            opts.log
+          );
+          sendSseChunk(res, { id, created, model, delta: {}, finish_reason: result.finishReason });
+          res.write("data: [DONE]\n\n");
+          res.end();
+        } else {
+          const result = await doGeminiComplete(geminiCtx, { messages: geminiMessages, model, timeoutMs }, opts.log);
+          res.writeHead(200, { "Content-Type": "application/json", ...corsHeaders() });
+          res.end(JSON.stringify({
+            id, object: "chat.completion", created, model,
+            choices: [{ index: 0, message: { role: "assistant", content: result.content }, finish_reason: result.finishReason }],
+            usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+          }));
+        }
+      } catch (err) {
+        const msg = (err as Error).message;
+        opts.warn(`[cli-bridge] Gemini browser error for ${model}: ${msg}`);
+        if (!res.headersSent) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: { message: msg, type: "gemini_browser_error" } }));
+        }
+      }
+      return;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+
     // ── CLI runner routing (Gemini / Claude Code) ─────────────────────────────
     let content: string;
     try {

package/test/gemini-proxy.test.ts

@@ -0,0 +1,139 @@
+/**
+ * test/gemini-proxy.test.ts
+ *
+ * Tests for Gemini web-session routing in the cli-bridge proxy.
+ * Uses _geminiComplete/_geminiCompleteStream DI overrides (no real browser).
+ */
+
+import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
+import http from "node:http";
+import type { AddressInfo } from "node:net";
+import { startProxyServer, CLI_MODELS } from "../src/proxy-server.js";
+import type { BrowserContext } from "playwright";
+
+type GeminiCompleteOptions = { messages: { role: string; content: string }[]; model?: string; timeoutMs?: number };
+type GeminiCompleteResult = { content: string; model: string; finishReason: string };
+
+const stubGeminiComplete = vi.fn(async (
+  _ctx: BrowserContext,
+  opts: GeminiCompleteOptions,
+  _log: (msg: string) => void
+): Promise<GeminiCompleteResult> => ({
+  content: `gemini mock: ${opts.messages[opts.messages.length - 1]?.content ?? ""}`,
+  model: opts.model ?? "web-gemini/gemini-2-5-pro",
+  finishReason: "stop",
+}));
+
+const stubGeminiCompleteStream = vi.fn(async (
+  _ctx: BrowserContext,
+  opts: GeminiCompleteOptions,
+  onToken: (t: string) => void,
+  _log: (msg: string) => void
+): Promise<GeminiCompleteResult> => {
+  const tokens = ["gemini ", "stream ", "mock"];
+  for (const t of tokens) onToken(t);
+  return { content: tokens.join(""), model: opts.model ?? "web-gemini/gemini-2-5-pro", finishReason: "stop" };
+});
+
+async function httpPost(url: string, body: unknown): Promise<{ status: number; body: unknown }> {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const u = new URL(url);
+    const req = http.request(
+      { hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data) } },
+      (res) => { let raw = ""; res.on("data", c => raw += c); res.on("end", () => { try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(raw) }); } catch { resolve({ status: res.statusCode ?? 0, body: raw }); } }); }
+    );
+    req.on("error", reject); req.write(data); req.end();
+  });
+}
+async function httpGet(url: string): Promise<{ status: number; body: unknown }> {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const req = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "GET" },
+      (res) => { let raw = ""; res.on("data", c => raw += c); res.on("end", () => { try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(raw) }); } catch { resolve({ status: res.statusCode ?? 0, body: raw }); } }); }
+    );
+    req.on("error", reject); req.end();
+  });
+}
+
+const fakeCtx = {} as BrowserContext;
+let server: http.Server;
+let baseUrl: string;
+
+beforeAll(async () => {
+  server = await startProxyServer({
+    port: 0, log: () => {}, warn: () => {},
+    getGeminiContext: () => fakeCtx,
+    // @ts-expect-error — stub types close enough for testing
+    _geminiComplete: stubGeminiComplete,
+    // @ts-expect-error — stub types close enough for testing
+    _geminiCompleteStream: stubGeminiCompleteStream,
+  });
+  baseUrl = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+});
+afterAll(() => server.close());
+
+describe("Gemini web-session routing — model list", () => {
+  it("includes web-gemini/* models in /v1/models", async () => {
+    const res = await httpGet(`${baseUrl}/v1/models`);
+    expect(res.status).toBe(200);
+    const ids = (res.body as { data: { id: string }[] }).data.map(m => m.id);
+    expect(ids).toContain("web-gemini/gemini-2-5-pro");
+    expect(ids).toContain("web-gemini/gemini-3-pro");
+  });
+
+  it("web-gemini/* models listed in CLI_MODELS constant", () => {
+    expect(CLI_MODELS.some(m => m.id.startsWith("web-gemini/"))).toBe(true);
+  });
+});
+
+describe("Gemini web-session routing — non-streaming", () => {
+  it("returns assistant message for web-gemini/gemini-2-5-pro", async () => {
+    const res = await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "web-gemini/gemini-2-5-pro",
+      messages: [{ role: "user", content: "hello gemini" }],
+      stream: false,
+    });
+    expect(res.status).toBe(200);
+    const body = res.body as { choices: { message: { content: string } }[] };
+    expect(body.choices[0].message.content).toContain("gemini mock");
+    expect(body.choices[0].message.content).toContain("hello gemini");
+  });
+
+  it("passes correct model to stub", async () => {
+    stubGeminiComplete.mockClear();
+    await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "web-gemini/gemini-3-flash",
+      messages: [{ role: "user", content: "test" }],
+    });
+    expect(stubGeminiComplete).toHaveBeenCalledOnce();
+    expect(stubGeminiComplete.mock.calls[0][1].model).toBe("web-gemini/gemini-3-flash");
+  });
+
+  it("returns 503 when no gemini context", async () => {
+    const s = await startProxyServer({ port: 0, log: () => {}, warn: () => {}, getGeminiContext: () => null });
+    const url = `http://127.0.0.1:${(s.address() as AddressInfo).port}`;
+    const res = await httpPost(`${url}/v1/chat/completions`, {
+      model: "web-gemini/gemini-2-5-pro",
+      messages: [{ role: "user", content: "hi" }],
+    });
+    expect(res.status).toBe(503);
+    expect((res.body as { error: { code: string } }).error.code).toBe("no_gemini_session");
+    s.close();
+  });
+});
+
+describe("Gemini web-session routing — streaming", () => {
+  it("returns SSE stream", async () => {
+    return new Promise<void>((resolve, reject) => {
+      const body = JSON.stringify({ model: "web-gemini/gemini-2-5-pro", messages: [{ role: "user", content: "stream" }], stream: true });
+      const u = new URL(`${baseUrl}/v1/chat/completions`);
+      const req = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } },
+        (res) => { expect(res.statusCode).toBe(200); let raw = ""; res.on("data", c => raw += c); res.on("end", () => { expect(raw).toContain("[DONE]"); resolve(); }); }
+      );
+      req.on("error", reject); req.write(body); req.end();
+    });
+  });
+});