@elvatis_com/openclaw-cli-bridge-elvatis 1.1.0 → 1.2.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.2.0`
 
 ---
 
@@ -287,6 +287,11 @@ 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

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.2.0

package/index.ts

@@ -613,7 +613,7 @@ function proxyTestRequest(
 const plugin = {
   id: "openclaw-cli-bridge-elvatis",
   name: "OpenClaw CLI Bridge",
-  version: "1.1.0",
+  version: "1.2.0",
   description:
     "Phase 1: openai-codex auth bridge. " +
     "Phase 2: HTTP proxy for gemini/claude CLIs. " +

package/openclaw.plugin.json

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