@elvatis_com/openclaw-cli-bridge-elvatis 1.0.0 → 1.2.0

package/.ai/handoff/STATUS.md

@@ -1,54 +1,35 @@
 # STATUS — openclaw-cli-bridge-elvatis
 
-## Current Version: 0.2.28 (npm + ClawHub + GitHub)
-
-## What's Done
-- v0.2.25: Sleep-resilient token refresh (setInterval), staged /cli-* switch
-- v0.2.26: Grok DOM-polling bridge (grok-client.ts, grok-session.ts)
-- v0.2.27: Persistent Chromium profile (~/.openclaw/grok-profile/)
-- v0.2.28: Cookie-expiry tracking (/grok-status shows ✅/⚠️/🚨)
-- claude-browser.ts: DOM-automation for claude.ai (not yet in proxy — NEXT)
-- 77/77 tests green
-
-## Next: v0.3.x → v1.0.0 — Full Headless Provider Bridge
-
-### Provider Status
-| Provider | DOM confirmed | browser.ts | Proxy routed | Login cmd | Tests |
-|---|---|---|---|---|---|
-| Grok | ✅ | ✅ grok-client.ts | ✅ web-grok/* | ✅ /grok-login | ✅ |
-| Claude | ✅ | ✅ claude-browser.ts | ❌ | ❌ | partial |
-| Gemini | ❌ | ❌ | ❌ | ❌ | ❌ |
-| ChatGPT | ❌ | ❌ | ❌ | ❌ | ❌ |
-
-### Claude DOM (confirmed 2026-03-11)
-- URL: https://claude.ai/new
-- Editor: .ProseMirror (tiptap)
-- Messages: [data-test-render-count] divs
-- Assistant msgs: child div class "group" (no "mb-1 mt-6")
-- User msgs: child div class "mb-1 mt-6 group"
-- CLOUDFLARE: persistent headless blocked — must use OpenClaw browser (CDP 18800)
-- Tested working: CLAUDE_WORKS response confirmed via OpenClaw browser
-
-### Next Steps (in order)
-1. Add connectToOpenClawBrowser() to claude-browser.ts (same as grok-session.ts)
-2. Add web-claude/* routing to proxy-server.ts (same as web-grok/*)
-3. Add /claude-login, /claude-status, /claude-logout to index.ts
-4. Add claude-browser integration tests (DI-override, same as grok-proxy.test.ts)
-5. Repeat for Gemini (gemini.google.com) and ChatGPT (chatgpt.com)
-6. Bump to v1.0.0 when all 4 providers green + all tests pass
-
-## Key Files
-- src/claude-browser.ts — Claude DOM automation (ready, not wired)
-- src/grok-client.ts — reference implementation
-- src/grok-session.ts — reference for login/session management
-- src/proxy-server.ts — add web-claude/* routing here
-- index.ts — add /claude-login here
-- test/claude-browser.test.ts — unit tests (partial, needs proxy integration test)
-
-## Constraints
-- OpenClaw browser (CDP 18800) required for Cloudflare bypass
-- persistent profile approach fails (fingerprint mismatch)
-- Each provider: own profile dir ~/.openclaw/<provider>-profile/
-- All providers share same proxy port 31337
-- Publish only after full test pass (77+ tests green)
-- All 3 platforms on every release: GitHub + npm + ClawHub
+## Current Version: 1.0.0 (npm + ClawHub + GitHub) ✅ RELEASED
+
+## All 4 Providers LIVE — Tested 2026-03-11 22:24
+| Provider | Status | Models | Command |
+|---|---|---|---|
+| Grok | ✅ | web-grok/grok-3, grok-3-fast, grok-3-mini, grok-3-mini-fast | /grok-login |
+| Claude | ✅ | web-claude/claude-sonnet, claude-opus, claude-haiku | /claude-login |
+| Gemini | ✅ | web-gemini/gemini-2-5-pro, gemini-2-5-flash, gemini-3-pro, gemini-3-flash | /gemini-login |
+| ChatGPT | ✅ | web-chatgpt/gpt-4o, gpt-4o-mini, gpt-o3, gpt-o4-mini, gpt-5 | /chatgpt-login |
+
+Live test: "What is the capital of France?"
+- Grok: "Paris" ✅
+- Claude: "Paris" ✅
+- Gemini: "Paris" ✅
+- ChatGPT: "Paris" ✅
+
+## Stats
+- 22 total models, 16 web-session models
+- 96/96 tests green (8 test files)
+- 0 zombie Chromium processes (singleton CDP, cleanupBrowsers on stop)
+- Cookie expiry tracking for all 4 providers
+
+## Known Issue: Browser persistence after Gateway restart
+After SIGUSR1/full restart, OpenClaw browser is gone (CDP ECONNREFUSED).
+Workaround: manually open browser + 4 provider pages → lazy connect takes over.
+Fix needed: auto-start browser on plugin init, or keep-alive ping.
+
+## Next Steps (v1.1.x)
+- Auto-reconnect OpenClaw browser on plugin start
+- /status command showing all 4 providers at once
+- Context-window management for long conversations (new page per conversation)
+- Handle model-switching within chatgpt.com (dropdown selector)
+- Handle Gemini model switching (2.5 Pro vs Flash vs 3)

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:** `1.0.0`
+**Current version:** `1.2.0`
 
 ---
 
@@ -287,12 +287,31 @@ npm test            # vitest run (45 tests)
 
 ## Changelog
 
+### v1.2.0
+- **fix:** Fresh page per request — no more message accumulation across calls
+- **feat:** ChatGPT model switching via URL param (?model=gpt-4o, o3, etc.)
+- **chore:** Gemini model switching: TODO (requires UI interaction)
+
+### v1.1.0
+- **feat:** Auto-connect all providers on startup (no manual login after restart if browser is open)
+- **feat:** `/bridge-status` — all 4 providers at a glance with expiry info
+- **fix:** Removed obsolete CLI models: gpt-5.2-codex, gpt-5.3-codex-spark, gpt-5.1-codex-mini, gemini-3-flash-preview
+- **fix:** Removed duplicate cli-gemini3-flash (was same as gemini-3-flash-preview)
+- **chore:** Cleaned up CLI_MODEL_COMMANDS (8 models, down from 13)
+
 ## v1.0.0 — Full Headless Browser Bridge 🚀
 
 All four major LLM providers are now available via browser automation.
 No CLI binaries required — just authenticated browser sessions.
 
-### v1.0.0
+#### v1.1.0
+- **feat:** Auto-connect all providers on startup (no manual login after restart if browser is open)
+- **feat:** `/bridge-status` — all 4 providers at a glance with expiry info
+- **fix:** Removed obsolete CLI models: gpt-5.2-codex, gpt-5.3-codex-spark, gpt-5.1-codex-mini, gemini-3-flash-preview
+- **fix:** Removed duplicate cli-gemini3-flash (was same as gemini-3-flash-preview)
+- **chore:** Cleaned up CLI_MODEL_COMMANDS (8 models, down from 13)
+
+## v1.0.0
 - **feat:** `chatgpt-browser.ts` — chatgpt.com DOM-automation (`#prompt-textarea` + `[data-message-author-role]`)
 - **feat:** `web-chatgpt/*` models: gpt-4o, gpt-4o-mini, gpt-o3, gpt-o4-mini, gpt-5
 - **feat:** `/chatgpt-login`, `/chatgpt-status`, `/chatgpt-logout` + cookie-expiry tracking

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:** 1.0.0
+**Version:** 1.2.0

package/index.ts

@@ -6,7 +6,7 @@
  *
  * Phase 2 (request bridge): starts a local OpenAI-compatible HTTP proxy server
  *   and configures OpenClaw's vllm provider to route through it. Model calls
- *   are handled by the Gemini CLI and Claude Code CLI subprocesses.
+ *   are routed to CLI tools or browser-session providers.
  *
  * Phase 3 (slash commands): registers /cli-* commands for instant model switching.
  *   /cli-sonnet       → vllm/cli-claude/claude-sonnet-4-6      (Claude Code CLI proxy)
@@ -15,9 +15,8 @@
  *   /cli-gemini       → vllm/cli-gemini/gemini-2.5-pro         (Gemini CLI proxy)
  *   /cli-gemini-flash → vllm/cli-gemini/gemini-2.5-flash       (Gemini CLI proxy)
  *   /cli-gemini3      → vllm/cli-gemini/gemini-3-pro-preview   (Gemini CLI proxy)
- *   /cli-gemini3-flash→ vllm/cli-gemini/gemini-3-flash-preview (Gemini CLI proxy)
  *   /cli-codex        → openai-codex/gpt-5.3-codex             (Codex CLI OAuth, direct API)
- *   /cli-codex-mini   → openai-codex/gpt-5.1-codex-mini        (Codex CLI OAuth, direct API)
+ *   /cli-codex54      → openai-codex/gpt-5.4                   (Codex CLI OAuth, direct API)
  *   /cli-back         → restore model that was active before last /cli-* switch
  *   /cli-test [model] → one-shot proxy health check (does NOT switch global model)
  *   /cli-list         → list all registered CLI bridge models with commands
@@ -405,81 +404,17 @@ function readCurrentModel(): string | null {
 // Phase 3: model command table
 // ──────────────────────────────────────────────────────────────────────────────
 const CLI_MODEL_COMMANDS = [
-  // ── Claude (via local proxy → Claude Code CLI) ──────────────────────────────
-  {
-    name: "cli-sonnet",
-    model: "vllm/cli-claude/claude-sonnet-4-6",
-    description: "Switch to Claude Sonnet 4.6 (Claude Code CLI via local proxy)",
-    label: "Claude Sonnet 4.6 (CLI)",
-  },
-  {
-    name: "cli-opus",
-    model: "vllm/cli-claude/claude-opus-4-6",
-    description: "Switch to Claude Opus 4.6 (Claude Code CLI via local proxy)",
-    label: "Claude Opus 4.6 (CLI)",
-  },
-  {
-    name: "cli-haiku",
-    model: "vllm/cli-claude/claude-haiku-4-5",
-    description: "Switch to Claude Haiku 4.5 (Claude Code CLI via local proxy)",
-    label: "Claude Haiku 4.5 (CLI)",
-  },
-  // ── Gemini (via local proxy → Gemini CLI) ───────────────────────────────────
-  {
-    name: "cli-gemini",
-    model: "vllm/cli-gemini/gemini-2.5-pro",
-    description: "Switch to Gemini 2.5 Pro (Gemini CLI via local proxy)",
-    label: "Gemini 2.5 Pro (CLI)",
-  },
-  {
-    name: "cli-gemini-flash",
-    model: "vllm/cli-gemini/gemini-2.5-flash",
-    description: "Switch to Gemini 2.5 Flash (Gemini CLI via local proxy)",
-    label: "Gemini 2.5 Flash (CLI)",
-  },
-  {
-    name: "cli-gemini3",
-    model: "vllm/cli-gemini/gemini-3-pro-preview",
-    description: "Switch to Gemini 3 Pro Preview (Gemini CLI via local proxy)",
-    label: "Gemini 3 Pro Preview (CLI)",
-  },
-  {
-    name: "cli-gemini3-flash",
-    model: "vllm/cli-gemini/gemini-3-flash-preview",
-    description: "Switch to Gemini 3 Flash Preview (Gemini CLI via local proxy)",
-    label: "Gemini 3 Flash Preview (CLI)",
-  },
-  // ── Codex (via openai-codex provider — Codex CLI OAuth auth, direct API) ────
-  {
-    name: "cli-codex",
-    model: "openai-codex/gpt-5.3-codex",
-    description: "Switch to GPT-5.3 Codex (openai-codex provider, Codex CLI auth)",
-    label: "GPT-5.3 Codex",
-  },
-  {
-    name: "cli-codex-spark",
-    model: "openai-codex/gpt-5.3-codex-spark",
-    description: "Switch to GPT-5.3 Codex Spark (openai-codex provider, Codex CLI auth)",
-    label: "GPT-5.3 Codex Spark",
-  },
-  {
-    name: "cli-codex52",
-    model: "openai-codex/gpt-5.2-codex",
-    description: "Switch to GPT-5.2 Codex (openai-codex provider, Codex CLI auth)",
-    label: "GPT-5.2 Codex",
-  },
-  {
-    name: "cli-codex54",
-    model: "openai-codex/gpt-5.4",
-    description: "Switch to GPT-5.4 (openai-codex provider, Codex CLI auth — may require upgraded scope)",
-    label: "GPT-5.4 (Codex)",
-  },
-  {
-    name: "cli-codex-mini",
-    model: "openai-codex/gpt-5.1-codex-mini",
-    description: "Switch to GPT-5.1 Codex Mini (openai-codex provider, Codex CLI auth)",
-    label: "GPT-5.1 Codex Mini",
-  },
+  // ── Claude Code CLI (via local proxy) ────────────────────────────────────────
+  { name: "cli-sonnet",       model: "vllm/cli-claude/claude-sonnet-4-6",    description: "Claude Sonnet 4.6 (Claude Code CLI)",   label: "Claude Sonnet 4.6 (CLI)" },
+  { name: "cli-opus",         model: "vllm/cli-claude/claude-opus-4-6",      description: "Claude Opus 4.6 (Claude Code CLI)",     label: "Claude Opus 4.6 (CLI)" },
+  { name: "cli-haiku",        model: "vllm/cli-claude/claude-haiku-4-5",     description: "Claude Haiku 4.5 (Claude Code CLI)",    label: "Claude Haiku 4.5 (CLI)" },
+  // ── Gemini CLI (via local proxy) ─────────────────────────────────────────────
+  { name: "cli-gemini",       model: "vllm/cli-gemini/gemini-2.5-pro",       description: "Gemini 2.5 Pro (Gemini CLI)",           label: "Gemini 2.5 Pro (CLI)" },
+  { name: "cli-gemini-flash", model: "vllm/cli-gemini/gemini-2.5-flash",     description: "Gemini 2.5 Flash (Gemini CLI)",         label: "Gemini 2.5 Flash (CLI)" },
+  { name: "cli-gemini3",      model: "vllm/cli-gemini/gemini-3-pro-preview", description: "Gemini 3 Pro (Gemini CLI)",             label: "Gemini 3 Pro (CLI)" },
+  // ── Codex CLI (openai-codex provider, OAuth auth) ────────────────────────────
+  { name: "cli-codex",        model: "openai-codex/gpt-5.3-codex",          description: "GPT-5.3 Codex (Codex CLI auth)",        label: "GPT-5.3 Codex" },
+  { name: "cli-codex54",      model: "openai-codex/gpt-5.4",                description: "GPT-5.4 (Codex CLI auth)",              label: "GPT-5.4" },
 ] as const;
 
 /** Default model used by /cli-test when no arg is given */
@@ -678,7 +613,7 @@ function proxyTestRequest(
 const plugin = {
   id: "openclaw-cli-bridge-elvatis",
   name: "OpenClaw CLI Bridge",
-  version: "1.0.0",
+  version: "1.2.0",
   description:
     "Phase 1: openai-codex auth bridge. " +
     "Phase 2: HTTP proxy for gemini/claude CLIs. " +
@@ -697,6 +632,53 @@ const plugin = {
     // ── Grok session restore (non-blocking) ───────────────────────────────────
     void tryRestoreGrokSession(grokSessionPath, (msg) => api.logger.info(msg));
 
+    // ── Auto-connect all browser providers on startup (non-blocking) ──────────
+    void (async () => {
+      // Wait for proxy to start first
+      await new Promise(r => setTimeout(r, 3000));
+      const log = (msg: string) => api.logger.info(msg);
+      const ctx = await connectToOpenClawBrowser(log);
+      if (!ctx) { log("[cli-bridge] startup auto-connect: OpenClaw browser not available"); return; }
+      const pages = ctx.pages().map(p => p.url());
+      log(`[cli-bridge] startup auto-connect: ${pages.length} pages open`);
+
+      // Claude
+      if (pages.some(u => u.includes("claude.ai")) && !claudeContext) {
+        try {
+          const { getOrCreateClaudePage } = await import("./src/claude-browser.js");
+          const { page } = await getOrCreateClaudePage(ctx);
+          if (await page.locator(".ProseMirror").isVisible().catch(() => false)) {
+            claudeContext = ctx;
+            log("[cli-bridge:claude] auto-connected ✅");
+          }
+        } catch { /* not available */ }
+      }
+
+      // Gemini
+      if (pages.some(u => u.includes("gemini.google.com")) && !geminiContext) {
+        try {
+          const { getOrCreateGeminiPage } = await import("./src/gemini-browser.js");
+          const { page } = await getOrCreateGeminiPage(ctx);
+          if (await page.locator(".ql-editor").isVisible().catch(() => false)) {
+            geminiContext = ctx;
+            log("[cli-bridge:gemini] auto-connected ✅");
+          }
+        } catch { /* not available */ }
+      }
+
+      // ChatGPT
+      if (pages.some(u => u.includes("chatgpt.com")) && !chatgptContext) {
+        try {
+          const { getOrCreateChatGPTPage } = await import("./src/chatgpt-browser.js");
+          const { page } = await getOrCreateChatGPTPage(ctx);
+          if (await page.locator("#prompt-textarea").isVisible().catch(() => false)) {
+            chatgptContext = ctx;
+            log("[cli-bridge:chatgpt] auto-connected ✅");
+          }
+        } catch { /* not available */ }
+      }
+    })();
+
     // ── Phase 1: openai-codex auth bridge ─────────────────────────────────────
     if (enableCodex) {
       api.registerProvider({
@@ -1457,6 +1439,93 @@ const plugin = {
         return { text: "✅ Disconnected from chatgpt.com. Run `/chatgpt-login` to reconnect." };
       },
     } satisfies OpenClawPluginCommandDefinition);
+
+    // ── /bridge-status — all providers at a glance ───────────────────────────
+    api.registerCommand({
+      name: "bridge-status",
+      description: "Show status of all headless browser providers (Grok, Claude, Gemini, ChatGPT)",
+      handler: async (): Promise<PluginCommandResult> => {
+        const lines: string[] = [`🌉 *CLI Bridge v${plugin.version} — Provider Status*\n`];
+
+        const checks = [
+          {
+            name: "Grok",
+            ctx: grokContext,
+            check: async () => {
+              if (!grokContext) return false;
+              const r = await verifySession(grokContext, () => {});
+              if (!r.valid) { grokContext = null; }
+              return r.valid;
+            },
+            models: "web-grok/grok-3, grok-3-fast, grok-3-mini",
+            loginCmd: "/grok-login",
+            expiry: () => { const e = loadGrokExpiry(); return e ? formatExpiryInfo(e) : null; },
+          },
+          {
+            name: "Claude",
+            ctx: claudeContext,
+            check: async () => {
+              if (!claudeContext) return false;
+              try {
+                const { getOrCreateClaudePage } = await import("./src/claude-browser.js");
+                const { page } = await getOrCreateClaudePage(claudeContext);
+                return page.locator(".ProseMirror").isVisible().catch(() => false);
+              } catch { claudeContext = null; return false; }
+            },
+            models: "web-claude/claude-sonnet, claude-opus, claude-haiku",
+            loginCmd: "/claude-login",
+            expiry: () => { const e = loadClaudeExpiry(); return e ? formatClaudeExpiry(e) : null; },
+          },
+          {
+            name: "Gemini",
+            ctx: geminiContext,
+            check: async () => {
+              if (!geminiContext) return false;
+              try {
+                const { getOrCreateGeminiPage } = await import("./src/gemini-browser.js");
+                const { page } = await getOrCreateGeminiPage(geminiContext);
+                return page.locator(".ql-editor").isVisible().catch(() => false);
+              } catch { geminiContext = null; return false; }
+            },
+            models: "web-gemini/gemini-2-5-pro, gemini-2-5-flash, gemini-3-pro, gemini-3-flash",
+            loginCmd: "/gemini-login",
+            expiry: () => { const e = loadGeminiExpiry(); return e ? formatGeminiExpiry(e) : null; },
+          },
+          {
+            name: "ChatGPT",
+            ctx: chatgptContext,
+            check: async () => {
+              if (!chatgptContext) return false;
+              try {
+                const { getOrCreateChatGPTPage } = await import("./src/chatgpt-browser.js");
+                const { page } = await getOrCreateChatGPTPage(chatgptContext);
+                return page.locator("#prompt-textarea").isVisible().catch(() => false);
+              } catch { chatgptContext = null; return false; }
+            },
+            models: "web-chatgpt/gpt-4o, gpt-o3, gpt-o4-mini, gpt-5",
+            loginCmd: "/chatgpt-login",
+            expiry: () => { const e = loadChatGPTExpiry(); return e ? formatChatGPTExpiry(e) : null; },
+          },
+        ];
+
+        for (const c of checks) {
+          const active = c.ctx !== null;
+          const ok = active ? await c.check() : false;
+          const expiry = c.expiry();
+          if (ok) {
+            lines.push(`✅ *${c.name}* — active`);
+            if (expiry) lines.push(`   🕐 ${expiry}`);
+            lines.push(`   Models: ${c.models}`);
+          } else {
+            lines.push(`❌ *${c.name}* — not connected (run \`${c.loginCmd}\`)`);
+          }
+          lines.push("");
+        }
+
+        lines.push(`🔌 Proxy: \`127.0.0.1:${port}\` | 22 models total`);
+        return { text: lines.join("\n") };
+      },
+    } satisfies OpenClawPluginCommandDefinition);
     // ─────────────────────────────────────────────────────────────────────────
 
     const allCommands = [
@@ -1476,6 +1545,7 @@ const plugin = {
       "/chatgpt-login",
       "/chatgpt-status",
       "/chatgpt-logout",
+      "/bridge-status",
     ];
     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": "1.0.0",
+  "version": "1.2.0",
   "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": "1.0.0",
+  "version": "1.2.0",
   "description": "Bridges gemini, claude, and codex CLI tools as OpenClaw model providers. Reads existing CLI auth without re-login.",
   "type": "module",
   "openclaw": {

package/src/chatgpt-browser.ts

@@ -35,6 +35,14 @@ const STABLE_CHECKS = 3;
 const STABLE_INTERVAL_MS = 500;
 const CHATGPT_HOME = "https://chatgpt.com";
 
+const MODEL_URLS: Record<string, string> = {
+  "gpt-4o":       "https://chatgpt.com/?model=gpt-4o",
+  "gpt-4o-mini":  "https://chatgpt.com/?model=gpt-4o-mini",
+  "o3":           "https://chatgpt.com/?model=o3",
+  "o4-mini":      "https://chatgpt.com/?model=o4-mini",
+  "gpt-5":        "https://chatgpt.com/?model=gpt-5",
+};
+
 const MODEL_MAP: Record<string, string> = {
   "gpt-4o":        "gpt-4o",
   "gpt-4o-mini":   "gpt-4o-mini",
@@ -173,18 +181,21 @@ export async function chatgptComplete(
   opts: ChatGPTBrowserOptions,
   log: (msg: string) => void
 ): Promise<ChatGPTBrowserResult> {
-  const { page, owned } = await getOrCreateChatGPTPage(context);
   const model = resolveModel(opts.model);
   const prompt = flattenMessages(opts.messages);
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const navUrl = MODEL_URLS[model] ?? CHATGPT_HOME;
 
   log(`chatgpt-browser: complete model=${model}`);
 
+  const page = await context.newPage();
   try {
+    await page.goto(navUrl, { waitUntil: "domcontentloaded", timeout: 15_000 });
+    await new Promise((r) => setTimeout(r, 2_000));
     const content = await sendAndWait(page, prompt, timeoutMs, log);
     return { content, model, finishReason: "stop" };
   } finally {
-    if (owned) await page.close().catch(() => {});
+    await page.close().catch(() => {});
   }
 }
 
@@ -194,60 +205,66 @@ export async function chatgptCompleteStream(
   onToken: (token: string) => void,
   log: (msg: string) => void
 ): Promise<ChatGPTBrowserResult> {
-  const { page, owned } = await getOrCreateChatGPTPage(context);
   const model = resolveModel(opts.model);
   const prompt = flattenMessages(opts.messages);
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const navUrl = MODEL_URLS[model] ?? CHATGPT_HOME;
 
   log(`chatgpt-browser: stream model=${model}`);
 
-  const countBefore = await countAssistantMessages(page);
-
-  await page.evaluate((msg: string) => {
-    const ed = document.querySelector("#prompt-textarea") as HTMLElement | null;
-    if (!ed) throw new Error("ChatGPT editor not found");
-    ed.focus();
-    document.execCommand("insertText", false, msg);
-  }, prompt);
-  await new Promise((r) => setTimeout(r, 300));
-  const sendBtn = page.locator('button[data-testid="send-button"]').first();
-  if (await sendBtn.isVisible().catch(() => false)) await sendBtn.click();
-  else 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 countAssistantMessages(page);
-    if (currentCount <= countBefore) continue;
-
-    const text = await getLastAssistantText(page);
-
-    if (text.length > emittedLength) {
-      onToken(text.slice(emittedLength));
-      emittedLength = text.length;
-    }
-
-    const streaming = await isStreaming(page);
-    if (streaming) { stableCount = 0; continue; }
+  const page = await context.newPage();
+  try {
+    await page.goto(navUrl, { waitUntil: "domcontentloaded", timeout: 15_000 });
+    await new Promise((r) => setTimeout(r, 2_000));
+
+    const countBefore = await countAssistantMessages(page);
+
+    await page.evaluate((msg: string) => {
+      const ed = document.querySelector("#prompt-textarea") as HTMLElement | null;
+      if (!ed) throw new Error("ChatGPT editor not found");
+      ed.focus();
+      document.execCommand("insertText", false, msg);
+    }, prompt);
+    await new Promise((r) => setTimeout(r, 300));
+    const sendBtn = page.locator('button[data-testid="send-button"]').first();
+    if (await sendBtn.isVisible().catch(() => false)) await sendBtn.click();
+    else 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 countAssistantMessages(page);
+      if (currentCount <= countBefore) continue;
+
+      const text = await getLastAssistantText(page);
+
+      if (text.length > emittedLength) {
+        onToken(text.slice(emittedLength));
+        emittedLength = text.length;
+      }
 
-    if (text && text === lastText) {
-      stableCount++;
-      if (stableCount >= STABLE_CHECKS) {
-        log(`chatgpt-browser: stream done (${text.length} chars)`);
-        if (owned) await page.close().catch(() => {});
-        return { content: text, model, finishReason: "stop" };
+      const streaming = await isStreaming(page);
+      if (streaming) { stableCount = 0; continue; }
+
+      if (text && text === lastText) {
+        stableCount++;
+        if (stableCount >= STABLE_CHECKS) {
+          log(`chatgpt-browser: stream done (${text.length} chars)`);
+          return { content: text, model, finishReason: "stop" };
+        }
+      } else {
+        stableCount = 0;
+        lastText = text;
       }
-    } else {
-      stableCount = 0;
-      lastText = text;
     }
-  }
 
-  if (owned) await page.close().catch(() => {});
-  throw new Error(`chatgpt.com stream timeout after ${timeoutMs}ms`);
+    throw new Error(`chatgpt.com stream timeout after ${timeoutMs}ms`);
+  } finally {
+    await page.close().catch(() => {});
+  }
 }

package/src/claude-browser.ts

@@ -160,18 +160,20 @@ export async function claudeComplete(
   opts: ClaudeBrowserOptions,
   log: (msg: string) => void
 ): Promise<ClaudeBrowserResult> {
-  const { page, owned } = await getOrCreateClaudePage(context);
   const model = resolveModel(opts.model);
   const prompt = flattenMessages(opts.messages);
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
 
   log(`claude-browser: complete model=${model}`);
 
+  const page = await context.newPage();
   try {
+    await page.goto(CLAUDE_HOME, { waitUntil: "domcontentloaded", timeout: 15_000 });
+    await new Promise((r) => setTimeout(r, 2_000));
     const content = await sendAndWait(page, prompt, timeoutMs, log);
     return { content, model, finishReason: "stop" };
   } finally {
-    if (owned) await page.close().catch(() => {});
+    await page.close().catch(() => {});
   }
 }
 
@@ -181,53 +183,60 @@ export async function claudeCompleteStream(
   onToken: (token: string) => void,
   log: (msg: string) => void
 ): Promise<ClaudeBrowserResult> {
-  const { page, owned } = await getOrCreateClaudePage(context);
   const model = resolveModel(opts.model);
   const prompt = flattenMessages(opts.messages);
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
 
   log(`claude-browser: stream model=${model}`);
 
-  const countBefore = await countAssistantMessages(page);
+  const page = await context.newPage();
+  try {
+    await page.goto(CLAUDE_HOME, { waitUntil: "domcontentloaded", timeout: 15_000 });
+    await new Promise((r) => setTimeout(r, 2_000));
 
-  await page.evaluate((msg: string) => {
-    const ed = document.querySelector(".ProseMirror") as HTMLElement | null;
-    if (!ed) throw new Error("Claude editor not found");
-    ed.focus();
-    document.execCommand("insertText", false, msg);
-  }, prompt);
-  await new Promise((r) => setTimeout(r, 300));
-  await page.keyboard.press("Enter");
+    const countBefore = await countAssistantMessages(page);
 
-  const deadline = Date.now() + timeoutMs;
-  let emittedLength = 0;
-  let lastText = "";
-  let stableCount = 0;
+    await page.evaluate((msg: string) => {
+      const ed = document.querySelector(".ProseMirror") as HTMLElement | null;
+      if (!ed) throw new Error("Claude editor not found");
+      ed.focus();
+      document.execCommand("insertText", false, msg);
+    }, prompt);
+    await new Promise((r) => setTimeout(r, 300));
+    await page.keyboard.press("Enter");
 
-  while (Date.now() < deadline) {
-    await new Promise((r) => setTimeout(r, STABLE_INTERVAL_MS));
+    const deadline = Date.now() + timeoutMs;
+    let emittedLength = 0;
+    let lastText = "";
+    let stableCount = 0;
 
-    const currentCount = await countAssistantMessages(page);
-    if (currentCount <= countBefore) continue;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, STABLE_INTERVAL_MS));
 
-    const text = await getLastAssistantText(page);
+      const currentCount = await countAssistantMessages(page);
+      if (currentCount <= countBefore) continue;
 
-    if (text.length > emittedLength) {
-      onToken(text.slice(emittedLength));
-      emittedLength = text.length;
-    }
+      const text = await getLastAssistantText(page);
 
-    if (text && text === lastText) {
-      stableCount++;
-      if (stableCount >= STABLE_CHECKS) {
-        log(`claude-browser: stream done (${text.length} chars)`);
-        return { content: text, model, finishReason: "stop" };
+      if (text.length > emittedLength) {
+        onToken(text.slice(emittedLength));
+        emittedLength = text.length;
+      }
+
+      if (text && text === lastText) {
+        stableCount++;
+        if (stableCount >= STABLE_CHECKS) {
+          log(`claude-browser: stream done (${text.length} chars)`);
+          return { content: text, model, finishReason: "stop" };
+        }
+      } else {
+        stableCount = 0;
+        lastText = text;
       }
-    } else {
-      stableCount = 0;
-      lastText = text;
     }
-  }
 
-  throw new Error(`claude.ai stream timeout after ${timeoutMs}ms`);
+    throw new Error(`claude.ai stream timeout after ${timeoutMs}ms`);
+  } finally {
+    await page.close().catch(() => {});
+  }
 }

package/src/gemini-browser.ts

@@ -167,18 +167,21 @@ export async function geminiComplete(
   opts: GeminiBrowserOptions,
   log: (msg: string) => void
 ): Promise<GeminiBrowserResult> {
-  const { page, owned } = await getOrCreateGeminiPage(context);
+  // TODO: Gemini model switching requires UI interaction (model picker dropdown), not yet implemented
   const model = resolveModel(opts.model);
   const prompt = flattenMessages(opts.messages);
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
 
   log(`gemini-browser: complete model=${model}`);
 
+  const page = await context.newPage();
   try {
+    await page.goto(GEMINI_HOME, { waitUntil: "domcontentloaded", timeout: 15_000 });
+    await new Promise((r) => setTimeout(r, 2_000));
     const content = await sendAndWait(page, prompt, timeoutMs, log);
     return { content, model, finishReason: "stop" };
   } finally {
-    if (owned) await page.close().catch(() => {});
+    await page.close().catch(() => {});
   }
 }
 
@@ -188,55 +191,60 @@ export async function geminiCompleteStream(
   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 page = await context.newPage();
+  try {
+    await page.goto(GEMINI_HOME, { waitUntil: "domcontentloaded", timeout: 15_000 });
+    await new Promise((r) => setTimeout(r, 2_000));
 
-  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 countBefore = await countResponses(page);
 
-  const deadline = Date.now() + timeoutMs;
-  let emittedLength = 0;
-  let lastText = "";
-  let stableCount = 0;
+    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");
 
-  while (Date.now() < deadline) {
-    await new Promise((r) => setTimeout(r, STABLE_INTERVAL_MS));
+    const deadline = Date.now() + timeoutMs;
+    let emittedLength = 0;
+    let lastText = "";
+    let stableCount = 0;
 
-    const currentCount = await countResponses(page);
-    if (currentCount <= countBefore) continue;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, STABLE_INTERVAL_MS));
 
-    const text = await getLastResponseText(page);
+      const currentCount = await countResponses(page);
+      if (currentCount <= countBefore) continue;
 
-    if (text.length > emittedLength) {
-      onToken(text.slice(emittedLength));
-      emittedLength = text.length;
-    }
+      const text = await getLastResponseText(page);
 
-    const streaming = await isStreaming(page);
-    if (streaming) { stableCount = 0; continue; }
+      if (text.length > emittedLength) {
+        onToken(text.slice(emittedLength));
+        emittedLength = text.length;
+      }
 
-    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" };
+      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)`);
+          return { content: text, model, finishReason: "stop" };
+        }
+      } else {
+        stableCount = 0;
+        lastText = text;
       }
-    } else {
-      stableCount = 0;
-      lastText = text;
     }
-  }
 
-  if (owned) await page.close().catch(() => {});
-  throw new Error(`gemini.google.com stream timeout after ${timeoutMs}ms`);
+    throw new Error(`gemini.google.com stream timeout after ${timeoutMs}ms`);
+  } finally {
+    await page.close().catch(() => {});
+  }
 }

package/src/grok-client.ts

@@ -160,18 +160,20 @@ export async function grokComplete(
   opts: GrokCompleteOptions,
   log: (msg: string) => void
 ): Promise<GrokCompleteResult> {
-  const { page, owned } = await getOrCreateGrokPage(context);
   const model = resolveModel(opts.model);
   const prompt = flattenMessages(opts.messages);
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
 
   log(`grok-client: complete model=${model}`);
 
+  const page = await context.newPage();
   try {
+    await page.goto("https://grok.com", { waitUntil: "domcontentloaded", timeout: 15_000 });
+    await new Promise((r) => setTimeout(r, 2_000));
     const content = await sendAndWait(page, prompt, timeoutMs, log);
     return { content, model, finishReason: "stop" };
   } finally {
-    if (owned) await page.close().catch(() => {});
+    await page.close().catch(() => {});
   }
 }
 
@@ -184,66 +186,73 @@ export async function grokCompleteStream(
   onToken: (token: string) => void,
   log: (msg: string) => void
 ): Promise<GrokCompleteResult> {
-  const { page, owned } = await getOrCreateGrokPage(context);
   const model = resolveModel(opts.model);
   const prompt = flattenMessages(opts.messages);
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
 
   log(`grok-client: stream model=${model}`);
 
-  const countBefore = await page.evaluate(
-    () => document.querySelectorAll(".message-bubble").length
-  );
-
-  // Send message
-  await page.evaluate((msg: string) => {
-    const ed =
-      document.querySelector(".ProseMirror") ||
-      document.querySelector('[contenteditable="true"]');
-    if (!ed) throw new Error("Grok editor not found");
-    (ed as HTMLElement).focus();
-    document.execCommand("insertText", false, msg);
-  }, prompt);
-  await new Promise((r) => setTimeout(r, 300));
-  await page.keyboard.press("Enter");
-
-  log(`grok-client: message sent, streaming…`);
-
-  // Stream: poll DOM, emit new chars as tokens
-  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 page = await context.newPage();
+  try {
+    await page.goto("https://grok.com", { waitUntil: "domcontentloaded", timeout: 15_000 });
+    await new Promise((r) => setTimeout(r, 2_000));
 
-    const text = await page.evaluate(
-      (before: number) => {
-        const bubbles = [...document.querySelectorAll(".message-bubble")];
-        if (bubbles.length <= before) return "";
-        return bubbles[bubbles.length - 1].textContent?.trim() ?? "";
-      },
-      countBefore
+    const countBefore = await page.evaluate(
+      () => document.querySelectorAll(".message-bubble").length
     );
 
-    if (text && text.length > emittedLength) {
-      const newChars = text.slice(emittedLength);
-      onToken(newChars);
-      emittedLength = text.length;
-    }
+    // Send message
+    await page.evaluate((msg: string) => {
+      const ed =
+        document.querySelector(".ProseMirror") ||
+        document.querySelector('[contenteditable="true"]');
+      if (!ed) throw new Error("Grok editor not found");
+      (ed as HTMLElement).focus();
+      document.execCommand("insertText", false, msg);
+    }, prompt);
+    await new Promise((r) => setTimeout(r, 300));
+    await page.keyboard.press("Enter");
+
+    log(`grok-client: message sent, streaming…`);
+
+    // Stream: poll DOM, emit new chars as tokens
+    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 text = await page.evaluate(
+        (before: number) => {
+          const bubbles = [...document.querySelectorAll(".message-bubble")];
+          if (bubbles.length <= before) return "";
+          return bubbles[bubbles.length - 1].textContent?.trim() ?? "";
+        },
+        countBefore
+      );
+
+      if (text && text.length > emittedLength) {
+        const newChars = text.slice(emittedLength);
+        onToken(newChars);
+        emittedLength = text.length;
+      }
 
-    if (text && text === lastText) {
-      stableCount++;
-      if (stableCount >= STABLE_CHECKS) {
-        log(`grok-client: stream done (${text.length} chars)`);
-        return { content: text, model, finishReason: "stop" };
+      if (text && text === lastText) {
+        stableCount++;
+        if (stableCount >= STABLE_CHECKS) {
+          log(`grok-client: stream done (${text.length} chars)`);
+          return { content: text, model, finishReason: "stop" };
+        }
+      } else {
+        stableCount = 0;
+        lastText = text;
       }
-    } else {
-      stableCount = 0;
-      lastText = text;
     }
-  }
 
-  throw new Error(`grok.com stream timeout after ${timeoutMs}ms`);
+    throw new Error(`grok.com stream timeout after ${timeoutMs}ms`);
+  } finally {
+    await page.close().catch(() => {});
+  }
 }

package/src/proxy-server.ts

@@ -64,42 +64,14 @@ export interface ProxyServerOptions {
 
 /** Available CLI bridge models for GET /v1/models */
 export const CLI_MODELS = [
-  {
-    id: "cli-gemini/gemini-2.5-pro",
-    name: "Gemini 2.5 Pro (CLI)",
-    contextWindow: 1_000_000,
-    maxTokens: 8192,
-  },
-  {
-    id: "cli-gemini/gemini-2.5-flash",
-    name: "Gemini 2.5 Flash (CLI)",
-    contextWindow: 1_000_000,
-    maxTokens: 8192,
-  },
-  {
-    id: "cli-gemini/gemini-3-pro",
-    name: "Gemini 3 Pro (CLI)",
-    contextWindow: 1_000_000,
-    maxTokens: 8192,
-  },
-  {
-    id: "cli-claude/claude-opus-4-6",
-    name: "Claude Opus 4.6 (CLI)",
-    contextWindow: 200_000,
-    maxTokens: 8192,
-  },
-  {
-    id: "cli-claude/claude-sonnet-4-6",
-    name: "Claude Sonnet 4.6 (CLI)",
-    contextWindow: 200_000,
-    maxTokens: 8192,
-  },
-  {
-    id: "cli-claude/claude-haiku-4-5",
-    name: "Claude Haiku 4.5 (CLI)",
-    contextWindow: 200_000,
-    maxTokens: 8192,
-  },
+  // ── Claude Code CLI ───────────────────────────────────────────────────────
+  { id: "cli-claude/claude-sonnet-4-6", name: "Claude Sonnet 4.6 (CLI)",  contextWindow: 200_000,   maxTokens: 8_192 },
+  { id: "cli-claude/claude-opus-4-6",   name: "Claude Opus 4.6 (CLI)",    contextWindow: 200_000,   maxTokens: 8_192 },
+  { id: "cli-claude/claude-haiku-4-5",  name: "Claude Haiku 4.5 (CLI)",   contextWindow: 200_000,   maxTokens: 8_192 },
+  // ── Gemini CLI ────────────────────────────────────────────────────────────
+  { id: "cli-gemini/gemini-2.5-pro",      name: "Gemini 2.5 Pro (CLI)",   contextWindow: 1_000_000, maxTokens: 8_192 },
+  { id: "cli-gemini/gemini-2.5-flash",    name: "Gemini 2.5 Flash (CLI)", contextWindow: 1_000_000, maxTokens: 8_192 },
+  { id: "cli-gemini/gemini-3-pro-preview",name: "Gemini 3 Pro (CLI)",     contextWindow: 1_000_000, maxTokens: 8_192 },
   // Grok web-session models (requires /grok-login)
   { id: "web-grok/grok-3",           name: "Grok 3 (web session)",           contextWindow: 131_072, maxTokens: 131_072 },
   { id: "web-grok/grok-3-fast",      name: "Grok 3 Fast (web session)",      contextWindow: 131_072, maxTokens: 131_072 },