@elvatis_com/openclaw-cli-bridge-elvatis 0.2.28 → 0.2.30

package/index.ts

@@ -89,6 +89,74 @@ 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; }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+
+// ── 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");
 
@@ -136,60 +204,96 @@ 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;
+  log("[cli-bridge] browser resources cleaned up");
 }
 
 async function tryRestoreGrokSession(
@@ -547,7 +651,7 @@ function proxyTestRequest(
 const plugin = {
   id: "openclaw-cli-bridge-elvatis",
   name: "OpenClaw CLI Bridge",
-  version: "0.2.28",
+  version: "0.2.30",
   description:
     "Phase 1: openai-codex auth bridge. " +
     "Phase 2: HTTP proxy for gemini/claude CLIs. " +
@@ -670,6 +774,28 @@ 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; }
+              }
+              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;
+            },
           });
           proxyServer = server;
           api.logger.info(
@@ -702,6 +828,28 @@ 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; }
+                  }
+                  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;
+                },
               });
               proxyServer = server;
               api.logger.info(`[cli-bridge] proxy ready on :${port} (retry)`);
@@ -723,6 +871,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
@@ -1033,13 +1184,170 @@ const plugin = {
       name: "grok-logout",
       description: "Disconnect from grok.com session (does not close the browser)",
       handler: async (): Promise<PluginCommandResult> => {
-        // Don't close the context — it belongs to the OpenClaw browser, not us
         grokContext = null;
         deleteSession(grokSessionPath);
         return { text: "✅ Disconnected from grok.com. Run `/grok-login` to reconnect." };
       },
     } 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;
+
+        // 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",
+      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);
+    // ─────────────────────────────────────────────────────────────────────────
+
     const allCommands = [
       ...CLI_MODEL_COMMANDS.map((c) => `/${c.name}`),
       "/cli-back",
@@ -1048,6 +1356,12 @@ const plugin = {
       "/grok-login",
       "/grok-status",
       "/grok-logout",
+      "/claude-login",
+      "/claude-status",
+      "/claude-logout",
+      "/gemini-login",
+      "/gemini-status",
+      "/gemini-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.28",
+  "version": "0.2.30",
   "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.28",
+  "version": "0.2.30",
   "description": "Bridges gemini, claude, and codex CLI tools as OpenClaw model providers. Reads existing CLI auth without re-login.",
   "type": "module",
   "openclaw": {