@elvatis_com/openclaw-cli-bridge-elvatis 0.2.30 → 1.0.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:** `0.2.30`
+**Current version:** `1.0.0`
 
 ---
 
@@ -287,6 +287,19 @@ npm test            # vitest run (45 tests)
 
 ## Changelog
 
+## 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
+- **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
+- **feat:** All 4 providers headless: Grok ✅ Claude ✅ Gemini ✅ ChatGPT ✅
+- **test:** 96/96 tests green (8 test files)
+- **fix:** Singleton CDP connection, cleanupBrowsers() on plugin stop
+
 ### v0.2.30
 - **feat:** `gemini-browser.ts` — gemini.google.com DOM-automation (Quill editor + message-content polling)
 - **feat:** `web-gemini/*` models in proxy (gemini-2-5-pro, gemini-2-5-flash, gemini-3-pro, gemini-3-flash)

package/SKILL.md

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

package/index.ts

@@ -121,6 +121,32 @@ async function scanGeminiCookieExpiry(ctx: BrowserContext): Promise<GeminiExpiry
 }
 // ─────────────────────────────────────────────────────────────────────────────
 
+// ── ChatGPT web-session state ─────────────────────────────────────────────────
+let chatgptContext: BrowserContext | null = null;
+const CHATGPT_EXPIRY_FILE = join(homedir(), ".openclaw", "chatgpt-cookie-expiry.json");
+interface ChatGPTExpiryInfo { expiresAt: number; loginAt: number; cookieName: string; }
+function saveChatGPTExpiry(i: ChatGPTExpiryInfo) { try { writeFileSync(CHATGPT_EXPIRY_FILE, JSON.stringify(i, null, 2)); } catch { /* ignore */ } }
+function loadChatGPTExpiry(): ChatGPTExpiryInfo | null { try { return JSON.parse(readFileSync(CHATGPT_EXPIRY_FILE, "utf-8")); } catch { return null; } }
+function formatChatGPTExpiry(i: ChatGPTExpiryInfo): string {
+  const d = Math.floor((i.expiresAt - Date.now()) / 86_400_000);
+  const dt = new Date(i.expiresAt).toISOString().substring(0, 10);
+  if (d < 0) return `⚠️ EXPIRED (${dt}) — run /chatgpt-login`;
+  if (d <= 7) return `🚨 expires in ${d}d (${dt}) — run /chatgpt-login NOW`;
+  if (d <= 14) return `⚠️ expires in ${d}d (${dt}) — run /chatgpt-login soon`;
+  return `✅ valid for ${d} more days (expires ${dt})`;
+}
+async function scanChatGPTCookieExpiry(ctx: BrowserContext): Promise<ChatGPTExpiryInfo | null> {
+  try {
+    const cookies = await ctx.cookies(["https://chatgpt.com", "https://openai.com"]);
+    const auth = cookies.filter(c => ["__Secure-next-auth.session-token", "cf_clearance", "__cf_bm"].includes(c.name) && c.expires && c.expires > 0);
+    if (!auth.length) return null;
+    auth.sort((a, b) => (a.expires ?? 0) - (b.expires ?? 0));
+    const earliest = auth[0];
+    return { expiresAt: (earliest.expires ?? 0) * 1000, loginAt: Date.now(), cookieName: earliest.name };
+  } catch { return null; }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+
 // ── Claude web-session state ──────────────────────────────────────────────────
 let claudeContext: BrowserContext | null = null;
 const CLAUDE_EXPIRY_FILE = join(homedir(), ".openclaw", "claude-cookie-expiry.json");
@@ -293,6 +319,7 @@ async function cleanupBrowsers(log: (msg: string) => void): Promise<void> {
   }
   claudeContext = null;
   geminiContext = null;
+  chatgptContext = null;
   log("[cli-bridge] browser resources cleaned up");
 }
 
@@ -651,7 +678,7 @@ function proxyTestRequest(
 const plugin = {
   id: "openclaw-cli-bridge-elvatis",
   name: "OpenClaw CLI Bridge",
-  version: "0.2.30",
+  version: "1.0.0",
   description:
     "Phase 1: openai-codex auth bridge. " +
     "Phase 2: HTTP proxy for gemini/claude CLIs. " +
@@ -796,6 +823,17 @@ const plugin = {
               }
               return null;
             },
+            getChatGPTContext: () => chatgptContext,
+            connectChatGPTContext: async () => {
+              const ctx = await connectToOpenClawBrowser((msg) => api.logger.info(msg));
+              if (ctx) {
+                const { getOrCreateChatGPTPage } = await import("./src/chatgpt-browser.js");
+                const { page } = await getOrCreateChatGPTPage(ctx);
+                const editor = await page.locator("#prompt-textarea").isVisible().catch(() => false);
+                if (editor) { chatgptContext = ctx; return ctx; }
+              }
+              return null;
+            },
           });
           proxyServer = server;
           api.logger.info(
@@ -850,6 +888,17 @@ const plugin = {
                   }
                   return null;
                 },
+                getChatGPTContext: () => chatgptContext,
+                connectChatGPTContext: async () => {
+                  const ctx = await connectToOpenClawBrowser((msg) => api.logger.info(msg));
+                  if (ctx) {
+                    const { getOrCreateChatGPTPage } = await import("./src/chatgpt-browser.js");
+                    const { page } = await getOrCreateChatGPTPage(ctx);
+                    const editor = await page.locator("#prompt-textarea").isVisible().catch(() => false);
+                    if (editor) { chatgptContext = ctx; return ctx; }
+                  }
+                  return null;
+                },
               });
               proxyServer = server;
               api.logger.info(`[cli-bridge] proxy ready on :${port} (retry)`);
@@ -1346,6 +1395,68 @@ const plugin = {
         return { text: "✅ Disconnected from gemini.google.com. Run `/gemini-login` to reconnect." };
       },
     } satisfies OpenClawPluginCommandDefinition);
+
+    // ── ChatGPT web-session commands ──────────────────────────────────────────
+    api.registerCommand({
+      name: "chatgpt-login",
+      description: "Authenticate chatgpt.com: imports session from OpenClaw browser",
+      handler: async (): Promise<PluginCommandResult> => {
+        if (chatgptContext) {
+          const { getOrCreateChatGPTPage } = await import("./src/chatgpt-browser.js");
+          try {
+            const { page } = await getOrCreateChatGPTPage(chatgptContext);
+            if (await page.locator("#prompt-textarea").isVisible().catch(() => false))
+              return { text: "✅ Already connected to chatgpt.com. Use `/chatgpt-logout` first to reset." };
+          } catch { /* fall through */ }
+          chatgptContext = null;
+        }
+        api.logger.info("[cli-bridge:chatgpt] /chatgpt-login: connecting to OpenClaw browser…");
+        const ctx = await connectToOpenClawBrowser((msg) => api.logger.info(msg));
+        if (!ctx) return { text: "❌ Could not connect to OpenClaw browser.\nMake sure chatgpt.com is open in your browser." };
+
+        const { getOrCreateChatGPTPage } = await import("./src/chatgpt-browser.js");
+        let page;
+        try { ({ page } = await getOrCreateChatGPTPage(ctx)); }
+        catch (err) { return { text: `❌ Failed to open chatgpt.com: ${(err as Error).message}` }; }
+
+        if (!await page.locator("#prompt-textarea").isVisible().catch(() => false))
+          return { text: "❌ ChatGPT editor not visible — are you logged in?\nOpen chatgpt.com in your browser and try again." };
+
+        chatgptContext = ctx;
+        const expiry = await scanChatGPTCookieExpiry(ctx);
+        if (expiry) { saveChatGPTExpiry(expiry); api.logger.info(`[cli-bridge:chatgpt] cookie expiry: ${new Date(expiry.expiresAt).toISOString()}`); }
+        const expiryLine = expiry ? `\n\n🕐 Cookie expiry: ${formatChatGPTExpiry(expiry)}` : "";
+        return { text: `✅ ChatGPT session ready!\n\nModels available:\n• \`vllm/web-chatgpt/gpt-4o\`\n• \`vllm/web-chatgpt/gpt-4o-mini\`\n• \`vllm/web-chatgpt/gpt-o3\`\n• \`vllm/web-chatgpt/gpt-o4-mini\`\n• \`vllm/web-chatgpt/gpt-5\`${expiryLine}` };
+      },
+    } satisfies OpenClawPluginCommandDefinition);
+
+    api.registerCommand({
+      name: "chatgpt-status",
+      description: "Check chatgpt.com session status",
+      handler: async (): Promise<PluginCommandResult> => {
+        if (!chatgptContext) return { text: "❌ No active chatgpt.com session\nRun `/chatgpt-login` to authenticate." };
+        const { getOrCreateChatGPTPage } = await import("./src/chatgpt-browser.js");
+        try {
+          const { page } = await getOrCreateChatGPTPage(chatgptContext);
+          if (await page.locator("#prompt-textarea").isVisible().catch(() => false)) {
+            const expiry = loadChatGPTExpiry();
+            const expiryLine = expiry ? `\n🕐 ${formatChatGPTExpiry(expiry)}` : "";
+            return { text: `✅ chatgpt.com session active\nProxy: \`127.0.0.1:${port}\`\nModels: web-chatgpt/gpt-4o, gpt-4o-mini, gpt-o3, gpt-o4-mini, gpt-5${expiryLine}` };
+          }
+        } catch { /* fall through */ }
+        chatgptContext = null;
+        return { text: "❌ Session lost — run `/chatgpt-login` to re-authenticate." };
+      },
+    } satisfies OpenClawPluginCommandDefinition);
+
+    api.registerCommand({
+      name: "chatgpt-logout",
+      description: "Disconnect from chatgpt.com session",
+      handler: async (): Promise<PluginCommandResult> => {
+        chatgptContext = null;
+        return { text: "✅ Disconnected from chatgpt.com. Run `/chatgpt-login` to reconnect." };
+      },
+    } satisfies OpenClawPluginCommandDefinition);
     // ─────────────────────────────────────────────────────────────────────────
 
     const allCommands = [
@@ -1362,6 +1473,9 @@ const plugin = {
       "/gemini-login",
       "/gemini-status",
       "/gemini-logout",
+      "/chatgpt-login",
+      "/chatgpt-status",
+      "/chatgpt-logout",
     ];
     api.logger.info(`[cli-bridge] registered ${allCommands.length} commands: ${allCommands.join(", ")}`);
   },

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-cli-bridge-elvatis",
   "name": "OpenClaw CLI Bridge",
-  "version": "0.2.30",
+  "version": "1.0.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": "0.2.30",
+  "version": "1.0.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

@@ -0,0 +1,253 @@
+/**
+ * chatgpt-browser.ts
+ *
+ * ChatGPT web automation via Playwright DOM-polling.
+ * Strategy identical to claude-browser.ts / grok-client.ts.
+ *
+ * DOM structure (confirmed 2026-03-11):
+ *   Editor:   #prompt-textarea (ProseMirror — use execCommand)
+ *   Send btn: button[data-testid="send-button"]
+ *   Response: [data-message-author-role="assistant"] (last element)
+ *   Streaming indicator: button[data-testid="stop-button"]
+ */
+
+import type { BrowserContext, Page } from "playwright";
+
+export interface ChatMessage {
+  role: "system" | "user" | "assistant";
+  content: string;
+}
+
+export interface ChatGPTBrowserOptions {
+  messages: ChatMessage[];
+  model?: string;
+  timeoutMs?: number;
+}
+
+export interface ChatGPTBrowserResult {
+  content: string;
+  model: string;
+  finishReason: string;
+}
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+const STABLE_CHECKS = 3;
+const STABLE_INTERVAL_MS = 500;
+const CHATGPT_HOME = "https://chatgpt.com";
+
+const MODEL_MAP: Record<string, string> = {
+  "gpt-4o":        "gpt-4o",
+  "gpt-4o-mini":   "gpt-4o-mini",
+  "gpt-o3":        "o3",
+  "gpt-o4-mini":   "o4-mini",
+  "gpt-4-1":       "gpt-4.1",
+  "gpt-5":         "gpt-5",
+};
+
+function resolveModel(m?: string): string {
+  const clean = (m ?? "gpt-4o").replace("web-chatgpt/", "");
+  return MODEL_MAP[clean] ?? clean;
+}
+
+function flattenMessages(messages: ChatMessage[]): string {
+  if (messages.length === 1) return messages[0].content;
+  return messages
+    .map((m) => {
+      if (m.role === "system") return `[System]: ${m.content}`;
+      if (m.role === "assistant") return `[Assistant]: ${m.content}`;
+      return m.content;
+    })
+    .join("\n\n");
+}
+
+/**
+ * Get or create a chatgpt.com page in the given context.
+ */
+export async function getOrCreateChatGPTPage(
+  context: BrowserContext
+): Promise<{ page: Page; owned: boolean }> {
+  const existing = context.pages().filter((p) => p.url().startsWith("https://chatgpt.com"));
+  if (existing.length > 0) return { page: existing[0], owned: false };
+  const page = await context.newPage();
+  await page.goto(CHATGPT_HOME, { waitUntil: "domcontentloaded", timeout: 15_000 });
+  await new Promise((r) => setTimeout(r, 2_000));
+  return { page, owned: true };
+}
+
+/**
+ * Count assistant messages on the page.
+ */
+async function countAssistantMessages(page: Page): Promise<number> {
+  return page.evaluate(() =>
+    document.querySelectorAll('[data-message-author-role="assistant"]').length
+  );
+}
+
+/**
+ * Get the text of the last assistant message.
+ */
+async function getLastAssistantText(page: Page): Promise<string> {
+  return page.evaluate(() => {
+    const els = [...document.querySelectorAll('[data-message-author-role="assistant"]')];
+    return els[els.length - 1]?.textContent?.trim() ?? "";
+  });
+}
+
+/**
+ * Check if ChatGPT is still generating (stop button visible).
+ */
+async function isStreaming(page: Page): Promise<boolean> {
+  return page.evaluate(() =>
+    !!document.querySelector('button[data-testid="stop-button"]')
+  );
+}
+
+/**
+ * Send a message and wait for stable response.
+ */
+async function sendAndWait(
+  page: Page,
+  message: string,
+  timeoutMs: number,
+  log: (msg: string) => void
+): Promise<string> {
+  const countBefore = await countAssistantMessages(page);
+
+  // Type into ProseMirror via execCommand
+  await page.evaluate((msg: string) => {
+    const ed = document.querySelector("#prompt-textarea") as HTMLElement | null;
+    if (!ed) throw new Error("ChatGPT editor (#prompt-textarea) not found");
+    ed.focus();
+    document.execCommand("insertText", false, msg);
+  }, message);
+
+  await new Promise((r) => setTimeout(r, 300));
+
+  // Click send button (preferred) or Enter
+  const sendBtn = page.locator('button[data-testid="send-button"]').first();
+  const hasSendBtn = await sendBtn.isVisible().catch(() => false);
+  if (hasSendBtn) {
+    await sendBtn.click();
+  } else {
+    await page.keyboard.press("Enter");
+  }
+
+  log(`chatgpt-browser: message sent (${message.length} chars), waiting…`);
+
+  const deadline = Date.now() + timeoutMs;
+  let lastText = "";
+  let stableCount = 0;
+
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, STABLE_INTERVAL_MS));
+
+    const currentCount = await countAssistantMessages(page);
+    if (currentCount <= countBefore) continue;
+
+    // Still generating?
+    const streaming = await isStreaming(page);
+    if (streaming) { stableCount = 0; continue; }
+
+    const text = await getLastAssistantText(page);
+    if (!text) continue;
+
+    if (text === lastText) {
+      stableCount++;
+      if (stableCount >= STABLE_CHECKS) {
+        log(`chatgpt-browser: response stable (${text.length} chars)`);
+        return text;
+      }
+    } else {
+      stableCount = 0;
+      lastText = text;
+    }
+  }
+
+  throw new Error(`chatgpt.com response timeout after ${timeoutMs}ms`);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+export async function chatgptComplete(
+  context: BrowserContext,
+  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;
+
+  log(`chatgpt-browser: complete model=${model}`);
+
+  try {
+    const content = await sendAndWait(page, prompt, timeoutMs, log);
+    return { content, model, finishReason: "stop" };
+  } finally {
+    if (owned) await page.close().catch(() => {});
+  }
+}
+
+export async function chatgptCompleteStream(
+  context: BrowserContext,
+  opts: ChatGPTBrowserOptions,
+  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;
+
+  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; }
+
+    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" };
+      }
+    } else {
+      stableCount = 0;
+      lastText = text;
+    }
+  }
+
+  if (owned) await page.close().catch(() => {});
+  throw new Error(`chatgpt.com stream timeout after ${timeoutMs}ms`);
+}

package/src/proxy-server.ts

@@ -15,6 +15,7 @@ import { scheduleTokenRefresh, setAuthLogger, stopTokenRefresh } from "./claude-
 import { grokComplete, grokCompleteStream, type ChatMessage as GrokChatMessage } from "./grok-client.js";
 import { claudeComplete, claudeCompleteStream, type ChatMessage as ClaudeBrowserChatMessage } from "./claude-browser.js";
 import { geminiComplete, geminiCompleteStream, type ChatMessage as GeminiBrowserChatMessage } from "./gemini-browser.js";
+import { chatgptComplete, chatgptCompleteStream, type ChatMessage as ChatGPTBrowserChatMessage } from "./chatgpt-browser.js";
 import type { BrowserContext } from "playwright";
 
 export type GrokCompleteOptions = Parameters<typeof grokComplete>[1];
@@ -51,6 +52,14 @@ export interface ProxyServerOptions {
   _geminiComplete?: typeof geminiComplete;
   /** Override for testing — replaces geminiCompleteStream */
   _geminiCompleteStream?: typeof geminiCompleteStream;
+  /** Returns the current authenticated ChatGPT BrowserContext */
+  getChatGPTContext?: () => BrowserContext | null;
+  /** Async lazy connect for ChatGPT */
+  connectChatGPTContext?: () => Promise<BrowserContext | null>;
+  /** Override for testing */
+  _chatgptComplete?: typeof chatgptComplete;
+  /** Override for testing */
+  _chatgptCompleteStream?: typeof chatgptCompleteStream;
 }
 
 /** Available CLI bridge models for GET /v1/models */
@@ -105,6 +114,12 @@ export const CLI_MODELS = [
   { id: "web-gemini/gemini-2-5-flash", name: "Gemini 2.5 Flash (web session)", contextWindow: 1_000_000, maxTokens: 8192 },
   { id: "web-gemini/gemini-3-pro",     name: "Gemini 3 Pro (web session)",     contextWindow: 1_000_000, maxTokens: 8192 },
   { id: "web-gemini/gemini-3-flash",   name: "Gemini 3 Flash (web session)",   contextWindow: 1_000_000, maxTokens: 8192 },
+  // ChatGPT web-session models (requires /chatgpt-login)
+  { id: "web-chatgpt/gpt-4o",       name: "GPT-4o (web session)",       contextWindow: 128_000, maxTokens: 16_384 },
+  { id: "web-chatgpt/gpt-4o-mini",  name: "GPT-4o Mini (web session)",  contextWindow: 128_000, maxTokens: 16_384 },
+  { id: "web-chatgpt/gpt-o3",       name: "o3 (web session)",           contextWindow: 200_000, maxTokens: 100_000 },
+  { id: "web-chatgpt/gpt-o4-mini",  name: "o4-mini (web session)",      contextWindow: 200_000, maxTokens: 100_000 },
+  { id: "web-chatgpt/gpt-5",        name: "GPT-5 (web session)",        contextWindow: 1_000_000, maxTokens: 32_768 },
 ];
 
 // ──────────────────────────────────────────────────────────────────────────────
@@ -374,6 +389,43 @@ async function handleRequest(
     }
     // ─────────────────────────────────────────────────────────────────────────
 
+    // ── ChatGPT web-session routing ───────────────────────────────────────────
+    if (model.startsWith("web-chatgpt/")) {
+      let chatgptCtx = opts.getChatGPTContext?.() ?? null;
+      if (!chatgptCtx && opts.connectChatGPTContext) chatgptCtx = await opts.connectChatGPTContext();
+      if (!chatgptCtx) {
+        res.writeHead(503, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: { message: "No active chatgpt.com session. Use /chatgpt-login to authenticate.", code: "no_chatgpt_session" } }));
+        return;
+      }
+      const timeoutMs = opts.timeoutMs ?? 120_000;
+      const msgs = messages as ChatGPTBrowserChatMessage[];
+      const doComplete = opts._chatgptComplete ?? chatgptComplete;
+      const doStream = opts._chatgptCompleteStream ?? chatgptCompleteStream;
+      try {
+        if (stream) {
+          res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive", ...corsHeaders() });
+          sendSseChunk(res, { id, created, model, delta: { role: "assistant" }, finish_reason: null });
+          const result = await doStream(chatgptCtx, { messages: msgs, model, timeoutMs },
+            (token) => sendSseChunk(res, { id, created, model, delta: { content: token }, finish_reason: null }), opts.log);
+          sendSseChunk(res, { id, created, model, delta: {}, finish_reason: result.finishReason });
+          res.write("data: [DONE]\n\n"); res.end();
+        } else {
+          const result = await doComplete(chatgptCtx, { messages: msgs, model, timeoutMs }, opts.log);
+          res.writeHead(200, { "Content-Type": "application/json", ...corsHeaders() });
+          res.end(JSON.stringify({ id, object: "chat.completion", created, model,
+            choices: [{ index: 0, message: { role: "assistant", content: result.content }, finish_reason: result.finishReason }],
+            usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 } }));
+        }
+      } catch (err) {
+        const msg = (err as Error).message;
+        opts.warn(`[cli-bridge] ChatGPT browser error for ${model}: ${msg}`);
+        if (!res.headersSent) { res.writeHead(500, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: { message: msg, type: "chatgpt_browser_error" } })); }
+      }
+      return;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+
     // ── CLI runner routing (Gemini / Claude Code) ─────────────────────────────
     let content: string;
     try {

package/test/chatgpt-proxy.test.ts

@@ -0,0 +1,107 @@
+/**
+ * test/chatgpt-proxy.test.ts
+ *
+ * Tests for ChatGPT web-session routing in the cli-bridge proxy.
+ * Uses _chatgptComplete/_chatgptCompleteStream DI overrides (no real browser).
+ */
+
+import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
+import http from "node:http";
+import type { AddressInfo } from "node:net";
+import { startProxyServer, CLI_MODELS } from "../src/proxy-server.js";
+import type { BrowserContext } from "playwright";
+
+type Opts = { messages: { role: string; content: string }[]; model?: string; timeoutMs?: number };
+type Result = { content: string; model: string; finishReason: string };
+
+const stubComplete = vi.fn(async (_ctx: BrowserContext, opts: Opts, _log: (m: string) => void): Promise<Result> => ({
+  content: `chatgpt mock: ${opts.messages[opts.messages.length - 1]?.content ?? ""}`,
+  model: opts.model ?? "web-chatgpt/gpt-4o", finishReason: "stop",
+}));
+const stubStream = vi.fn(async (_ctx: BrowserContext, opts: Opts, onToken: (t: string) => void, _log: (m: string) => void): Promise<Result> => {
+  ["chatgpt ", "stream ", "mock"].forEach(t => onToken(t));
+  return { content: "chatgpt stream mock", model: opts.model ?? "web-chatgpt/gpt-4o", finishReason: "stop" };
+});
+
+async function post(url: string, body: unknown): Promise<{ status: number; body: unknown }> {
+  return new Promise((res, rej) => {
+    const d = JSON.stringify(body); const u = new URL(url);
+    const r = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "POST",
+      headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(d) } },
+      resp => { let raw = ""; resp.on("data", c => raw += c); resp.on("end", () => { try { res({ status: resp.statusCode ?? 0, body: JSON.parse(raw) }); } catch { res({ status: resp.statusCode ?? 0, body: raw }); } }); });
+    r.on("error", rej); r.write(d); r.end();
+  });
+}
+async function get(url: string): Promise<{ status: number; body: unknown }> {
+  return new Promise((res, rej) => {
+    const u = new URL(url);
+    const r = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "GET" },
+      resp => { let raw = ""; resp.on("data", c => raw += c); resp.on("end", () => { try { res({ status: resp.statusCode ?? 0, body: JSON.parse(raw) }); } catch { res({ status: resp.statusCode ?? 0, body: raw }); } }); });
+    r.on("error", rej); r.end();
+  });
+}
+
+const fakeCtx = {} as BrowserContext;
+let server: http.Server;
+let baseUrl: string;
+
+beforeAll(async () => {
+  server = await startProxyServer({
+    port: 0, log: () => {}, warn: () => {},
+    getChatGPTContext: () => fakeCtx,
+    // @ts-expect-error stub
+    _chatgptComplete: stubComplete,
+    // @ts-expect-error stub
+    _chatgptCompleteStream: stubStream,
+  });
+  baseUrl = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+});
+afterAll(() => server.close());
+
+describe("ChatGPT routing — model list", () => {
+  it("includes web-chatgpt/* models in /v1/models", async () => {
+    const res = await get(`${baseUrl}/v1/models`);
+    expect(res.status).toBe(200);
+    const ids = (res.body as { data: { id: string }[] }).data.map(m => m.id);
+    expect(ids).toContain("web-chatgpt/gpt-4o");
+    expect(ids).toContain("web-chatgpt/gpt-5");
+  });
+  it("CLI_MODELS includes web-chatgpt/*", () => {
+    expect(CLI_MODELS.some(m => m.id.startsWith("web-chatgpt/"))).toBe(true);
+  });
+});
+
+describe("ChatGPT routing — non-streaming", () => {
+  it("returns assistant message for web-chatgpt/gpt-4o", async () => {
+    const res = await post(`${baseUrl}/v1/chat/completions`, {
+      model: "web-chatgpt/gpt-4o", messages: [{ role: "user", content: "hello chatgpt" }], stream: false,
+    });
+    expect(res.status).toBe(200);
+    expect((res.body as any).choices[0].message.content).toContain("chatgpt mock");
+  });
+  it("passes correct model to stub", async () => {
+    stubComplete.mockClear();
+    await post(`${baseUrl}/v1/chat/completions`, { model: "web-chatgpt/gpt-o3", messages: [{ role: "user", content: "x" }] });
+    expect(stubComplete).toHaveBeenCalledOnce();
+    expect(stubComplete.mock.calls[0][1].model).toBe("web-chatgpt/gpt-o3");
+  });
+  it("returns 503 when no context", async () => {
+    const s = await startProxyServer({ port: 0, log: () => {}, warn: () => {}, getChatGPTContext: () => null });
+    const u = `http://127.0.0.1:${(s.address() as AddressInfo).port}`;
+    const r = await post(`${u}/v1/chat/completions`, { model: "web-chatgpt/gpt-4o", messages: [{ role: "user", content: "hi" }] });
+    expect(r.status).toBe(503);
+    expect((r.body as any).error.code).toBe("no_chatgpt_session");
+    s.close();
+  });
+});
+
+describe("ChatGPT routing — streaming", () => {
+  it("returns SSE stream with [DONE]", () => new Promise<void>((resolve, reject) => {
+    const body = JSON.stringify({ model: "web-chatgpt/gpt-4o", messages: [{ role: "user", content: "s" }], stream: true });
+    const u = new URL(`${baseUrl}/v1/chat/completions`);
+    const r = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "POST",
+      headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } },
+      resp => { let raw = ""; resp.on("data", c => raw += c); resp.on("end", () => { expect(raw).toContain("[DONE]"); resolve(); }); });
+    r.on("error", reject); r.write(body); r.end();
+  }));
+});