@elvatis_com/openclaw-cli-bridge-elvatis 1.1.0 → 1.3.0

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.1.0`
+**Current version:** `1.3.0`
 
 ---
 
@@ -287,6 +287,16 @@ npm test            # vitest run (45 tests)
 
 ## Changelog
 
+### v1.3.0
+- **fix:** Browser persistence after gateway restart — each provider launches its own persistent Chromium if OpenClaw browser is unavailable
+- **feat:** `ensureAllProviderContexts()` — unified startup connect for all 4 providers
+- **feat:** Lazy-connect fallback to persistent context when CDP unavailable
+
+### 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

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.1.0
+**Version:** 1.3.0

package/index.ts

@@ -322,6 +322,101 @@ async function cleanupBrowsers(log: (msg: string) => void): Promise<void> {
   log("[cli-bridge] browser resources cleaned up");
 }
 
+/**
+ * Ensure all browser provider contexts are connected.
+ * 1. Try the shared OpenClaw browser (CDP 18800)
+ * 2. Fallback: launch a persistent headless Chromium per provider (saved profile with cookies)
+ */
+async function ensureAllProviderContexts(log: (msg: string) => void): Promise<void> {
+  const { chromium } = await import("playwright");
+
+  // Try CDP first (OpenClaw browser)
+  let sharedCtx: BrowserContext | null = null;
+  try {
+    const b = await chromium.connectOverCDP("http://127.0.0.1:18800", { timeout: 2000 });
+    sharedCtx = b.contexts()[0] ?? null;
+    if (sharedCtx) log("[cli-bridge] using OpenClaw browser for all providers");
+  } catch { /* not available */ }
+
+  // For each provider: if no context yet, try shared ctx or launch own persistent context
+  const providerConfigs = [
+    {
+      name: "claude",
+      profileDir: join(homedir(), ".openclaw", "claude-profile"),
+      getCtx: () => claudeContext,
+      setCtx: (c: BrowserContext) => { claudeContext = c; },
+      homeUrl: "https://claude.ai/new",
+      verifySelector: ".ProseMirror",
+    },
+    {
+      name: "gemini",
+      profileDir: join(homedir(), ".openclaw", "gemini-profile"),
+      getCtx: () => geminiContext,
+      setCtx: (c: BrowserContext) => { geminiContext = c; },
+      homeUrl: "https://gemini.google.com/app",
+      verifySelector: ".ql-editor",
+    },
+    {
+      name: "chatgpt",
+      profileDir: join(homedir(), ".openclaw", "chatgpt-profile"),
+      getCtx: () => chatgptContext,
+      setCtx: (c: BrowserContext) => { chatgptContext = c; },
+      homeUrl: "https://chatgpt.com",
+      verifySelector: "#prompt-textarea",
+    },
+  ];
+
+  for (const cfg of providerConfigs) {
+    if (cfg.getCtx()) continue; // already connected
+
+    let ctx: BrowserContext | null = null;
+
+    // 1. Try shared OpenClaw browser context
+    if (sharedCtx) {
+      try {
+        const pages = sharedCtx.pages();
+        const existing = pages.find(p => p.url().includes(new URL(cfg.homeUrl).hostname));
+        const page = existing ?? await sharedCtx.newPage();
+        if (!existing) {
+          await page.goto(cfg.homeUrl, { waitUntil: "domcontentloaded", timeout: 10_000 });
+          await new Promise(r => setTimeout(r, 2000));
+        }
+        const visible = await page.locator(cfg.verifySelector).isVisible().catch(() => false);
+        if (visible) {
+          ctx = sharedCtx;
+          log(`[cli-bridge:${cfg.name}] connected via OpenClaw browser ✅`);
+        }
+      } catch { /* fall through */ }
+    }
+
+    // 2. Launch own persistent context (has saved cookies)
+    if (!ctx) {
+      try {
+        mkdirSync(cfg.profileDir, { recursive: true });
+        const pCtx = await chromium.launchPersistentContext(cfg.profileDir, {
+          headless: true,
+          args: ["--no-sandbox", "--disable-setuid-sandbox"],
+        });
+        const page = await pCtx.newPage();
+        await page.goto(cfg.homeUrl, { waitUntil: "domcontentloaded", timeout: 15_000 });
+        await new Promise(r => setTimeout(r, 3000));
+        const visible = await page.locator(cfg.verifySelector).isVisible().catch(() => false);
+        if (visible) {
+          ctx = pCtx;
+          log(`[cli-bridge:${cfg.name}] launched persistent context ✅`);
+        } else {
+          await pCtx.close().catch(() => {});
+          log(`[cli-bridge:${cfg.name}] persistent context: editor not visible (not logged in?)`);
+        }
+      } catch (err) {
+        log(`[cli-bridge:${cfg.name}] could not launch browser: ${(err as Error).message}`);
+      }
+    }
+
+    if (ctx) cfg.setCtx(ctx);
+  }
+}
+
 async function tryRestoreGrokSession(
   _sessionPath: string,
   log: (msg: string) => void
@@ -613,7 +708,7 @@ function proxyTestRequest(
 const plugin = {
   id: "openclaw-cli-bridge-elvatis",
   name: "OpenClaw CLI Bridge",
-  version: "1.1.0",
+  version: "1.3.0",
   description:
     "Phase 1: openai-codex auth bridge. " +
     "Phase 2: HTTP proxy for gemini/claude CLIs. " +
@@ -634,49 +729,8 @@ const plugin = {
 
     // ── 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 */ }
-      }
+      await new Promise(r => setTimeout(r, 3000)); // wait for proxy to start
+      await ensureAllProviderContexts((msg) => api.logger.info(msg));
     })();
 
     // ── Phase 1: openai-codex auth bridge ─────────────────────────────────────
@@ -792,7 +846,9 @@ const plugin = {
                 const editor = await page.locator(".ProseMirror").isVisible().catch(() => false);
                 if (editor) { claudeContext = ctx; return ctx; }
               }
-              return null;
+              // Fallback: try persistent context
+              await ensureAllProviderContexts((msg) => api.logger.info(msg));
+              return claudeContext;
             },
             getGeminiContext: () => geminiContext,
             connectGeminiContext: async () => {
@@ -803,7 +859,9 @@ const plugin = {
                 const editor = await page.locator(".ql-editor").isVisible().catch(() => false);
                 if (editor) { geminiContext = ctx; return ctx; }
               }
-              return null;
+              // Fallback: try persistent context
+              await ensureAllProviderContexts((msg) => api.logger.info(msg));
+              return geminiContext;
             },
             getChatGPTContext: () => chatgptContext,
             connectChatGPTContext: async () => {
@@ -814,7 +872,9 @@ const plugin = {
                 const editor = await page.locator("#prompt-textarea").isVisible().catch(() => false);
                 if (editor) { chatgptContext = ctx; return ctx; }
               }
-              return null;
+              // Fallback: try persistent context
+              await ensureAllProviderContexts((msg) => api.logger.info(msg));
+              return chatgptContext;
             },
           });
           proxyServer = server;
@@ -857,7 +917,9 @@ const plugin = {
                     const editor = await page.locator(".ProseMirror").isVisible().catch(() => false);
                     if (editor) { claudeContext = ctx; return ctx; }
                   }
-                  return null;
+                  // Fallback: try persistent context
+                  await ensureAllProviderContexts((msg) => api.logger.info(msg));
+                  return claudeContext;
                 },
                 getGeminiContext: () => geminiContext,
                 connectGeminiContext: async () => {
@@ -868,7 +930,9 @@ const plugin = {
                     const editor = await page.locator(".ql-editor").isVisible().catch(() => false);
                     if (editor) { geminiContext = ctx; return ctx; }
                   }
-                  return null;
+                  // Fallback: try persistent context
+                  await ensureAllProviderContexts((msg) => api.logger.info(msg));
+                  return geminiContext;
                 },
                 getChatGPTContext: () => chatgptContext,
                 connectChatGPTContext: async () => {
@@ -879,7 +943,9 @@ const plugin = {
                     const editor = await page.locator("#prompt-textarea").isVisible().catch(() => false);
                     if (editor) { chatgptContext = ctx; return ctx; }
                   }
-                  return null;
+                  // Fallback: try persistent context
+                  await ensureAllProviderContexts((msg) => api.logger.info(msg));
+                  return chatgptContext;
                 },
               });
               proxyServer = server;

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-cli-bridge-elvatis",
   "name": "OpenClaw CLI Bridge",
-  "version": "1.1.0",
+  "version": "1.3.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.1.0",
+  "version": "1.3.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(() => {});
+  }
 }