@elvatis_com/openclaw-cli-bridge-elvatis 1.5.0 → 1.6.1

package/CONTRIBUTING.md

@@ -0,0 +1,93 @@
+# Contributing & Release Checklist
+
+## 🚨 Pflicht-Workflow vor jedem Release
+
+**Kein Publish ohne erfolgreichen `/bridge-status` Test!**
+
+### 1. Build
+
+```bash
+npm run build
+# Exit 0 erwartet — TS-Fehler sind ok (--noEmitOnError false), aber Exit != 0 blockiert
+```
+
+### 2. Gateway neu starten
+
+```bash
+openclaw gateway restart
+# oder via Chat: gateway restart
+```
+
+### 3. Smoke Tests (alle müssen grün sein)
+
+```
+/bridge-status     → Grok ✅ + Gemini ✅ (beide connected, nicht "not connected")
+/cli-test          → CLI bridge OK, Latency < 10s
+/grok-status       → valid (Cookie-Expiry prüfen)
+/gemini-status     → valid (Cookie-Expiry prüfen)
+```
+
+**Erst wenn alle Tests grün sind → publishen!**
+
+### 4. Publish (Reihenfolge einhalten)
+
+```bash
+# 1. Version bump in package.json + openclaw.plugin.json (beide!)
+# 2. Git commit + tag
+git add package.json openclaw.plugin.json
+git commit -m "chore: bump to vX.Y.Z — <kurze Beschreibung>"
+git tag vX.Y.Z
+git push origin main vX.Y.Z
+
+# 3. GitHub Release erstellen (Tag ≠ Release!)
+gh release create vX.Y.Z --title "vX.Y.Z — <Titel>" --notes "<Notes>" --latest
+
+# 4. npm publish
+npm publish --access public
+
+# 5. ClawHub publish (aus tmp-Dir, nicht direkt aus Repo)
+TMPDIR=$(mktemp -d)
+rsync -a --exclude='node_modules' --exclude='.git' --exclude='dist' \
+  --exclude='package-lock.json' --exclude='test' ./ "$TMPDIR/"
+clawhub publish "$TMPDIR" --slug openclaw-cli-bridge-elvatis --version X.Y.Z \
+  --tags "latest" --changelog "<Changelog>"
+```
+
+> ⚠️ **ClawHub Bug (CLI v0.7.0):** `acceptLicenseTerms: invalid value` — Workaround: `publish.js` vor dem Publish patchen und danach zurücksetzen. Details in AGENTS.md / MEMORY.md des Workspaces.
+
+---
+
+## Versionsstellen — alle prüfen vor Release
+
+```bash
+grep -rn "X\.Y\.Z\|version" \
+  --include="*.md" --include="*.json" \
+  --exclude-dir=node_modules --exclude-dir=dist --exclude-dir=.git \
+  | grep -i "version"
+```
+
+Typische Stellen:
+- `package.json` → `"version": "..."`
+- `openclaw.plugin.json` → `"version": "..."`
+- `README.md` → `**Current version:** ...` (falls vorhanden)
+
+---
+
+## Breaking Changes
+
+Bei Breaking Changes (Major oder entfernte Commands):
+- Version-Bump auf nächste **Minor** (z.B. 1.4.x → 1.5.0)
+- GitHub Release Notes: `## ⚠️ Breaking Change` Sektion
+- README Changelog: Was wurde entfernt + warum
+- `/bridge-status` muss die entfernten Provider NICHT mehr zeigen
+
+---
+
+## TS-Build-Fehler
+
+Die folgenden TS-Fehler sind bekannt und ignorierbar (kein Runtime-Problem):
+- `TS2307: Cannot find module 'openclaw/plugin-sdk'` — Typ-Deklarationen fehlen in npm-Paket
+- `TS2339: Property 'handler' does not exist on type 'unknown'` — folgt aus TS2307
+- `TS7006: Parameter implicitly has 'any' type` — minor, kein Effekt
+
+Build läuft mit `--noEmitOnError false` durch. `npm run build` → Exit 0 ist das Kriterium, nicht null TS-Fehler.

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.5.0`
+**Current version:** `1.6.1`
 
 ---
 
@@ -115,11 +115,42 @@ Routes requests through real browser sessions on the provider's web UI. Requires
 | `/gemini-status` | Show session validity + cookie expiry |
 | `/gemini-logout` | Clear session |
 
+**Claude.ai** (claude.ai — Pro/Team subscription):
+
+| Model | Notes |
+|---|---|
+| `web-claude/claude-sonnet` | Claude Sonnet (web) |
+| `web-claude/claude-opus` | Claude Opus (web) |
+| `web-claude/claude-haiku` | Claude Haiku (web) |
+
+| Command | What it does |
+|---|---|
+| `/claude-login` | Authenticate, save cookies to `~/.openclaw/claude-profile/` |
+| `/claude-status` | Show session validity + cookie expiry |
+| `/claude-logout` | Clear session |
+
+**ChatGPT** (chatgpt.com — Plus/Pro subscription):
+
+| Model | Notes |
+|---|---|
+| `web-chatgpt/gpt-4o` | GPT-4o |
+| `web-chatgpt/gpt-4o-mini` | GPT-4o Mini |
+| `web-chatgpt/gpt-o3` | GPT o3 |
+| `web-chatgpt/gpt-o4-mini` | GPT o4-mini |
+| `web-chatgpt/gpt-5` | GPT-5 |
+
+| Command | What it does |
+|---|---|
+| `/chatgpt-login` | Authenticate, save cookies to `~/.openclaw/chatgpt-profile/` |
+| `/chatgpt-status` | Show session validity + cookie expiry |
+| `/chatgpt-logout` | Clear session |
+
 **Session lifecycle:**
-- First use: run `/xxx-login` once - authenticates and saves cookies to persistent Chromium profile
+- First use: run `/xxx-login` once — authenticates and saves cookies to persistent Chromium profile
 - **No CDP required:** `/xxx-login` no longer depends on the OpenClaw browser (CDP port 18800). If CDP is available, cookies are imported from it; otherwise a standalone persistent Chromium is launched automatically.
+- If headless login fails, a **headed browser** opens for manual login (5 min timeout)
 - After gateway restart: sessions are **automatically restored** from saved profiles on startup (sequential, ~25s after start)
-- `/bridge-status` — shows all providers at a glance with login state + expiry info
+- `/bridge-status` — shows all 4 providers at a glance with login state + expiry info
 
 ---
 

package/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: openclaw-cli-bridge-elvatis
-description: Bridge local Codex, Gemini, and Claude Code CLIs into OpenClaw as vllm model providers. Includes /cli-* slash commands for instant model switching (/cli-sonnet, /cli-opus, /cli-haiku, /cli-gemini, /cli-gemini-flash, /cli-gemini3). E2BIG-safe spawn via minimal env.
+description: Bridge local AI CLIs + web browser sessions (Grok, Gemini, Claude.ai, ChatGPT) into OpenClaw as model providers. Includes /cli-* slash commands for instant model switching and persistent browser profiles for all 4 web providers.
 homepage: https://github.com/elvatis/openclaw-cli-bridge-elvatis
 metadata:
   {
@@ -15,7 +15,7 @@ metadata:
 
 # OpenClaw CLI Bridge
 
-Bridges locally installed AI CLIs (Codex, Gemini, Claude Code) as OpenClaw model providers. Three phases:
+Bridges locally installed AI CLIs + web browser sessions into OpenClaw as model providers. Four phases:
 
 ## Phase 1 — Codex Auth Bridge
 Registers `openai-codex` provider from existing `~/.codex/auth.json` tokens. No re-login.
@@ -43,7 +43,16 @@ Six instant model-switch commands (authorized senders only):
 | `/cli-back` | Restore previous model |
 | `/cli-test [model]` | Health check (no model switch) |
 
-Each command runs `openclaw models set <model>` atomically and replies with a confirmation.
+Each command uses staged switching by default (apply with `/cli-apply`).
+
+## Phase 4 — Web Browser Providers
+Persistent Chromium profiles for 4 web providers (no API key needed):
+- **Grok** (`web-grok/*`): `/grok-login`, `/grok-status`, `/grok-logout`
+- **Gemini** (`web-gemini/*`): `/gemini-login`, `/gemini-status`, `/gemini-logout`
+- **Claude.ai** (`web-claude/*`): `/claude-login`, `/claude-status`, `/claude-logout`
+- **ChatGPT** (`web-chatgpt/*`): `/chatgpt-login`, `/chatgpt-status`, `/chatgpt-logout`
+
+Sessions survive gateway restarts. `/bridge-status` shows all 4 at a glance.
 
 ## Setup
 
@@ -53,4 +62,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.3.1
+**Version:** 1.6.1

package/index.ts

@@ -88,6 +88,8 @@ let grokContext: BrowserContext | null = null;
 // Persistent profile dirs — survive gateway restarts, keep cookies intact
 const GROK_PROFILE_DIR = join(homedir(), ".openclaw", "grok-profile");
 const GEMINI_PROFILE_DIR = join(homedir(), ".openclaw", "gemini-profile");
+const CLAUDE_PROFILE_DIR = join(homedir(), ".openclaw", "claude-profile");
+const CHATGPT_PROFILE_DIR = join(homedir(), ".openclaw", "chatgpt-profile");
 
 // Stealth launch options — prevent Cloudflare/bot detection from flagging the browser
 const STEALTH_ARGS = [
@@ -102,6 +104,14 @@ const STEALTH_IGNORE_DEFAULTS = ["--enable-automation"] as const;
 let geminiContext: BrowserContext | null = null;
 const GEMINI_EXPIRY_FILE = join(homedir(), ".openclaw", "gemini-cookie-expiry.json");
 
+// ── Claude web-session state ─────────────────────────────────────────────────
+let claudeWebContext: BrowserContext | null = null;
+const CLAUDE_EXPIRY_FILE = join(homedir(), ".openclaw", "claude-cookie-expiry.json");
+
+// ── ChatGPT web-session state ────────────────────────────────────────────────
+let chatgptContext: BrowserContext | null = null;
+const CHATGPT_EXPIRY_FILE = join(homedir(), ".openclaw", "chatgpt-cookie-expiry.json");
+
 interface GeminiExpiryInfo { expiresAt: number; loginAt: number; cookieName: string; }
 
 function saveGeminiExpiry(info: GeminiExpiryInfo): void {
@@ -128,6 +138,60 @@ async function scanGeminiCookieExpiry(ctx: BrowserContext): Promise<GeminiExpiry
     return { expiresAt: (earliest.expires ?? 0) * 1000, loginAt: Date.now(), cookieName: earliest.name };
   } catch { return null; }
 }
+// ── Claude cookie expiry helpers ─────────────────────────────────────────────
+interface ClaudeExpiryInfo { expiresAt: number; loginAt: number; cookieName: string; }
+function saveClaudeExpiry(info: ClaudeExpiryInfo): void {
+  try { writeFileSync(CLAUDE_EXPIRY_FILE, JSON.stringify(info, null, 2)); } catch { /* ignore */ }
+}
+function loadClaudeExpiry(): ClaudeExpiryInfo | null {
+  try { return JSON.parse(readFileSync(CLAUDE_EXPIRY_FILE, "utf-8")) as ClaudeExpiryInfo; } catch { return null; }
+}
+function formatClaudeExpiry(info: ClaudeExpiryInfo): string {
+  const daysLeft = Math.floor((info.expiresAt - Date.now()) / 86_400_000);
+  const dateStr = new Date(info.expiresAt).toISOString().substring(0, 10);
+  if (daysLeft < 0)   return `⚠️ EXPIRED (${dateStr}) — run /claude-login`;
+  if (daysLeft <= 7)  return `🚨 expires in ${daysLeft}d (${dateStr}) — run /claude-login NOW`;
+  if (daysLeft <= 14) return `⚠️ expires in ${daysLeft}d (${dateStr}) — run /claude-login soon`;
+  return `✅ valid for ${daysLeft} more days (expires ${dateStr})`;
+}
+async function scanClaudeCookieExpiry(ctx: BrowserContext): Promise<ClaudeExpiryInfo | null> {
+  try {
+    const cookies = await ctx.cookies(["https://claude.ai"]);
+    const auth = cookies.filter(c => ["sessionKey", "__cf_bm", "lastActiveOrg"].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; }
+}
+
+// ── ChatGPT cookie expiry helpers ────────────────────────────────────────────
+interface ChatGPTExpiryInfo { expiresAt: number; loginAt: number; cookieName: string; }
+function saveChatGPTExpiry(info: ChatGPTExpiryInfo): void {
+  try { writeFileSync(CHATGPT_EXPIRY_FILE, JSON.stringify(info, null, 2)); } catch { /* ignore */ }
+}
+function loadChatGPTExpiry(): ChatGPTExpiryInfo | null {
+  try { return JSON.parse(readFileSync(CHATGPT_EXPIRY_FILE, "utf-8")) as ChatGPTExpiryInfo; } catch { return null; }
+}
+function formatChatGPTExpiry(info: ChatGPTExpiryInfo): string {
+  const daysLeft = Math.floor((info.expiresAt - Date.now()) / 86_400_000);
+  const dateStr = new Date(info.expiresAt).toISOString().substring(0, 10);
+  if (daysLeft < 0)   return `⚠️ EXPIRED (${dateStr}) — run /chatgpt-login`;
+  if (daysLeft <= 7)  return `🚨 expires in ${daysLeft}d (${dateStr}) — run /chatgpt-login NOW`;
+  if (daysLeft <= 14) return `⚠️ expires in ${daysLeft}d (${dateStr}) — run /chatgpt-login soon`;
+  return `✅ valid for ${daysLeft} more days (expires ${dateStr})`;
+}
+async function scanChatGPTCookieExpiry(ctx: BrowserContext): Promise<ChatGPTExpiryInfo | null> {
+  try {
+    const cookies = await ctx.cookies(["https://chatgpt.com", "https://auth0.openai.com"]);
+    const auth = cookies.filter(c => ["__Secure-next-auth.session-token", "_puid", "oai-did"].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; }
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 
 // Cookie expiry tracking file — written on /grok-login, read on startup
@@ -297,6 +361,80 @@ async function getOrLaunchGeminiContext(
   return _geminiLaunchPromise;
 }
 
+// ── Per-provider persistent context launch promises (Claude) ─────────────────
+let _claudeLaunchPromise: Promise<BrowserContext | null> | null = null;
+
+async function getOrLaunchClaudeContext(
+  log: (msg: string) => void
+): Promise<BrowserContext | null> {
+  if (claudeWebContext) {
+    try { claudeWebContext.pages(); return claudeWebContext; } catch { claudeWebContext = null; }
+  }
+  const cdpCtx = await connectToOpenClawBrowser(log);
+  if (cdpCtx) return cdpCtx;
+  if (_claudeLaunchPromise) return _claudeLaunchPromise;
+  _claudeLaunchPromise = (async () => {
+    const { chromium } = await import("playwright");
+    log("[cli-bridge:claude-web] launching persistent Chromium…");
+    try {
+      mkdirSync(CLAUDE_PROFILE_DIR, { recursive: true });
+      const ctx = await chromium.launchPersistentContext(CLAUDE_PROFILE_DIR, {
+        headless: true,
+        channel: "chrome",
+        args: STEALTH_ARGS,
+        ignoreDefaultArgs: [...STEALTH_IGNORE_DEFAULTS],
+      });
+      claudeWebContext = ctx;
+      ctx.on("close", () => { claudeWebContext = null; log("[cli-bridge:claude-web] persistent context closed"); });
+      log("[cli-bridge:claude-web] persistent context ready");
+      return ctx;
+    } catch (err) {
+      log(`[cli-bridge:claude-web] failed to launch browser: ${(err as Error).message}`);
+      return null;
+    } finally {
+      _claudeLaunchPromise = null;
+    }
+  })();
+  return _claudeLaunchPromise;
+}
+
+// ── Per-provider persistent context launch promises (ChatGPT) ────────────────
+let _chatgptLaunchPromise: Promise<BrowserContext | null> | null = null;
+
+async function getOrLaunchChatGPTContext(
+  log: (msg: string) => void
+): Promise<BrowserContext | null> {
+  if (chatgptContext) {
+    try { chatgptContext.pages(); return chatgptContext; } catch { chatgptContext = null; }
+  }
+  const cdpCtx = await connectToOpenClawBrowser(log);
+  if (cdpCtx) return cdpCtx;
+  if (_chatgptLaunchPromise) return _chatgptLaunchPromise;
+  _chatgptLaunchPromise = (async () => {
+    const { chromium } = await import("playwright");
+    log("[cli-bridge:chatgpt] launching persistent Chromium…");
+    try {
+      mkdirSync(CHATGPT_PROFILE_DIR, { recursive: true });
+      const ctx = await chromium.launchPersistentContext(CHATGPT_PROFILE_DIR, {
+        headless: true,
+        channel: "chrome",
+        args: STEALTH_ARGS,
+        ignoreDefaultArgs: [...STEALTH_IGNORE_DEFAULTS],
+      });
+      chatgptContext = ctx;
+      ctx.on("close", () => { chatgptContext = null; log("[cli-bridge:chatgpt] persistent context closed"); });
+      log("[cli-bridge:chatgpt] persistent context ready");
+      return ctx;
+    } catch (err) {
+      log(`[cli-bridge:chatgpt] failed to launch browser: ${(err as Error).message}`);
+      return null;
+    } finally {
+      _chatgptLaunchPromise = null;
+    }
+  })();
+  return _chatgptLaunchPromise;
+}
+
 /** Clean up all browser resources — call on plugin teardown */
 async function cleanupBrowsers(log: (msg: string) => void): Promise<void> {
   if (grokContext) {
@@ -307,6 +445,14 @@ async function cleanupBrowsers(log: (msg: string) => void): Promise<void> {
     try { await geminiContext.close(); } catch { /* ignore */ }
     geminiContext = null;
   }
+  if (claudeWebContext) {
+    try { await claudeWebContext.close(); } catch { /* ignore */ }
+    claudeWebContext = null;
+  }
+  if (chatgptContext) {
+    try { await chatgptContext.close(); } catch { /* ignore */ }
+    chatgptContext = null;
+  }
   if (_cdpBrowser) {
     try { await _cdpBrowser.close(); } catch { /* ignore */ }
     _cdpBrowser = null;
@@ -708,11 +854,12 @@ function proxyTestRequest(
 const plugin = {
   id: "openclaw-cli-bridge-elvatis",
   name: "OpenClaw CLI Bridge",
-  version: "1.3.1",
+  version: "1.6.1",
   description:
     "Phase 1: openai-codex auth bridge. " +
     "Phase 2: HTTP proxy for gemini/claude CLIs. " +
-    "Phase 3: /cli-* model switching, /cli-back restore, /cli-test health check.",
+    "Phase 3: /cli-* model switching, /cli-back restore, /cli-test health check. " +
+    "Phase 4: persistent browser profiles for Grok, Gemini, Claude.ai, ChatGPT.",
 
   register(api: OpenClawPluginApi) {
     const cfg = (api.pluginConfig ?? {}) as CliPluginConfig;
@@ -738,12 +885,16 @@ const plugin = {
         const { chromium } = await import("playwright");
         const { existsSync } = await import("node:fs");
 
+        // Collect providers that need re-login — send one batched WhatsApp alert
+        const needsLogin: string[] = [];
+
         const profileProviders: Array<{
           name: string;
           profileDir: string;
           cookieFile: string;
           verifySelector: string;
           homeUrl: string;
+          loginCmd: string;
           setCtx: (c: BrowserContext) => void;
           getCtx: () => BrowserContext | null;
         }> = [
@@ -753,18 +904,40 @@ const plugin = {
             cookieFile: join(homedir(), ".openclaw", "grok-session.json"),
             verifySelector: "textarea",
             homeUrl: "https://grok.com",
+            loginCmd: "/grok-login",
             getCtx: () => grokContext,
             setCtx: (c) => { grokContext = c; },
           },
           {
             name: "gemini",
-            profileDir: join(homedir(), ".openclaw", "gemini-profile"),
+            profileDir: GEMINI_PROFILE_DIR,
             cookieFile: join(homedir(), ".openclaw", "gemini-cookie-expiry.json"),
             verifySelector: ".ql-editor",
             homeUrl: "https://gemini.google.com/app",
+            loginCmd: "/gemini-login",
             getCtx: () => geminiContext,
             setCtx: (c) => { geminiContext = c; },
           },
+          {
+            name: "claude-web",
+            profileDir: CLAUDE_PROFILE_DIR,
+            cookieFile: CLAUDE_EXPIRY_FILE,
+            verifySelector: ".ProseMirror",
+            homeUrl: "https://claude.ai/new",
+            loginCmd: "/claude-login",
+            getCtx: () => claudeWebContext,
+            setCtx: (c) => { claudeWebContext = c; },
+          },
+          {
+            name: "chatgpt",
+            profileDir: CHATGPT_PROFILE_DIR,
+            cookieFile: CHATGPT_EXPIRY_FILE,
+            verifySelector: "#prompt-textarea",
+            homeUrl: "https://chatgpt.com",
+            loginCmd: "/chatgpt-login",
+            getCtx: () => chatgptContext,
+            setCtx: (c) => { chatgptContext = c; },
+          },
         ];
 
         for (const p of profileProviders) {
@@ -791,7 +964,8 @@ const plugin = {
               api.logger.info(`[cli-bridge:${p.name}] session restored from profile ✅`);
             } else {
               await ctx.close().catch(() => {});
-              api.logger.info(`[cli-bridge:${p.name}] profile exists but not logged in — needs /xxx-login`);
+              api.logger.info(`[cli-bridge:${p.name}] profile exists but not logged in — needs ${p.loginCmd}`);
+              needsLogin.push(p.loginCmd);
             }
           } catch (err) {
             api.logger.warn(`[cli-bridge:${p.name}] startup restore failed: ${(err as Error).message}`);
@@ -799,6 +973,22 @@ const plugin = {
 
           // Sequential — never spawn all 4 Chromium instances at once
           await new Promise(r => setTimeout(r, 3000));
+
+        }
+
+        // Send one batched WhatsApp alert if any providers need re-login
+        if (needsLogin.length > 0) {
+          const cmds = needsLogin.map(cmd => `• ${cmd}`).join("\n");
+          const msg = `🔐 *cli-bridge:* Session expired for ${needsLogin.length} provider(s). Run to re-login:\n\n${cmds}`;
+          try {
+            await api.runtime.system.runCommandWithTimeout(
+              ["openclaw", "message", "send", "--channel", "whatsapp", "--to", "+4915170113694", "--message", msg],
+              { timeoutMs: 10_000 }
+            );
+            api.logger.info(`[cli-bridge] sent re-login notification for: ${needsLogin.join(", ")}`);
+          } catch (err) {
+            api.logger.warn(`[cli-bridge] failed to send re-login notification: ${(err as Error).message}`);
+          }
         }
       })();
     }
@@ -843,7 +1033,7 @@ const plugin = {
           },
         ],
 
-        refreshOAuth: async (cred) => {
+        refreshOAuth: async (cred: ProviderAuthContext) => {
           try {
             const fresh = await readCodexCredentials(codexAuthPath);
             return {
@@ -918,6 +1108,28 @@ const plugin = {
               }
               return geminiContext;
             },
+            getClaudeContext: () => claudeWebContext,
+            connectClaudeContext: async () => {
+              const ctx = await getOrLaunchClaudeContext((msg) => api.logger.info(msg));
+              if (ctx) {
+                const { getOrCreateClaudePage } = await import("./src/claude-browser.js");
+                const { page } = await getOrCreateClaudePage(ctx);
+                const editor = await page.locator(".ProseMirror").isVisible().catch(() => false);
+                if (editor) { claudeWebContext = ctx; return ctx; }
+              }
+              return claudeWebContext;
+            },
+            getChatGPTContext: () => chatgptContext,
+            connectChatGPTContext: async () => {
+              const ctx = await getOrLaunchChatGPTContext((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 chatgptContext;
+            },
           });
           proxyServer = server;
           api.logger.info(
@@ -959,9 +1171,30 @@ const plugin = {
                     const editor = await page.locator(".ql-editor").isVisible().catch(() => false);
                     if (editor) { geminiContext = ctx; return ctx; }
                   }
-                  // No fallback spawn — return existing context or null to avoid Chromium leak
                   return geminiContext;
                 },
+                getClaudeContext: () => claudeWebContext,
+                connectClaudeContext: async () => {
+                  const ctx = await connectToOpenClawBrowser((msg) => api.logger.info(msg));
+                  if (ctx) {
+                    const { getOrCreateClaudePage } = await import("./src/claude-browser.js");
+                    const { page } = await getOrCreateClaudePage(ctx);
+                    const editor = await page.locator(".ProseMirror").isVisible().catch(() => false);
+                    if (editor) { claudeWebContext = ctx; return ctx; }
+                  }
+                  return claudeWebContext;
+                },
+                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 chatgptContext;
+                },
               });
               proxyServer = server;
               api.logger.info(`[cli-bridge] proxy ready on :${port} (retry)`);
@@ -1428,10 +1661,262 @@ const plugin = {
       },
     } satisfies OpenClawPluginCommandDefinition);
 
+    // ── Claude.ai web-session commands ─────────────────────────────────────────
+    api.registerCommand({
+      name: "claude-login",
+      description: "Authenticate claude.ai: imports cookies from OpenClaw browser into persistent profile",
+      handler: async (): Promise<PluginCommandResult> => {
+        if (claudeWebContext) {
+          const { getOrCreateClaudePage } = await import("./src/claude-browser.js");
+          try {
+            const { page } = await getOrCreateClaudePage(claudeWebContext);
+            const editor = await page.locator(".ProseMirror").isVisible().catch(() => false);
+            if (editor) return { text: "✅ Already connected to claude.ai. Use `/claude-logout` first to reset." };
+          } catch { /* fall through */ }
+          claudeWebContext = null;
+        }
+
+        api.logger.info("[cli-bridge:claude-web] /claude-login: connecting…");
+
+        // Step 1: try to grab cookies from OpenClaw browser (CDP)
+        let importedCookies: unknown[] = [];
+        try {
+          const { chromium } = await import("playwright");
+          const ocBrowser = await chromium.connectOverCDP("http://127.0.0.1:18800", { timeout: 3000 });
+          const ocCtx = ocBrowser.contexts()[0];
+          if (ocCtx) {
+            importedCookies = await ocCtx.cookies(["https://claude.ai"]);
+            api.logger.info(`[cli-bridge:claude-web] imported ${importedCookies.length} cookies from OpenClaw browser`);
+          }
+          await ocBrowser.close().catch(() => {});
+        } catch {
+          api.logger.info("[cli-bridge:claude-web] OpenClaw browser not available — using saved profile");
+        }
+
+        // Step 2: get or launch persistent context
+        const ctx = await getOrLaunchClaudeContext((msg) => api.logger.info(msg));
+        if (!ctx) return { text: "❌ Could not launch browser. Check server logs." };
+
+        // Step 3: inject imported cookies
+        if (importedCookies.length > 0) {
+          await ctx.addCookies(importedCookies as Parameters<typeof ctx.addCookies>[0]);
+          api.logger.info("[cli-bridge:claude-web] cookies injected into persistent profile");
+        }
+
+        // Step 4: navigate and verify
+        const { getOrCreateClaudePage } = await import("./src/claude-browser.js");
+        let page;
+        try {
+          ({ page } = await getOrCreateClaudePage(ctx));
+        } catch (err) {
+          return { text: `❌ Failed to open claude.ai: ${(err as Error).message}` };
+        }
+
+        let editor = await page.locator(".ProseMirror").isVisible().catch(() => false);
+        if (!editor) {
+          // Headless failed — launch headed browser for interactive login
+          api.logger.info("[cli-bridge:claude-web] headless login failed — launching headed browser for manual login…");
+          try { await ctx.close(); } catch { /* ignore */ }
+          claudeWebContext = null;
+
+          const { chromium } = await import("playwright");
+          const headedCtx = await chromium.launchPersistentContext(CLAUDE_PROFILE_DIR, {
+            headless: false,
+            channel: "chrome",
+            args: STEALTH_ARGS,
+            ignoreDefaultArgs: [...STEALTH_IGNORE_DEFAULTS],
+          });
+          const loginPage = await headedCtx.newPage();
+          await loginPage.goto("https://claude.ai/new", { waitUntil: "domcontentloaded", timeout: 15_000 });
+
+          api.logger.info("[cli-bridge:claude-web] waiting for manual login (5 min timeout)…");
+          try {
+            await loginPage.waitForSelector(".ProseMirror", { timeout: 300_000 });
+          } catch {
+            await headedCtx.close().catch(() => {});
+            return { text: "❌ Login timeout — Claude editor did not appear within 5 minutes." };
+          }
+
+          claudeWebContext = headedCtx;
+          headedCtx.on("close", () => { claudeWebContext = null; });
+          editor = true;
+          page = loginPage;
+        } else {
+          claudeWebContext = ctx;
+        }
+
+        const expiry = await scanClaudeCookieExpiry(claudeWebContext!);
+        if (expiry) {
+          saveClaudeExpiry(expiry);
+          api.logger.info(`[cli-bridge:claude-web] cookie expiry: ${new Date(expiry.expiresAt).toISOString()}`);
+        }
+        const expiryLine = expiry ? `\n\n🕐 Cookie expiry: ${formatClaudeExpiry(expiry)}` : "";
+
+        return { text: `✅ Claude.ai session ready!\n\nModels available:\n• \`vllm/web-claude/claude-sonnet\`\n• \`vllm/web-claude/claude-opus\`\n• \`vllm/web-claude/claude-haiku\`${expiryLine}` };
+      },
+    } satisfies OpenClawPluginCommandDefinition);
+
+    api.registerCommand({
+      name: "claude-status",
+      description: "Check claude.ai session status",
+      handler: async (): Promise<PluginCommandResult> => {
+        if (!claudeWebContext) {
+          return { text: "❌ No active claude.ai session\nRun `/claude-login` to authenticate." };
+        }
+        const { getOrCreateClaudePage } = await import("./src/claude-browser.js");
+        try {
+          const { page } = await getOrCreateClaudePage(claudeWebContext);
+          const editor = await page.locator(".ProseMirror").isVisible().catch(() => false);
+          if (editor) {
+            const expiry = loadClaudeExpiry();
+            const expiryLine = expiry ? `\n🕐 ${formatClaudeExpiry(expiry)}` : "";
+            return { text: `✅ claude.ai session active\nProxy: \`127.0.0.1:${port}\`\nModels: web-claude/claude-sonnet, claude-opus, claude-haiku${expiryLine}` };
+          }
+        } catch { /* fall through */ }
+        claudeWebContext = null;
+        return { text: "❌ Session lost — run `/claude-login` to re-authenticate." };
+      },
+    } satisfies OpenClawPluginCommandDefinition);
+
+    api.registerCommand({
+      name: "claude-logout",
+      description: "Disconnect from claude.ai session",
+      handler: async (): Promise<PluginCommandResult> => {
+        claudeWebContext = null;
+        return { text: "✅ Disconnected from claude.ai. Run `/claude-login` to reconnect." };
+      },
+    } satisfies OpenClawPluginCommandDefinition);
+
+    // ── ChatGPT web-session commands ─────────────────────────────────────────
+    api.registerCommand({
+      name: "chatgpt-login",
+      description: "Authenticate chatgpt.com: imports cookies from OpenClaw browser into persistent profile",
+      handler: async (): Promise<PluginCommandResult> => {
+        if (chatgptContext) {
+          const { getOrCreateChatGPTPage } = await import("./src/chatgpt-browser.js");
+          try {
+            const { page } = await getOrCreateChatGPTPage(chatgptContext);
+            const editor = await page.locator("#prompt-textarea").isVisible().catch(() => false);
+            if (editor) 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…");
+
+        // Step 1: try to grab cookies from OpenClaw browser (CDP)
+        let importedCookies: unknown[] = [];
+        try {
+          const { chromium } = await import("playwright");
+          const ocBrowser = await chromium.connectOverCDP("http://127.0.0.1:18800", { timeout: 3000 });
+          const ocCtx = ocBrowser.contexts()[0];
+          if (ocCtx) {
+            importedCookies = await ocCtx.cookies(["https://chatgpt.com", "https://auth0.openai.com", "https://openai.com"]);
+            api.logger.info(`[cli-bridge:chatgpt] imported ${importedCookies.length} cookies from OpenClaw browser`);
+          }
+          await ocBrowser.close().catch(() => {});
+        } catch {
+          api.logger.info("[cli-bridge:chatgpt] OpenClaw browser not available — using saved profile");
+        }
+
+        // Step 2: get or launch persistent context
+        const ctx = await getOrLaunchChatGPTContext((msg) => api.logger.info(msg));
+        if (!ctx) return { text: "❌ Could not launch browser. Check server logs." };
+
+        // Step 3: inject imported cookies
+        if (importedCookies.length > 0) {
+          await ctx.addCookies(importedCookies as Parameters<typeof ctx.addCookies>[0]);
+          api.logger.info("[cli-bridge:chatgpt] cookies injected into persistent profile");
+        }
+
+        // Step 4: navigate and verify
+        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}` };
+        }
+
+        let editor = await page.locator("#prompt-textarea").isVisible().catch(() => false);
+        if (!editor) {
+          // Headless failed — launch headed browser for interactive login
+          api.logger.info("[cli-bridge:chatgpt] headless login failed — launching headed browser for manual login…");
+          try { await ctx.close(); } catch { /* ignore */ }
+          chatgptContext = null;
+
+          const { chromium } = await import("playwright");
+          const headedCtx = await chromium.launchPersistentContext(CHATGPT_PROFILE_DIR, {
+            headless: false,
+            channel: "chrome",
+            args: STEALTH_ARGS,
+            ignoreDefaultArgs: [...STEALTH_IGNORE_DEFAULTS],
+          });
+          const loginPage = await headedCtx.newPage();
+          await loginPage.goto("https://chatgpt.com", { waitUntil: "domcontentloaded", timeout: 15_000 });
+
+          api.logger.info("[cli-bridge:chatgpt] waiting for manual login (5 min timeout)…");
+          try {
+            await loginPage.waitForSelector("#prompt-textarea", { timeout: 300_000 });
+          } catch {
+            await headedCtx.close().catch(() => {});
+            return { text: "❌ Login timeout — ChatGPT editor did not appear within 5 minutes." };
+          }
+
+          chatgptContext = headedCtx;
+          headedCtx.on("close", () => { chatgptContext = null; });
+          editor = true;
+          page = loginPage;
+        } else {
+          chatgptContext = ctx;
+        }
+
+        const expiry = await scanChatGPTCookieExpiry(chatgptContext!);
+        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);
+          const editor = await page.locator("#prompt-textarea").isVisible().catch(() => false);
+          if (editor) {
+            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);
+
     // ── /bridge-status — all providers at a glance ───────────────────────────
     api.registerCommand({
       name: "bridge-status",
-      description: "Show status of all headless browser providers (Grok, Gemini)",
+      description: "Show status of all headless browser providers (Grok, Gemini, Claude, ChatGPT)",
       handler: async (): Promise<PluginCommandResult> => {
         const lines: string[] = [`🌉 *CLI Bridge v${plugin.version} — Provider Status*\n`];
 
@@ -1464,6 +1949,36 @@ const plugin = {
             loginCmd: "/gemini-login",
             expiry: () => { const e = loadGeminiExpiry(); return e ? formatGeminiExpiry(e) : null; },
           },
+          {
+            name: "Claude.ai",
+            ctx: claudeWebContext,
+            check: async () => {
+              if (!claudeWebContext) return false;
+              try {
+                const { getOrCreateClaudePage } = await import("./src/claude-browser.js");
+                const { page } = await getOrCreateClaudePage(claudeWebContext);
+                return page.locator(".ProseMirror").isVisible().catch(() => false);
+              } catch { claudeWebContext = 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: "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-4o-mini, gpt-o3, gpt-o4-mini, gpt-5",
+            loginCmd: "/chatgpt-login",
+            expiry: () => { const e = loadChatGPTExpiry(); return e ? formatChatGPTExpiry(e) : null; },
+          },
         ];
 
         for (const c of checks) {
@@ -1497,6 +2012,12 @@ const plugin = {
       "/gemini-login",
       "/gemini-status",
       "/gemini-logout",
+      "/claude-login",
+      "/claude-status",
+      "/claude-logout",
+      "/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,8 @@
 {
   "id": "openclaw-cli-bridge-elvatis",
   "name": "OpenClaw CLI Bridge",
-  "version": "1.5.0",
+  "version": "1.6.1",
+  "license": "MIT",
   "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.5.0",
+  "version": "1.6.1",
   "description": "Bridges gemini, claude, and codex CLI tools as OpenClaw model providers. Reads existing CLI auth without re-login.",
   "type": "module",
   "openclaw": {
@@ -9,7 +9,7 @@
     ]
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc --noEmitOnError false",
     "typecheck": "tsc -p tsconfig.check.json",
     "test": "vitest run",
     "ci": "npm run typecheck && npm run test"

package/src/proxy-server.ts

@@ -14,6 +14,8 @@ import { type ChatMessage, routeToCliRunner } from "./cli-runner.js";
 import { scheduleTokenRefresh, setAuthLogger, stopTokenRefresh } from "./claude-auth.js";
 import { grokComplete, grokCompleteStream, type ChatMessage as GrokChatMessage } from "./grok-client.js";
 import { geminiComplete, geminiCompleteStream, type ChatMessage as GeminiBrowserChatMessage } from "./gemini-browser.js";
+import { claudeComplete, claudeCompleteStream, type ChatMessage as ClaudeBrowserChatMessage } from "./claude-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];
@@ -42,6 +44,22 @@ export interface ProxyServerOptions {
   _geminiComplete?: typeof geminiComplete;
   /** Override for testing — replaces geminiCompleteStream */
   _geminiCompleteStream?: typeof geminiCompleteStream;
+  /** Returns the current authenticated Claude BrowserContext (null if not logged in) */
+  getClaudeContext?: () => BrowserContext | null;
+  /** Async lazy connect — called when getClaudeContext returns null */
+  connectClaudeContext?: () => Promise<BrowserContext | null>;
+  /** Override for testing — replaces claudeComplete */
+  _claudeComplete?: typeof claudeComplete;
+  /** Override for testing — replaces claudeCompleteStream */
+  _claudeCompleteStream?: typeof claudeCompleteStream;
+  /** Returns the current authenticated ChatGPT BrowserContext (null if not logged in) */
+  getChatGPTContext?: () => BrowserContext | null;
+  /** Async lazy connect — called when getChatGPTContext returns null */
+  connectChatGPTContext?: () => Promise<BrowserContext | null>;
+  /** Override for testing — replaces chatgptComplete */
+  _chatgptComplete?: typeof chatgptComplete;
+  /** Override for testing — replaces chatgptCompleteStream */
+  _chatgptCompleteStream?: typeof chatgptCompleteStream;
 }
 
 /** Available CLI bridge models for GET /v1/models */
@@ -64,6 +82,16 @@ 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 },
+  // Claude web-session models (requires /claude-login)
+  { id: "web-claude/claude-sonnet",     name: "Claude Sonnet (web session)",     contextWindow: 200_000, maxTokens: 8192 },
+  { id: "web-claude/claude-opus",       name: "Claude Opus (web session)",       contextWindow: 200_000, maxTokens: 8192 },
+  { id: "web-claude/claude-haiku",      name: "Claude Haiku (web session)",      contextWindow: 200_000, maxTokens: 8192 },
+  // ChatGPT web-session models (requires /chatgpt-login)
+  { id: "web-chatgpt/gpt-4o",           name: "GPT-4o (web session)",            contextWindow: 128_000, maxTokens: 8192 },
+  { id: "web-chatgpt/gpt-4o-mini",      name: "GPT-4o Mini (web session)",       contextWindow: 128_000, maxTokens: 8192 },
+  { id: "web-chatgpt/gpt-o3",           name: "GPT o3 (web session)",            contextWindow: 200_000, maxTokens: 8192 },
+  { id: "web-chatgpt/gpt-o4-mini",      name: "GPT o4-mini (web session)",       contextWindow: 200_000, maxTokens: 8192 },
+  { id: "web-chatgpt/gpt-5",            name: "GPT-5 (web session)",             contextWindow: 200_000, maxTokens: 8192 },
 ];
 
 // ──────────────────────────────────────────────────────────────────────────────
@@ -284,6 +312,105 @@ async function handleRequest(
     }
     // ─────────────────────────────────────────────────────────────────────────
 
+    // ── Claude web-session routing ────────────────────────────────────────────
+    if (model.startsWith("web-claude/")) {
+      let claudeCtx = opts.getClaudeContext?.() ?? null;
+      if (!claudeCtx && opts.connectClaudeContext) {
+        claudeCtx = await opts.connectClaudeContext();
+      }
+      if (!claudeCtx) {
+        res.writeHead(503, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: { message: "No active claude.ai session. Use /claude-login to authenticate.", code: "no_claude_session" } }));
+        return;
+      }
+      const timeoutMs = opts.timeoutMs ?? 120_000;
+      const claudeMessages = messages as ClaudeBrowserChatMessage[];
+      const doClaudeComplete = opts._claudeComplete ?? claudeComplete;
+      const doClaudeCompleteStream = opts._claudeCompleteStream ?? claudeCompleteStream;
+      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 doClaudeCompleteStream(
+            claudeCtx,
+            { messages: claudeMessages, 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 doClaudeComplete(claudeCtx, { messages: claudeMessages, 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] Claude browser error for ${model}: ${msg}`);
+        if (!res.headersSent) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: { message: msg, type: "claude_browser_error" } }));
+        }
+      }
+      return;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+
+    // ── 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 chatgptModel = model.replace("web-chatgpt/", "");
+      const timeoutMs = opts.timeoutMs ?? 120_000;
+      const chatgptMessages = messages as ChatGPTBrowserChatMessage[];
+      const doChatGPTComplete = opts._chatgptComplete ?? chatgptComplete;
+      const doChatGPTCompleteStream = 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 doChatGPTCompleteStream(
+            chatgptCtx,
+            { messages: chatgptMessages, model: chatgptModel, 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 doChatGPTComplete(chatgptCtx, { messages: chatgptMessages, model: chatgptModel, 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,153 @@
+/**
+ * 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 ChatGPTCompleteOptions = { messages: { role: string; content: string }[]; model?: string; timeoutMs?: number };
+type ChatGPTCompleteResult = { content: string; model: string; finishReason: string };
+
+const stubChatGPTComplete = vi.fn(async (
+  _ctx: BrowserContext,
+  opts: ChatGPTCompleteOptions,
+  _log: (msg: string) => void
+): Promise<ChatGPTCompleteResult> => ({
+  content: `chatgpt mock: ${opts.messages[opts.messages.length - 1]?.content ?? ""}`,
+  model: opts.model ?? "gpt-4o",
+  finishReason: "stop",
+}));
+
+const stubChatGPTCompleteStream = vi.fn(async (
+  _ctx: BrowserContext,
+  opts: ChatGPTCompleteOptions,
+  onToken: (t: string) => void,
+  _log: (msg: string) => void
+): Promise<ChatGPTCompleteResult> => {
+  const tokens = ["chatgpt ", "stream ", "mock"];
+  for (const t of tokens) onToken(t);
+  return { content: tokens.join(""), model: opts.model ?? "gpt-4o", finishReason: "stop" };
+});
+
+async function httpPost(url: string, body: unknown): Promise<{ status: number; body: unknown }> {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const u = new URL(url);
+    const req = http.request(
+      { hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data) } },
+      (res) => { let raw = ""; res.on("data", c => raw += c); res.on("end", () => { try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(raw) }); } catch { resolve({ status: res.statusCode ?? 0, body: raw }); } }); }
+    );
+    req.on("error", reject); req.write(data); req.end();
+  });
+}
+async function httpGet(url: string): Promise<{ status: number; body: unknown }> {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const req = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "GET" },
+      (res) => { let raw = ""; res.on("data", c => raw += c); res.on("end", () => { try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(raw) }); } catch { resolve({ status: res.statusCode ?? 0, body: raw }); } }); }
+    );
+    req.on("error", reject); req.end();
+  });
+}
+
+const fakeCtx = {} as BrowserContext;
+let server: http.Server;
+let baseUrl: string;
+
+beforeAll(async () => {
+  server = await startProxyServer({
+    port: 0, log: () => {}, warn: () => {},
+    getChatGPTContext: () => fakeCtx,
+    // @ts-expect-error — stub types close enough for testing
+    _chatgptComplete: stubChatGPTComplete,
+    // @ts-expect-error — stub types close enough for testing
+    _chatgptCompleteStream: stubChatGPTCompleteStream,
+  });
+  baseUrl = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+});
+afterAll(() => server.close());
+
+describe("ChatGPT web-session routing — model list", () => {
+  it("includes web-chatgpt/* models in /v1/models", async () => {
+    const res = await httpGet(`${baseUrl}/v1/models`);
+    expect(res.status).toBe(200);
+    const ids = (res.body as { data: { id: string }[] }).data.map(m => m.id);
+    expect(ids).toContain("web-chatgpt/gpt-4o");
+    expect(ids).toContain("web-chatgpt/gpt-4o-mini");
+    expect(ids).toContain("web-chatgpt/gpt-o3");
+    expect(ids).toContain("web-chatgpt/gpt-o4-mini");
+    expect(ids).toContain("web-chatgpt/gpt-5");
+  });
+
+  it("web-chatgpt/* models listed in CLI_MODELS constant", () => {
+    const chatgpt = CLI_MODELS.filter(m => m.id.startsWith("web-chatgpt/"));
+    expect(chatgpt).toHaveLength(5);
+  });
+});
+
+describe("ChatGPT web-session routing — non-streaming", () => {
+  it("returns assistant message for web-chatgpt/gpt-4o", async () => {
+    const res = await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "web-chatgpt/gpt-4o",
+      messages: [{ role: "user", content: "hello chatgpt" }],
+      stream: false,
+    });
+    expect(res.status).toBe(200);
+    const body = res.body as { choices: { message: { content: string } }[] };
+    expect(body.choices[0].message.content).toContain("chatgpt mock");
+    expect(body.choices[0].message.content).toContain("hello chatgpt");
+  });
+
+  it("strips web-chatgpt/ prefix before passing to chatgptComplete", async () => {
+    stubChatGPTComplete.mockClear();
+    await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "web-chatgpt/gpt-o3",
+      messages: [{ role: "user", content: "test" }],
+    });
+    expect(stubChatGPTComplete).toHaveBeenCalledOnce();
+    expect(stubChatGPTComplete.mock.calls[0][1].model).toBe("gpt-o3");
+  });
+
+  it("response model preserves web-chatgpt/ prefix", async () => {
+    const res = await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "web-chatgpt/gpt-5",
+      messages: [{ role: "user", content: "hi" }],
+    });
+    expect(res.status).toBe(200);
+    const body = res.body as { model: string };
+    expect(body.model).toBe("web-chatgpt/gpt-5");
+  });
+
+  it("returns 503 when no chatgpt context", async () => {
+    const s = await startProxyServer({ port: 0, log: () => {}, warn: () => {}, getChatGPTContext: () => null });
+    const url = `http://127.0.0.1:${(s.address() as AddressInfo).port}`;
+    const res = await httpPost(`${url}/v1/chat/completions`, {
+      model: "web-chatgpt/gpt-4o",
+      messages: [{ role: "user", content: "hi" }],
+    });
+    expect(res.status).toBe(503);
+    expect((res.body as { error: { code: string } }).error.code).toBe("no_chatgpt_session");
+    s.close();
+  });
+});
+
+describe("ChatGPT web-session routing — streaming", () => {
+  it("returns SSE stream", async () => {
+    return new Promise<void>((resolve, reject) => {
+      const body = JSON.stringify({ model: "web-chatgpt/gpt-4o", messages: [{ role: "user", content: "stream" }], stream: true });
+      const u = new URL(`${baseUrl}/v1/chat/completions`);
+      const req = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } },
+        (res) => { expect(res.statusCode).toBe(200); let raw = ""; res.on("data", c => raw += c); res.on("end", () => { expect(raw).toContain("[DONE]"); resolve(); }); }
+      );
+      req.on("error", reject); req.write(body); req.end();
+    });
+  });
+});

package/test/claude-proxy.test.ts

@@ -0,0 +1,140 @@
+/**
+ * test/claude-proxy.test.ts
+ *
+ * Tests for Claude web-session routing in the cli-bridge proxy.
+ * Uses _claudeComplete/_claudeCompleteStream 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 ClaudeCompleteOptions = { messages: { role: string; content: string }[]; model?: string; timeoutMs?: number };
+type ClaudeCompleteResult = { content: string; model: string; finishReason: string };
+
+const stubClaudeComplete = vi.fn(async (
+  _ctx: BrowserContext,
+  opts: ClaudeCompleteOptions,
+  _log: (msg: string) => void
+): Promise<ClaudeCompleteResult> => ({
+  content: `claude mock: ${opts.messages[opts.messages.length - 1]?.content ?? ""}`,
+  model: opts.model ?? "web-claude/claude-sonnet",
+  finishReason: "stop",
+}));
+
+const stubClaudeCompleteStream = vi.fn(async (
+  _ctx: BrowserContext,
+  opts: ClaudeCompleteOptions,
+  onToken: (t: string) => void,
+  _log: (msg: string) => void
+): Promise<ClaudeCompleteResult> => {
+  const tokens = ["claude ", "stream ", "mock"];
+  for (const t of tokens) onToken(t);
+  return { content: tokens.join(""), model: opts.model ?? "web-claude/claude-sonnet", finishReason: "stop" };
+});
+
+async function httpPost(url: string, body: unknown): Promise<{ status: number; body: unknown }> {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const u = new URL(url);
+    const req = http.request(
+      { hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data) } },
+      (res) => { let raw = ""; res.on("data", c => raw += c); res.on("end", () => { try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(raw) }); } catch { resolve({ status: res.statusCode ?? 0, body: raw }); } }); }
+    );
+    req.on("error", reject); req.write(data); req.end();
+  });
+}
+async function httpGet(url: string): Promise<{ status: number; body: unknown }> {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const req = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "GET" },
+      (res) => { let raw = ""; res.on("data", c => raw += c); res.on("end", () => { try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(raw) }); } catch { resolve({ status: res.statusCode ?? 0, body: raw }); } }); }
+    );
+    req.on("error", reject); req.end();
+  });
+}
+
+const fakeCtx = {} as BrowserContext;
+let server: http.Server;
+let baseUrl: string;
+
+beforeAll(async () => {
+  server = await startProxyServer({
+    port: 0, log: () => {}, warn: () => {},
+    getClaudeContext: () => fakeCtx,
+    // @ts-expect-error — stub types close enough for testing
+    _claudeComplete: stubClaudeComplete,
+    // @ts-expect-error — stub types close enough for testing
+    _claudeCompleteStream: stubClaudeCompleteStream,
+  });
+  baseUrl = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+});
+afterAll(() => server.close());
+
+describe("Claude web-session routing — model list", () => {
+  it("includes web-claude/* models in /v1/models", async () => {
+    const res = await httpGet(`${baseUrl}/v1/models`);
+    expect(res.status).toBe(200);
+    const ids = (res.body as { data: { id: string }[] }).data.map(m => m.id);
+    expect(ids).toContain("web-claude/claude-sonnet");
+    expect(ids).toContain("web-claude/claude-opus");
+    expect(ids).toContain("web-claude/claude-haiku");
+  });
+
+  it("web-claude/* models listed in CLI_MODELS constant", () => {
+    expect(CLI_MODELS.some(m => m.id.startsWith("web-claude/"))).toBe(true);
+  });
+});
+
+describe("Claude web-session routing — non-streaming", () => {
+  it("returns assistant message for web-claude/claude-sonnet", async () => {
+    const res = await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "web-claude/claude-sonnet",
+      messages: [{ role: "user", content: "hello claude" }],
+      stream: false,
+    });
+    expect(res.status).toBe(200);
+    const body = res.body as { choices: { message: { content: string } }[] };
+    expect(body.choices[0].message.content).toContain("claude mock");
+    expect(body.choices[0].message.content).toContain("hello claude");
+  });
+
+  it("passes model to stub unchanged", async () => {
+    stubClaudeComplete.mockClear();
+    await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "web-claude/claude-opus",
+      messages: [{ role: "user", content: "test" }],
+    });
+    expect(stubClaudeComplete).toHaveBeenCalledOnce();
+    expect(stubClaudeComplete.mock.calls[0][1].model).toBe("web-claude/claude-opus");
+  });
+
+  it("returns 503 when no claude context", async () => {
+    const s = await startProxyServer({ port: 0, log: () => {}, warn: () => {}, getClaudeContext: () => null });
+    const url = `http://127.0.0.1:${(s.address() as AddressInfo).port}`;
+    const res = await httpPost(`${url}/v1/chat/completions`, {
+      model: "web-claude/claude-sonnet",
+      messages: [{ role: "user", content: "hi" }],
+    });
+    expect(res.status).toBe(503);
+    expect((res.body as { error: { code: string } }).error.code).toBe("no_claude_session");
+    s.close();
+  });
+});
+
+describe("Claude web-session routing — streaming", () => {
+  it("returns SSE stream", async () => {
+    return new Promise<void>((resolve, reject) => {
+      const body = JSON.stringify({ model: "web-claude/claude-sonnet", messages: [{ role: "user", content: "stream" }], stream: true });
+      const u = new URL(`${baseUrl}/v1/chat/completions`);
+      const req = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } },
+        (res) => { expect(res.statusCode).toBe(200); let raw = ""; res.on("data", c => raw += c); res.on("end", () => { expect(raw).toContain("[DONE]"); resolve(); }); }
+      );
+      req.on("error", reject); req.write(body); req.end();
+    });
+  });
+});