@elvatis_com/openclaw-cli-bridge-elvatis 0.2.29 → 1.0.0

package/README.md

@@ -2,7 +2,7 @@
 
 > OpenClaw plugin that bridges locally installed AI CLIs (Codex, Gemini, Claude Code) as model providers — with slash commands for instant model switching, restore, health testing, and model listing.
 
-**Current version:** `0.2.29`
+**Current version:** `1.0.0`
 
 ---
 
@@ -287,6 +287,27 @@ npm test            # vitest run (45 tests)
 
 ## Changelog
 
+## v1.0.0 — Full Headless Browser Bridge 🚀
+
+All four major LLM providers are now available via browser automation.
+No CLI binaries required — just authenticated browser sessions.
+
+### v1.0.0
+- **feat:** `chatgpt-browser.ts` — chatgpt.com DOM-automation (`#prompt-textarea` + `[data-message-author-role]`)
+- **feat:** `web-chatgpt/*` models: gpt-4o, gpt-4o-mini, gpt-o3, gpt-o4-mini, gpt-5
+- **feat:** `/chatgpt-login`, `/chatgpt-status`, `/chatgpt-logout` + cookie-expiry tracking
+- **feat:** All 4 providers headless: Grok ✅ Claude ✅ Gemini ✅ ChatGPT ✅
+- **test:** 96/96 tests green (8 test files)
+- **fix:** Singleton CDP connection, cleanupBrowsers() on plugin stop
+
+### v0.2.30
+- **feat:** `gemini-browser.ts` — gemini.google.com DOM-automation (Quill editor + message-content polling)
+- **feat:** `web-gemini/*` models in proxy (gemini-2-5-pro, gemini-2-5-flash, gemini-3-pro, gemini-3-flash)
+- **feat:** `/gemini-login`, `/gemini-status`, `/gemini-logout` commands + cookie-expiry tracking
+- **fix:** Singleton CDP connection — no more zombie Chromium processes
+- **fix:** `cleanupBrowsers()` called on plugin stop — all browser resources released
+- **test:** 90/90 tests green (+6 gemini-proxy tests)
+
 ### v0.2.29
 - **feat:** `claude-browser.ts` — claude.ai DOM-automation (ProseMirror + `[data-test-render-count]` polling)
 - **feat:** `web-claude/*` models in proxy (web-claude/claude-sonnet, claude-opus, claude-haiku)

package/SKILL.md

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

package/index.ts

@@ -89,6 +89,64 @@ let grokContext: BrowserContext | null = null;
 // Persistent profile dir — survives gateway restarts, keeps cookies intact
 const GROK_PROFILE_DIR = join(homedir(), ".openclaw", "grok-profile");
 
+// ── Gemini web-session state ──────────────────────────────────────────────────
+let geminiContext: BrowserContext | null = null;
+const GEMINI_EXPIRY_FILE = join(homedir(), ".openclaw", "gemini-cookie-expiry.json");
+
+interface GeminiExpiryInfo { expiresAt: number; loginAt: number; cookieName: string; }
+
+function saveGeminiExpiry(info: GeminiExpiryInfo): void {
+  try { writeFileSync(GEMINI_EXPIRY_FILE, JSON.stringify(info, null, 2)); } catch { /* ignore */ }
+}
+function loadGeminiExpiry(): GeminiExpiryInfo | null {
+  try { return JSON.parse(readFileSync(GEMINI_EXPIRY_FILE, "utf-8")) as GeminiExpiryInfo; } catch { return null; }
+}
+function formatGeminiExpiry(info: GeminiExpiryInfo): 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 /gemini-login`;
+  if (daysLeft <= 7)  return `🚨 expires in ${daysLeft}d (${dateStr}) — run /gemini-login NOW`;
+  if (daysLeft <= 14) return `⚠️ expires in ${daysLeft}d (${dateStr}) — run /gemini-login soon`;
+  return `✅ valid for ${daysLeft} more days (expires ${dateStr})`;
+}
+async function scanGeminiCookieExpiry(ctx: BrowserContext): Promise<GeminiExpiryInfo | null> {
+  try {
+    const cookies = await ctx.cookies(["https://gemini.google.com", "https://accounts.google.com"]);
+    const auth = cookies.filter(c => ["__Secure-1PSID", "__Secure-3PSID", "SID"].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 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");
@@ -172,60 +230,97 @@ async function scanCookieExpiry(ctx: import("playwright").BrowserContext): Promi
   } catch { return null; }
 }
 
+// Singleton CDP connection — one browser object shared across grok + claude
+let _cdpBrowser: import("playwright").Browser | null = null;
+let _cdpBrowserLaunchPromise: Promise<import("playwright").BrowserContext | null> | null = null;
+
 /**
- * Launch (or reuse) a persistent headless Chromium context for grok.com.
- * Uses launchPersistentContext so cookies survive gateway restarts.
- * The profile lives at ~/.openclaw/grok-profile/
+ * Connect to the OpenClaw managed browser (CDP port 18800).
+ * Singleton: reuses the same connection. Falls back to persistent Chromium for Grok only.
+ * NEVER launches a new browser for Claude — Claude requires the OpenClaw browser.
  */
-async function getOrLaunchGrokContext(
+async function connectToOpenClawBrowser(
   log: (msg: string) => void
 ): Promise<BrowserContext | null> {
-  // Already have a live context?
-  if (grokContext) {
+  // Reuse existing CDP connection if still alive
+  if (_cdpBrowser) {
     try {
-      // Quick check: can we still enumerate pages?
-      grokContext.pages();
-      return grokContext;
+      _cdpBrowser.contexts(); // ping
+      return _cdpBrowser.contexts()[0] ?? null;
     } catch {
-      grokContext = null;
+      _cdpBrowser = null;
     }
   }
-
   const { chromium } = await import("playwright");
-
-  // 1. Try connecting to the OpenClaw managed browser first (user may have grok.com open)
   try {
-    const browser = await chromium.connectOverCDP("http://127.0.0.1:18800", { timeout: 2000 });
-    grokBrowser = browser;
-    const ctx = browser.contexts()[0];
-    if (ctx) {
-      log("[cli-bridge:grok] connected to OpenClaw browser");
-      return ctx;
-    }
+    const browser = await chromium.connectOverCDP("http://127.0.0.1:18800", { timeout: 3000 });
+    _cdpBrowser = browser;
+    browser.on("disconnected", () => { _cdpBrowser = null; log("[cli-bridge] OpenClaw browser disconnected"); });
+    log("[cli-bridge] connected to OpenClaw browser via CDP");
+    return browser.contexts()[0] ?? null;
   } catch {
-    // OpenClaw browser not available — fall through to persistent context
-  }
-
-  // 2. Launch our own persistent headless Chromium with saved profile
-  log("[cli-bridge:grok] launching persistent Chromium…");
-  try {
-    const ctx = await chromium.launchPersistentContext(GROK_PROFILE_DIR, {
-      headless: true,
-      args: ["--no-sandbox", "--disable-setuid-sandbox"],
-    });
-    grokContext = ctx;
-    log("[cli-bridge:grok] persistent context ready");
-    return ctx;
-  } catch (err) {
-    log(`[cli-bridge:grok] failed to launch browser: ${(err as Error).message}`);
+    log("[cli-bridge] OpenClaw browser not available (CDP 18800)");
     return null;
   }
 }
 
-async function connectToOpenClawBrowser(
+/**
+ * Launch (or reuse) a persistent headless Chromium context for grok.com.
+ * ONLY used for Grok — Grok has a saved persistent profile with cookies.
+ * Claude does NOT use this — it requires the OpenClaw browser.
+ */
+async function getOrLaunchGrokContext(
   log: (msg: string) => void
 ): Promise<BrowserContext | null> {
-  return getOrLaunchGrokContext(log);
+  // Already have a live context?
+  if (grokContext) {
+    try { grokContext.pages(); return grokContext; } catch { grokContext = null; }
+  }
+
+  // Try OpenClaw browser first (singleton CDP)
+  const cdpCtx = await connectToOpenClawBrowser(log);
+  if (cdpCtx) return cdpCtx;
+
+  // Coalesce concurrent launch requests into one
+  if (_cdpBrowserLaunchPromise) return _cdpBrowserLaunchPromise;
+
+  _cdpBrowserLaunchPromise = (async () => {
+    const { chromium } = await import("playwright");
+    log("[cli-bridge:grok] launching persistent Chromium…");
+    try {
+      const ctx = await chromium.launchPersistentContext(GROK_PROFILE_DIR, {
+        headless: true,
+        args: ["--no-sandbox", "--disable-setuid-sandbox"],
+      });
+      grokContext = ctx;
+      // Auto-cleanup on browser crash
+      ctx.on("close", () => { grokContext = null; log("[cli-bridge:grok] persistent context closed"); });
+      log("[cli-bridge:grok] persistent context ready");
+      return ctx;
+    } catch (err) {
+      log(`[cli-bridge:grok] failed to launch browser: ${(err as Error).message}`);
+      return null;
+    } finally {
+      _cdpBrowserLaunchPromise = null;
+    }
+  })();
+  return _cdpBrowserLaunchPromise;
+}
+
+/** 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 (_cdpBrowser) {
+    try { await _cdpBrowser.close(); } catch { /* ignore */ }
+    _cdpBrowser = null;
+  }
+  claudeContext = null;
+  geminiContext = null;
+  chatgptContext = null;
+  log("[cli-bridge] browser resources cleaned up");
 }
 
 async function tryRestoreGrokSession(
@@ -583,7 +678,7 @@ function proxyTestRequest(
 const plugin = {
   id: "openclaw-cli-bridge-elvatis",
   name: "OpenClaw CLI Bridge",
-  version: "0.2.29",
+  version: "1.0.0",
   description:
     "Phase 1: openai-codex auth bridge. " +
     "Phase 2: HTTP proxy for gemini/claude CLIs. " +
@@ -717,6 +812,28 @@ const plugin = {
               }
               return null;
             },
+            getGeminiContext: () => geminiContext,
+            connectGeminiContext: async () => {
+              const ctx = await connectToOpenClawBrowser((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; }
+              }
+              return null;
+            },
+            getChatGPTContext: () => chatgptContext,
+            connectChatGPTContext: async () => {
+              const ctx = await connectToOpenClawBrowser((msg) => api.logger.info(msg));
+              if (ctx) {
+                const { getOrCreateChatGPTPage } = await import("./src/chatgpt-browser.js");
+                const { page } = await getOrCreateChatGPTPage(ctx);
+                const editor = await page.locator("#prompt-textarea").isVisible().catch(() => false);
+                if (editor) { chatgptContext = ctx; return ctx; }
+              }
+              return null;
+            },
           });
           proxyServer = server;
           api.logger.info(
@@ -760,6 +877,28 @@ const plugin = {
                   }
                   return null;
                 },
+                getGeminiContext: () => geminiContext,
+                connectGeminiContext: async () => {
+                  const ctx = await connectToOpenClawBrowser((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; }
+                  }
+                  return null;
+                },
+                getChatGPTContext: () => chatgptContext,
+                connectChatGPTContext: async () => {
+                  const ctx = await connectToOpenClawBrowser((msg) => api.logger.info(msg));
+                  if (ctx) {
+                    const { getOrCreateChatGPTPage } = await import("./src/chatgpt-browser.js");
+                    const { page } = await getOrCreateChatGPTPage(ctx);
+                    const editor = await page.locator("#prompt-textarea").isVisible().catch(() => false);
+                    if (editor) { chatgptContext = ctx; return ctx; }
+                  }
+                  return null;
+                },
               });
               proxyServer = server;
               api.logger.info(`[cli-bridge] proxy ready on :${port} (retry)`);
@@ -781,6 +920,9 @@ const plugin = {
       id: "cli-bridge-proxy",
       start: async () => { /* proxy already started above */ },
       stop: async () => {
+        // Clean up browser resources first
+        await cleanupBrowsers((msg) => api.logger.info(msg));
+
         if (proxyServer) {
           // closeAllConnections() forcefully terminates keep-alive connections
           // so that server.close() releases the port immediately rather than
@@ -1113,23 +1255,8 @@ const plugin = {
         }
 
         api.logger.info("[cli-bridge:claude] /claude-login: connecting to OpenClaw browser…");
-        const { chromium } = await import("playwright");
 
-        // Import cookies from OpenClaw browser
-        let importedCookies: unknown[] = [];
-        try {
-          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", "https://anthropic.com"]);
-            api.logger.info(`[cli-bridge:claude] imported ${importedCookies.length} cookies`);
-          }
-          await ocBrowser.close().catch(() => {});
-        } catch {
-          api.logger.info("[cli-bridge:claude] OpenClaw browser not available");
-        }
-
-        // Connect to OpenClaw browser context for session
+        // 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." };
 
@@ -1192,6 +1319,144 @@ const plugin = {
         return { text: "✅ Disconnected from claude.ai. Run `/claude-login` to reconnect." };
       },
     } satisfies OpenClawPluginCommandDefinition);
+
+    // ── Gemini web-session commands ───────────────────────────────────────────
+    api.registerCommand({
+      name: "gemini-login",
+      description: "Authenticate gemini.google.com: imports session from OpenClaw browser",
+      handler: async (): Promise<PluginCommandResult> => {
+        if (geminiContext) {
+          const { getOrCreateGeminiPage } = await import("./src/gemini-browser.js");
+          try {
+            const { page } = await getOrCreateGeminiPage(geminiContext);
+            const editor = await page.locator(".ql-editor").isVisible().catch(() => false);
+            if (editor) return { text: "✅ Already connected to gemini.google.com. Use `/gemini-logout` first to reset." };
+          } catch { /* fall through */ }
+          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." };
+
+        const { getOrCreateGeminiPage } = await import("./src/gemini-browser.js");
+        let page;
+        try {
+          ({ page } = await getOrCreateGeminiPage(ctx));
+        } catch (err) {
+          return { text: `❌ Failed to open gemini.google.com: ${(err as Error).message}` };
+        }
+
+        const 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;
+
+        const expiry = await scanGeminiCookieExpiry(ctx);
+        if (expiry) {
+          saveGeminiExpiry(expiry);
+          api.logger.info(`[cli-bridge:gemini] cookie expiry: ${new Date(expiry.expiresAt).toISOString()}`);
+        }
+        const expiryLine = expiry ? `\n\n🕐 Cookie expiry: ${formatGeminiExpiry(expiry)}` : "";
+
+        return { text: `✅ Gemini session ready!\n\nModels available:\n• \`vllm/web-gemini/gemini-2-5-pro\`\n• \`vllm/web-gemini/gemini-2-5-flash\`\n• \`vllm/web-gemini/gemini-3-pro\`\n• \`vllm/web-gemini/gemini-3-flash\`${expiryLine}` };
+      },
+    } satisfies OpenClawPluginCommandDefinition);
+
+    api.registerCommand({
+      name: "gemini-status",
+      description: "Check gemini.google.com session status",
+      handler: async (): Promise<PluginCommandResult> => {
+        if (!geminiContext) {
+          return { text: "❌ No active gemini.google.com session\nRun `/gemini-login` to authenticate." };
+        }
+        const { getOrCreateGeminiPage } = await import("./src/gemini-browser.js");
+        try {
+          const { page } = await getOrCreateGeminiPage(geminiContext);
+          const editor = await page.locator(".ql-editor").isVisible().catch(() => false);
+          if (editor) {
+            const expiry = loadGeminiExpiry();
+            const expiryLine = expiry ? `\n🕐 ${formatGeminiExpiry(expiry)}` : "";
+            return { text: `✅ gemini.google.com session active\nProxy: \`127.0.0.1:${port}\`\nModels: web-gemini/gemini-2-5-pro, gemini-2-5-flash, gemini-3-pro, gemini-3-flash${expiryLine}` };
+          }
+        } catch { /* fall through */ }
+        geminiContext = null;
+        return { text: "❌ Session lost — run `/gemini-login` to re-authenticate." };
+      },
+    } satisfies OpenClawPluginCommandDefinition);
+
+    api.registerCommand({
+      name: "gemini-logout",
+      description: "Disconnect from gemini.google.com session",
+      handler: async (): Promise<PluginCommandResult> => {
+        geminiContext = null;
+        return { text: "✅ Disconnected from gemini.google.com. Run `/gemini-login` to reconnect." };
+      },
+    } satisfies OpenClawPluginCommandDefinition);
+
+    // ── ChatGPT web-session commands ──────────────────────────────────────────
+    api.registerCommand({
+      name: "chatgpt-login",
+      description: "Authenticate chatgpt.com: imports session from OpenClaw browser",
+      handler: async (): Promise<PluginCommandResult> => {
+        if (chatgptContext) {
+          const { getOrCreateChatGPTPage } = await import("./src/chatgpt-browser.js");
+          try {
+            const { page } = await getOrCreateChatGPTPage(chatgptContext);
+            if (await page.locator("#prompt-textarea").isVisible().catch(() => false))
+              return { text: "✅ Already connected to chatgpt.com. Use `/chatgpt-logout` first to reset." };
+          } catch { /* fall through */ }
+          chatgptContext = null;
+        }
+        api.logger.info("[cli-bridge:chatgpt] /chatgpt-login: connecting to OpenClaw browser…");
+        const ctx = await connectToOpenClawBrowser((msg) => api.logger.info(msg));
+        if (!ctx) return { text: "❌ Could not connect to OpenClaw browser.\nMake sure chatgpt.com is open in your browser." };
+
+        const { getOrCreateChatGPTPage } = await import("./src/chatgpt-browser.js");
+        let page;
+        try { ({ page } = await getOrCreateChatGPTPage(ctx)); }
+        catch (err) { return { text: `❌ Failed to open chatgpt.com: ${(err as Error).message}` }; }
+
+        if (!await page.locator("#prompt-textarea").isVisible().catch(() => false))
+          return { text: "❌ ChatGPT editor not visible — are you logged in?\nOpen chatgpt.com in your browser and try again." };
+
+        chatgptContext = ctx;
+        const expiry = await scanChatGPTCookieExpiry(ctx);
+        if (expiry) { saveChatGPTExpiry(expiry); api.logger.info(`[cli-bridge:chatgpt] cookie expiry: ${new Date(expiry.expiresAt).toISOString()}`); }
+        const expiryLine = expiry ? `\n\n🕐 Cookie expiry: ${formatChatGPTExpiry(expiry)}` : "";
+        return { text: `✅ ChatGPT session ready!\n\nModels available:\n• \`vllm/web-chatgpt/gpt-4o\`\n• \`vllm/web-chatgpt/gpt-4o-mini\`\n• \`vllm/web-chatgpt/gpt-o3\`\n• \`vllm/web-chatgpt/gpt-o4-mini\`\n• \`vllm/web-chatgpt/gpt-5\`${expiryLine}` };
+      },
+    } satisfies OpenClawPluginCommandDefinition);
+
+    api.registerCommand({
+      name: "chatgpt-status",
+      description: "Check chatgpt.com session status",
+      handler: async (): Promise<PluginCommandResult> => {
+        if (!chatgptContext) return { text: "❌ No active chatgpt.com session\nRun `/chatgpt-login` to authenticate." };
+        const { getOrCreateChatGPTPage } = await import("./src/chatgpt-browser.js");
+        try {
+          const { page } = await getOrCreateChatGPTPage(chatgptContext);
+          if (await page.locator("#prompt-textarea").isVisible().catch(() => false)) {
+            const expiry = loadChatGPTExpiry();
+            const expiryLine = expiry ? `\n🕐 ${formatChatGPTExpiry(expiry)}` : "";
+            return { text: `✅ chatgpt.com session active\nProxy: \`127.0.0.1:${port}\`\nModels: web-chatgpt/gpt-4o, gpt-4o-mini, gpt-o3, gpt-o4-mini, gpt-5${expiryLine}` };
+          }
+        } catch { /* fall through */ }
+        chatgptContext = null;
+        return { text: "❌ Session lost — run `/chatgpt-login` to re-authenticate." };
+      },
+    } satisfies OpenClawPluginCommandDefinition);
+
+    api.registerCommand({
+      name: "chatgpt-logout",
+      description: "Disconnect from chatgpt.com session",
+      handler: async (): Promise<PluginCommandResult> => {
+        chatgptContext = null;
+        return { text: "✅ Disconnected from chatgpt.com. Run `/chatgpt-login` to reconnect." };
+      },
+    } satisfies OpenClawPluginCommandDefinition);
     // ─────────────────────────────────────────────────────────────────────────
 
     const allCommands = [
@@ -1205,6 +1470,12 @@ const plugin = {
       "/claude-login",
       "/claude-status",
       "/claude-logout",
+      "/gemini-login",
+      "/gemini-status",
+      "/gemini-logout",
+      "/chatgpt-login",
+      "/chatgpt-status",
+      "/chatgpt-logout",
     ];
     api.logger.info(`[cli-bridge] registered ${allCommands.length} commands: ${allCommands.join(", ")}`);
   },

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-cli-bridge-elvatis",
   "name": "OpenClaw CLI Bridge",
-  "version": "0.2.29",
+  "version": "1.0.0",
   "description": "Phase 1: openai-codex auth bridge. Phase 2: local HTTP proxy routing model calls through gemini/claude CLIs (vllm provider).",
   "providers": [
     "openai-codex"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elvatis_com/openclaw-cli-bridge-elvatis",
-  "version": "0.2.29",
+  "version": "1.0.0",
   "description": "Bridges gemini, claude, and codex CLI tools as OpenClaw model providers. Reads existing CLI auth without re-login.",
   "type": "module",
   "openclaw": {