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

package/index.ts

@@ -85,8 +85,18 @@ interface CliPluginConfig {
 let grokBrowser: Browser | null = null;
 let grokContext: BrowserContext | null = null;
 
-// Persistent profile dir — survives gateway restarts, keeps cookies intact
+// 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");
+
+// Stealth launch options — prevent Cloudflare/bot detection from flagging the browser
+const STEALTH_ARGS = [
+  "--no-sandbox",
+  "--disable-setuid-sandbox",
+  "--disable-blink-features=AutomationControlled",
+  "--disable-infobars",
+];
+const STEALTH_IGNORE_DEFAULTS = ["--enable-automation"] as const;
 
 // ── Gemini web-session state ──────────────────────────────────────────────────
 let geminiContext: BrowserContext | null = null;
@@ -120,68 +130,6 @@ 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");
-
-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", "https://anthropic.com"]);
-    const authCookies = cookies.filter(c => ["sessionKey", "intercom-session-igviqkfk"].includes(c.name) && c.expires && c.expires > 0);
-    if (!authCookies.length) return null;
-    authCookies.sort((a, b) => (a.expires ?? 0) - (b.expires ?? 0));
-    const earliest = authCookies[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
 const GROK_EXPIRY_FILE = join(homedir(), ".openclaw", "grok-cookie-expiry.json");
 
@@ -233,6 +181,10 @@ async function scanCookieExpiry(ctx: import("playwright").BrowserContext): Promi
 let _cdpBrowser: import("playwright").Browser | null = null;
 let _cdpBrowserLaunchPromise: Promise<import("playwright").BrowserContext | null> | null = null;
 
+// Startup restore guard — module-level so it survives hot-reloads (SIGUSR1).
+// Set to true after first run; hot-reloads see true and skip the restore loop.
+let _startupRestoreDone = false;
+
 /**
  * Connect to the OpenClaw managed browser (CDP port 18800).
  * Singleton: reuses the same connection. Falls back to persistent Chromium for Grok only.
@@ -289,7 +241,9 @@ async function getOrLaunchGrokContext(
     try {
       const ctx = await chromium.launchPersistentContext(GROK_PROFILE_DIR, {
         headless: true,
-        args: ["--no-sandbox", "--disable-setuid-sandbox"],
+        channel: "chrome",
+        args: STEALTH_ARGS,
+        ignoreDefaultArgs: [...STEALTH_IGNORE_DEFAULTS],
       });
       grokContext = ctx;
       // Auto-cleanup on browser crash
@@ -306,19 +260,57 @@ async function getOrLaunchGrokContext(
   return _cdpBrowserLaunchPromise;
 }
 
+// ── Per-provider persistent context launch promises (coalesce concurrent calls) ──
+let _geminiLaunchPromise: Promise<BrowserContext | null> | null = null;
+
+async function getOrLaunchGeminiContext(
+  log: (msg: string) => void
+): Promise<BrowserContext | null> {
+  if (geminiContext) {
+    try { geminiContext.pages(); return geminiContext; } catch { geminiContext = null; }
+  }
+  const cdpCtx = await connectToOpenClawBrowser(log);
+  if (cdpCtx) return cdpCtx;
+  if (_geminiLaunchPromise) return _geminiLaunchPromise;
+  _geminiLaunchPromise = (async () => {
+    const { chromium } = await import("playwright");
+    log("[cli-bridge:gemini] launching persistent Chromium…");
+    try {
+      mkdirSync(GEMINI_PROFILE_DIR, { recursive: true });
+      const ctx = await chromium.launchPersistentContext(GEMINI_PROFILE_DIR, {
+        headless: true,
+        channel: "chrome",
+        args: STEALTH_ARGS,
+        ignoreDefaultArgs: [...STEALTH_IGNORE_DEFAULTS],
+      });
+      geminiContext = ctx;
+      ctx.on("close", () => { geminiContext = null; log("[cli-bridge:gemini] persistent context closed"); });
+      log("[cli-bridge:gemini] persistent context ready");
+      return ctx;
+    } catch (err) {
+      log(`[cli-bridge:gemini] failed to launch browser: ${(err as Error).message}`);
+      return null;
+    } finally {
+      _geminiLaunchPromise = null;
+    }
+  })();
+  return _geminiLaunchPromise;
+}
+
 /** Clean up all browser resources — call on plugin teardown */
 async function cleanupBrowsers(log: (msg: string) => void): Promise<void> {
   if (grokContext) {
     try { await grokContext.close(); } catch { /* ignore */ }
     grokContext = null;
   }
+  if (geminiContext) {
+    try { await geminiContext.close(); } catch { /* ignore */ }
+    geminiContext = null;
+  }
   if (_cdpBrowser) {
     try { await _cdpBrowser.close(); } catch { /* ignore */ }
     _cdpBrowser = null;
   }
-  claudeContext = null;
-  geminiContext = null;
-  chatgptContext = null;
   log("[cli-bridge] browser resources cleaned up");
 }
 
@@ -360,14 +352,6 @@ async function _doEnsureAllProviderContexts(log: (msg: string) => void): Promise
 
   // For each provider: if no context yet, try shared ctx or launch own persistent context
   const providerConfigs = [
-    {
-      name: "claude",
-      profileDir: join(homedir(), ".openclaw", "claude-profile"),
-      getCtx: () => claudeContext,
-      setCtx: (c: BrowserContext) => { claudeContext = c; },
-      homeUrl: "https://claude.ai/new",
-      verifySelector: ".ProseMirror",
-    },
     {
       name: "gemini",
       profileDir: join(homedir(), ".openclaw", "gemini-profile"),
@@ -376,14 +360,6 @@ async function _doEnsureAllProviderContexts(log: (msg: string) => void): Promise
       homeUrl: "https://gemini.google.com/app",
       verifySelector: ".ql-editor",
     },
-    {
-      name: "chatgpt",
-      profileDir: join(homedir(), ".openclaw", "chatgpt-profile"),
-      getCtx: () => chatgptContext,
-      setCtx: (c: BrowserContext) => { chatgptContext = c; },
-      homeUrl: "https://chatgpt.com",
-      verifySelector: "#prompt-textarea",
-    },
   ];
 
   for (const cfg of providerConfigs) {
@@ -415,7 +391,9 @@ async function _doEnsureAllProviderContexts(log: (msg: string) => void): Promise
         mkdirSync(cfg.profileDir, { recursive: true });
         const pCtx = await chromium.launchPersistentContext(cfg.profileDir, {
           headless: true,
-          args: ["--no-sandbox", "--disable-setuid-sandbox"],
+          channel: "chrome",
+          args: STEALTH_ARGS,
+          ignoreDefaultArgs: [...STEALTH_IGNORE_DEFAULTS],
         });
         const page = await pCtx.newPage();
         await page.goto(cfg.homeUrl, { waitUntil: "domcontentloaded", timeout: 15_000 });
@@ -746,97 +724,84 @@ const plugin = {
     const codexAuthPath = cfg.codexAuthPath ?? DEFAULT_CODEX_AUTH_PATH;
     const grokSessionPath = cfg.grokSessionPath ?? DEFAULT_SESSION_PATH;
 
-    // ── Safe session restore on startup (sequential, profile-gated, non-blocking) ──
-    // Restores provider sessions from saved persistent profiles — but ONLY if the
-    // profile directory already exists (i.e. user has logged in before).
-    // Providers are launched one at a time with a delay to avoid OOM.
-    void (async () => {
-      await new Promise(r => setTimeout(r, 5000)); // wait for proxy + gateway to settle
-      const { chromium } = await import("playwright");
-      const { existsSync } = await import("node:fs");
-
-      const profileProviders: Array<{
-        name: string;
-        profileDir: string;
-        cookieFile: string;
-        verifySelector: string;
-        homeUrl: string;
-        setCtx: (c: BrowserContext) => void;
-        getCtx: () => BrowserContext | null;
-      }> = [
-        {
-          name: "grok",
-          profileDir: GROK_PROFILE_DIR,
-          cookieFile: join(homedir(), ".openclaw", "grok-session.json"),
-          verifySelector: "textarea",
-          homeUrl: "https://grok.com",
-          getCtx: () => grokContext,
-          setCtx: (c) => { grokContext = c; },
-        },
-        {
-          name: "claude",
-          profileDir: join(homedir(), ".openclaw", "claude-profile"),
-          cookieFile: join(homedir(), ".openclaw", "claude-cookie-expiry.json"),
-          verifySelector: ".ProseMirror",
-          homeUrl: "https://claude.ai/new",
-          getCtx: () => claudeContext,
-          setCtx: (c) => { claudeContext = c; },
-        },
-        {
-          name: "gemini",
-          profileDir: join(homedir(), ".openclaw", "gemini-profile"),
-          cookieFile: join(homedir(), ".openclaw", "gemini-cookie-expiry.json"),
-          verifySelector: ".ql-editor",
-          homeUrl: "https://gemini.google.com/app",
-          getCtx: () => geminiContext,
-          setCtx: (c) => { geminiContext = c; },
-        },
-        {
-          name: "chatgpt",
-          profileDir: join(homedir(), ".openclaw", "chatgpt-profile"),
-          cookieFile: join(homedir(), ".openclaw", "chatgpt-cookie-expiry.json"),
-          verifySelector: "#prompt-textarea",
-          homeUrl: "https://chatgpt.com",
-          getCtx: () => chatgptContext,
-          setCtx: (c) => { chatgptContext = c; },
-        },
-      ];
+    // ── Session restore: only on first plugin load (not on hot-reloads) ──────
+    // The gateway polls every ~60s via openclaw status, which triggers a hot-reload
+    // (SIGUSR1 + hybrid mode). Module-level contexts (grokContext etc.) survive
+    // hot-reloads because Node keeps the module in memory — so we only need to
+    // restore once, on the very first load (when all contexts are null).
+    //
+    // Guard: _startupRestoreDone is module-level and persists across hot-reloads.
+    if (!_startupRestoreDone) {
+      _startupRestoreDone = true;
+      void (async () => {
+        await new Promise(r => setTimeout(r, 5000)); // wait for proxy + gateway to settle
+        const { chromium } = await import("playwright");
+        const { existsSync } = await import("node:fs");
+
+        const profileProviders: Array<{
+          name: string;
+          profileDir: string;
+          cookieFile: string;
+          verifySelector: string;
+          homeUrl: string;
+          setCtx: (c: BrowserContext) => void;
+          getCtx: () => BrowserContext | null;
+        }> = [
+          {
+            name: "grok",
+            profileDir: GROK_PROFILE_DIR,
+            cookieFile: join(homedir(), ".openclaw", "grok-session.json"),
+            verifySelector: "textarea",
+            homeUrl: "https://grok.com",
+            getCtx: () => grokContext,
+            setCtx: (c) => { grokContext = c; },
+          },
+          {
+            name: "gemini",
+            profileDir: join(homedir(), ".openclaw", "gemini-profile"),
+            cookieFile: join(homedir(), ".openclaw", "gemini-cookie-expiry.json"),
+            verifySelector: ".ql-editor",
+            homeUrl: "https://gemini.google.com/app",
+            getCtx: () => geminiContext,
+            setCtx: (c) => { geminiContext = c; },
+          },
+        ];
 
-      for (const p of profileProviders) {
-        // Skip if no saved profile/session exists
-        if (!existsSync(p.profileDir) && !existsSync(p.cookieFile)) {
-          api.logger.info(`[cli-bridge:${p.name}] no saved profile — skipping startup restore`);
-          continue;
-        }
-        if (p.getCtx()) continue; // already connected
+        for (const p of profileProviders) {
+          if (!existsSync(p.profileDir) && !existsSync(p.cookieFile)) {
+            api.logger.info(`[cli-bridge:${p.name}] no saved profile — skipping startup restore`);
+            continue;
+          }
+          if (p.getCtx()) continue; // already connected
 
-        try {
-          api.logger.info(`[cli-bridge:${p.name}] restoring session from profile…`);
-          const ctx = await chromium.launchPersistentContext(p.profileDir, {
-            headless: true,
-            args: ["--no-sandbox", "--disable-setuid-sandbox"],
-          });
-          const page = await ctx.newPage();
-          await page.goto(p.homeUrl, { waitUntil: "domcontentloaded", timeout: 20_000 });
-          await new Promise(r => setTimeout(r, 3000));
-          const ok = await page.locator(p.verifySelector).isVisible().catch(() => false);
-          await page.close().catch(() => {});
-          if (ok) {
-            p.setCtx(ctx);
-            ctx.on("close", () => { p.setCtx(null as unknown as BrowserContext); });
-            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 — skipping`);
+          try {
+            api.logger.info(`[cli-bridge:${p.name}] restoring session from profile…`);
+            const ctx = await chromium.launchPersistentContext(p.profileDir, {
+              headless: true,
+              args: ["--no-sandbox", "--disable-setuid-sandbox"],
+            });
+            const page = await ctx.newPage();
+            await page.goto(p.homeUrl, { waitUntil: "domcontentloaded", timeout: 20_000 });
+            await new Promise(r => setTimeout(r, 3000));
+            const ok = await page.locator(p.verifySelector).isVisible().catch(() => false);
+            await page.close().catch(() => {});
+            if (ok) {
+              p.setCtx(ctx);
+              ctx.on("close", () => { p.setCtx(null as unknown as BrowserContext); });
+              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`);
+            }
+          } catch (err) {
+            api.logger.warn(`[cli-bridge:${p.name}] startup restore failed: ${(err as Error).message}`);
           }
-        } catch (err) {
-          api.logger.warn(`[cli-bridge:${p.name}] startup restore failed: ${(err as Error).message}`);
-        }
 
-        // Sequential delay — avoid spawning all 4 Chromium instances at once
-        await new Promise(r => setTimeout(r, 3000));
-      }
-    })();
+          // Sequential — never spawn all 4 Chromium instances at once
+          await new Promise(r => setTimeout(r, 3000));
+        }
+      })();
+    }
 
     // ── Phase 1: openai-codex auth bridge ─────────────────────────────────────
     if (enableCodex) {
@@ -935,49 +900,24 @@ const plugin = {
             warn: (msg) => api.logger.warn(msg),
             getGrokContext: () => grokContext,
             connectGrokContext: async () => {
-              const ctx = await connectToOpenClawBrowser((msg) => api.logger.info(msg));
+              const ctx = await getOrLaunchGrokContext((msg) => api.logger.info(msg));
               if (ctx) {
                 const check = await verifySession(ctx, (msg) => api.logger.info(msg));
                 if (check.valid) { grokContext = ctx; return ctx; }
               }
               return null;
             },
-            getClaudeContext: () => claudeContext,
-            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) { claudeContext = ctx; return ctx; }
-              }
-              // No fallback spawn — return existing context or null to avoid Chromium leak
-              return claudeContext;
-            },
             getGeminiContext: () => geminiContext,
             connectGeminiContext: async () => {
-              const ctx = await connectToOpenClawBrowser((msg) => api.logger.info(msg));
+              const ctx = await getOrLaunchGeminiContext((msg) => api.logger.info(msg));
               if (ctx) {
                 const { getOrCreateGeminiPage } = await import("./src/gemini-browser.js");
                 const { page } = await getOrCreateGeminiPage(ctx);
                 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;
             },
-            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; }
-              }
-              // No fallback spawn — return existing context or null to avoid Chromium leak
-              return chatgptContext;
-            },
           });
           proxyServer = server;
           api.logger.info(
@@ -1010,18 +950,6 @@ const plugin = {
                   }
                   return null;
                 },
-                getClaudeContext: () => claudeContext,
-                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) { claudeContext = ctx; return ctx; }
-                  }
-                  // No fallback spawn — return existing context or null to avoid Chromium leak
-                  return claudeContext;
-                },
                 getGeminiContext: () => geminiContext,
                 connectGeminiContext: async () => {
                   const ctx = await connectToOpenClawBrowser((msg) => api.logger.info(msg));
@@ -1034,18 +962,6 @@ const plugin = {
                   // No fallback spawn — return existing context or null to avoid Chromium leak
                   return geminiContext;
                 },
-                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; }
-                  }
-                  // No fallback spawn — return existing context or null to avoid Chromium leak
-                  return chatgptContext;
-                },
               });
               proxyServer = server;
               api.logger.info(`[cli-bridge] proxy ready on :${port} (retry)`);
@@ -1386,107 +1302,6 @@ const plugin = {
       },
     } satisfies OpenClawPluginCommandDefinition);
 
-    // ── Claude web-session commands ───────────────────────────────────────────
-    api.registerCommand({
-      name: "claude-login",
-      description: "Authenticate claude.ai: imports session from OpenClaw browser",
-      handler: async (): Promise<PluginCommandResult> => {
-        if (claudeContext) {
-          const { getOrCreateClaudePage } = await import("./src/claude-browser.js");
-          try {
-            const { page } = await getOrCreateClaudePage(claudeContext);
-            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 */ }
-          claudeContext = null;
-        }
-
-        api.logger.info("[cli-bridge:claude] /claude-login: connecting to OpenClaw browser…");
-
-        // Connect to OpenClaw browser context for session (singleton CDP)
-        const ctx = await connectToOpenClawBrowser((msg) => api.logger.info(msg));
-        if (!ctx) return { text: "❌ Could not connect to OpenClaw browser.\nMake sure claude.ai is open in your browser." };
-
-        // Navigate to claude.ai/new if not already there
-        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}` };
-        }
-
-        // Verify editor is visible
-        const editor = await page.locator(".ProseMirror").isVisible().catch(() => false);
-        if (!editor) {
-          return { text: "❌ claude.ai editor not visible — are you logged in?\nOpen claude.ai in your browser and try again." };
-        }
-
-        claudeContext = ctx;
-
-        // Export + bake cookies into persistent profile
-        const claudeProfileDir = join(homedir(), ".openclaw", "claude-profile");
-        mkdirSync(claudeProfileDir, { recursive: true });
-        try {
-          const allCookies = await ctx.cookies([
-            "https://claude.ai",
-            "https://anthropic.com",
-          ]);
-          const { chromium } = await import("playwright");
-          const pCtx = await chromium.launchPersistentContext(claudeProfileDir, {
-            headless: true,
-            args: ["--no-sandbox", "--disable-setuid-sandbox"],
-          });
-          await pCtx.addCookies(allCookies);
-          await pCtx.close();
-          api.logger.info(`[cli-bridge:claude] cookies baked into ${claudeProfileDir}`);
-        } catch (err) {
-          api.logger.warn(`[cli-bridge:claude] cookie bake failed: ${(err as Error).message}`);
-        }
-
-        // Scan cookie expiry
-        const expiry = await scanClaudeCookieExpiry(ctx);
-        if (expiry) {
-          saveClaudeExpiry(expiry);
-          api.logger.info(`[cli-bridge:claude] 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 (!claudeContext) {
-          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(claudeContext);
-          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, web-claude/claude-opus, web-claude/claude-haiku${expiryLine}` };
-          }
-        } catch { /* fall through */ }
-        claudeContext = 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> => {
-        claudeContext = null;
-        return { text: "✅ Disconnected from claude.ai. Run `/claude-login` to reconnect." };
-      },
-    } satisfies OpenClawPluginCommandDefinition);
-
     // ── Gemini web-session commands ───────────────────────────────────────────
     api.registerCommand({
       name: "gemini-login",
@@ -1502,10 +1317,34 @@ const plugin = {
           geminiContext = null;
         }
 
-        api.logger.info("[cli-bridge:gemini] /gemini-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 gemini.google.com is open in your browser." };
+        api.logger.info("[cli-bridge:gemini] /gemini-login: connecting…");
+
+        // Step 1: try to grab cookies from OpenClaw browser (CDP) if available
+        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://gemini.google.com", "https://accounts.google.com", "https://google.com"]);
+            api.logger.info(`[cli-bridge:gemini] imported ${importedCookies.length} cookies from OpenClaw browser`);
+          }
+          await ocBrowser.close().catch(() => {});
+        } catch {
+          api.logger.info("[cli-bridge:gemini] OpenClaw browser not available — using saved profile");
+        }
+
+        // Step 2: get or launch persistent context
+        const ctx = await getOrLaunchGeminiContext((msg) => api.logger.info(msg));
+        if (!ctx) return { text: "❌ Could not launch browser. Check server logs." };
 
+        // Step 3: inject imported cookies if available
+        if (importedCookies.length > 0) {
+          await ctx.addCookies(importedCookies as Parameters<typeof ctx.addCookies>[0]);
+          api.logger.info("[cli-bridge:gemini] cookies injected into persistent profile");
+        }
+
+        // Step 4: navigate and verify
         const { getOrCreateGeminiPage } = await import("./src/gemini-browser.js");
         let page;
         try {
@@ -1514,35 +1353,40 @@ const plugin = {
           return { text: `❌ Failed to open gemini.google.com: ${(err as Error).message}` };
         }
 
-        const editor = await page.locator(".ql-editor").isVisible().catch(() => false);
+        let editor = await page.locator(".ql-editor").isVisible().catch(() => false);
         if (!editor) {
-          return { text: "❌ Gemini editor not visible — are you logged in?\nOpen gemini.google.com in your browser and try again." };
-        }
-
-        geminiContext = ctx;
+          // Headless failed — launch headed browser for interactive login
+          api.logger.info("[cli-bridge:gemini] headless login failed — launching headed browser for manual login…");
+          try { await ctx.close(); } catch { /* ignore */ }
+          geminiContext = null;
 
-        // Export + bake cookies into persistent profile
-        const geminiProfileDir = join(homedir(), ".openclaw", "gemini-profile");
-        mkdirSync(geminiProfileDir, { recursive: true });
-        try {
-          const allCookies = await ctx.cookies([
-            "https://gemini.google.com",
-            "https://accounts.google.com",
-            "https://google.com",
-          ]);
           const { chromium } = await import("playwright");
-          const pCtx = await chromium.launchPersistentContext(geminiProfileDir, {
-            headless: true,
-            args: ["--no-sandbox", "--disable-setuid-sandbox"],
+          const headedCtx = await chromium.launchPersistentContext(GEMINI_PROFILE_DIR, {
+            headless: false,
+            channel: "chrome",
+            args: STEALTH_ARGS,
+            ignoreDefaultArgs: [...STEALTH_IGNORE_DEFAULTS],
           });
-          await pCtx.addCookies(allCookies);
-          await pCtx.close();
-          api.logger.info(`[cli-bridge:gemini] cookies baked into ${geminiProfileDir}`);
-        } catch (err) {
-          api.logger.warn(`[cli-bridge:gemini] cookie bake failed: ${(err as Error).message}`);
+          const loginPage = await headedCtx.newPage();
+          await loginPage.goto("https://gemini.google.com/app", { waitUntil: "domcontentloaded", timeout: 15_000 });
+
+          api.logger.info("[cli-bridge:gemini] waiting for manual login (5 min timeout)…");
+          try {
+            await loginPage.waitForSelector(".ql-editor", { timeout: 300_000 });
+          } catch {
+            await headedCtx.close().catch(() => {});
+            return { text: "❌ Login timeout — Gemini editor did not appear within 5 minutes." };
+          }
+
+          geminiContext = headedCtx;
+          headedCtx.on("close", () => { geminiContext = null; });
+          editor = true;
+          page = loginPage;
+        } else {
+          geminiContext = ctx;
         }
 
-        const expiry = await scanGeminiCookieExpiry(ctx);
+        const expiry = await scanGeminiCookieExpiry(geminiContext!);
         if (expiry) {
           saveGeminiExpiry(expiry);
           api.logger.info(`[cli-bridge:gemini] cookie expiry: ${new Date(expiry.expiresAt).toISOString()}`);
@@ -1584,94 +1428,10 @@ const plugin = {
       },
     } 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;
-
-        // Export + bake cookies into persistent profile
-        const chatgptProfileDir = join(homedir(), ".openclaw", "chatgpt-profile");
-        mkdirSync(chatgptProfileDir, { recursive: true });
-        try {
-          const allCookies = await ctx.cookies([
-            "https://chatgpt.com",
-            "https://openai.com",
-            "https://auth.openai.com",
-          ]);
-          const { chromium } = await import("playwright");
-          const pCtx = await chromium.launchPersistentContext(chatgptProfileDir, {
-            headless: true,
-            args: ["--no-sandbox", "--disable-setuid-sandbox"],
-          });
-          await pCtx.addCookies(allCookies);
-          await pCtx.close();
-          api.logger.info(`[cli-bridge:chatgpt] cookies baked into ${chatgptProfileDir}`);
-        } catch (err) {
-          api.logger.warn(`[cli-bridge:chatgpt] cookie bake failed: ${(err as Error).message}`);
-        }
-
-        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);
-
     // ── /bridge-status — all providers at a glance ───────────────────────────
     api.registerCommand({
       name: "bridge-status",
-      description: "Show status of all headless browser providers (Grok, Claude, Gemini, ChatGPT)",
+      description: "Show status of all headless browser providers (Grok, Gemini)",
       handler: async (): Promise<PluginCommandResult> => {
         const lines: string[] = [`🌉 *CLI Bridge v${plugin.version} — Provider Status*\n`];
 
@@ -1689,21 +1449,6 @@ const plugin = {
             loginCmd: "/grok-login",
             expiry: () => { const e = loadGrokExpiry(); return e ? formatExpiryInfo(e) : null; },
           },
-          {
-            name: "Claude",
-            ctx: claudeContext,
-            check: async () => {
-              if (!claudeContext) return false;
-              try {
-                const { getOrCreateClaudePage } = await import("./src/claude-browser.js");
-                const { page } = await getOrCreateClaudePage(claudeContext);
-                return page.locator(".ProseMirror").isVisible().catch(() => false);
-              } catch { claudeContext = null; return false; }
-            },
-            models: "web-claude/claude-sonnet, claude-opus, claude-haiku",
-            loginCmd: "/claude-login",
-            expiry: () => { const e = loadClaudeExpiry(); return e ? formatClaudeExpiry(e) : null; },
-          },
           {
             name: "Gemini",
             ctx: geminiContext,
@@ -1719,21 +1464,6 @@ const plugin = {
             loginCmd: "/gemini-login",
             expiry: () => { const e = loadGeminiExpiry(); return e ? formatGeminiExpiry(e) : null; },
           },
-          {
-            name: "ChatGPT",
-            ctx: chatgptContext,
-            check: async () => {
-              if (!chatgptContext) return false;
-              try {
-                const { getOrCreateChatGPTPage } = await import("./src/chatgpt-browser.js");
-                const { page } = await getOrCreateChatGPTPage(chatgptContext);
-                return page.locator("#prompt-textarea").isVisible().catch(() => false);
-              } catch { chatgptContext = null; return false; }
-            },
-            models: "web-chatgpt/gpt-4o, gpt-o3, gpt-o4-mini, gpt-5",
-            loginCmd: "/chatgpt-login",
-            expiry: () => { const e = loadChatGPTExpiry(); return e ? formatChatGPTExpiry(e) : null; },
-          },
         ];
 
         for (const c of checks) {
@@ -1750,7 +1480,7 @@ const plugin = {
           lines.push("");
         }
 
-        lines.push(`🔌 Proxy: \`127.0.0.1:${port}\` | 22 models total`);
+        lines.push(`🔌 Proxy: \`127.0.0.1:${port}\``);
         return { text: lines.join("\n") };
       },
     } satisfies OpenClawPluginCommandDefinition);
@@ -1764,15 +1494,9 @@ const plugin = {
       "/grok-login",
       "/grok-status",
       "/grok-logout",
-      "/claude-login",
-      "/claude-status",
-      "/claude-logout",
       "/gemini-login",
       "/gemini-status",
       "/gemini-logout",
-      "/chatgpt-login",
-      "/chatgpt-status",
-      "/chatgpt-logout",
       "/bridge-status",
     ];
     api.logger.info(`[cli-bridge] registered ${allCommands.length} commands: ${allCommands.join(", ")}`);