chrome-ai-bridge 2.3.10 → 2.4.0

package/build/extension/background.mjs

@@ -170,6 +170,8 @@ class RelayConnection {
     }
     if (message.method === 'reloadExtension') {
       logInfo('reload', 'reloadExtension command received');
+      // Set flag so the reloaded service worker skips cooldown
+      chrome.storage.local.set({ _reloadTriggered: Date.now() }).catch(() => {});
       // Delay reload to allow response to be sent first
       setTimeout(() => {
         logInfo('reload', 'Calling chrome.runtime.reload()');
@@ -731,7 +733,7 @@ const DISCOVERY_INTERVAL_MS = {
 };
 const FAST_TO_NORMAL_EMPTY_STREAK = 5;
 const NORMAL_TO_IDLE_EMPTY_STREAK = 20;
-const ACTIVE_TO_IDLE_EMPTY_STREAK = 3;
+const ACTIVE_TO_IDLE_EMPTY_STREAK = 10;
 let lastSuccessfulPort = null;
 const lastRelayByPort = new Map();
 
@@ -745,8 +747,23 @@ let emptyDiscoveryStreak = 0;
 let keepAliveActive = false;
 
 // リロード時クールダウン: 5秒間は「新しいrelay」検出をスキップ
+// ただし reloadExtension コマンド経由のリロード時はスキップしない
 const extensionStartTime = Date.now();
 const COOLDOWN_MS = 5000;
+let cooldownDisabled = false;
+
+// Check if this is a reload triggered by reloadExtension command
+chrome.storage.local.get('_reloadTriggered').then(result => {
+  if (result._reloadTriggered) {
+    const age = Date.now() - result._reloadTriggered;
+    if (age < 10000) {  // Within 10 seconds of reload trigger
+      cooldownDisabled = true;
+      logInfo('discovery', 'Cooldown disabled (reloadExtension triggered)', {age});
+    }
+    // Clear the flag
+    chrome.storage.local.remove('_reloadTriggered').catch(() => {});
+  }
+}).catch(() => {});
 
 // ユーザー操作によるDiscoveryかどうかのフラグ
 // Chrome起動時やService Worker再起動時はfalse、アイコンクリック時のみtrue
@@ -937,15 +954,15 @@ async function autoConnectRelay(best) {
 
   // tabUrl があれば、connect.html を開かずに直接接続
   // preferredTabId があれば優先的に使用
+  const requestedNewTab = Boolean(best?.data?.newTab);
   let targetTabId;
   try {
     // autoConnectRelay経由の場合はフォーカスしない（active: false）
-    // リロード時に勝手にタブがフォーカスされる問題を防ぐ
-    // newTab: false に固定 - 自動接続では既存タブを優先してタブスパムを防止
+    // newTab: relay の要求を尊重する（MCP サーバーが newTab: true を指定した場合は新規タブ作成を許可）
     targetTabId = await tabShareExtension._resolveTabId(
       tabUrl,
       preferredTabId,
-      false,  // newTab: false - always prefer existing tabs in auto-connect
+      requestedNewTab,
       false,  // active: false - 自動接続時はタブをフォーカスしない
     );
   } catch (error) {
@@ -957,8 +974,23 @@ async function autoConnectRelay(best) {
     return false;
   }
   if (tabShareExtension._activeConnections?.has(targetTabId)) {
-    logInfo('auto-connect', 'Tab already connected', {targetTabId});
-    return true; // 既に接続済み
+    const existingSessionId = tabShareExtension._tabSessionOwners?.get(targetTabId);
+    const newSessionId = best?.data?.sessionId;
+    if (existingSessionId && newSessionId && existingSessionId !== newSessionId) {
+      // Different session wants the same tab — replace the old connection
+      logInfo('auto-connect', 'Replacing stale connection with newer session', {
+        targetTabId, oldSession: existingSessionId, newSession: newSessionId,
+      });
+      const oldConn = tabShareExtension._activeConnections.get(targetTabId);
+      if (oldConn) {
+        oldConn.close('Replaced by newer session');
+        tabShareExtension._activeConnections.delete(targetTabId);
+        tabShareExtension._tabSessionOwners.delete(targetTabId);
+      }
+    } else {
+      logInfo('auto-connect', 'Tab already connected', {targetTabId});
+      return true; // 同じセッションで接続済み
+    }
   }
 
   const targetTab = await chrome.tabs.get(targetTabId).catch(() => null);
@@ -1009,8 +1041,9 @@ async function autoOpenConnectUi() {
   };
 
   // リロード直後はタブを開かない（既存MCPサーバーとの再接続を防ぐ）
+  // ただし reloadExtension コマンド経由の場合はスキップしない
   const elapsed = Date.now() - extensionStartTime;
-  if (elapsed < COOLDOWN_MS) {
+  if (elapsed < COOLDOWN_MS && !cooldownDisabled) {
     logDebug('discovery', `Cooldown active (${elapsed}ms < ${COOLDOWN_MS}ms), skipping`);
     result.skippedCooldown = true;
     return result;
@@ -1038,7 +1071,7 @@ async function autoOpenConnectUi() {
       continue;
     }
 
-    logInfo('discovery', 'New relay detected', {port, tabUrl: data.tabUrl, wsUrl: data.wsUrl});
+    logInfo('discovery', 'New relay detected', {port, tabUrl: data.tabUrl, wsUrl: data.wsUrl, startedAt});
     lastRelayByPort.set(port, {
       wsUrl: data.wsUrl,
       startedAt,
@@ -1047,14 +1080,34 @@ async function autoOpenConnectUi() {
     newRelays.push({port, data});
   }
 
-  result.newRelayCount = newRelays.length;
+  // Deduplicate: when multiple relays serve the same tabUrl, prefer the newest (by startedAt)
+  // This prevents stale MCP servers from stealing connections from active ones
+  const bestByTabUrl = new Map();
+  for (const relay of newRelays) {
+    const tabUrl = relay.data?.tabUrl || '';
+    const existing = bestByTabUrl.get(tabUrl);
+    const relayStartedAt = relay.data?.startedAt || 0;
+    if (!existing || relayStartedAt > (existing.data?.startedAt || 0)) {
+      bestByTabUrl.set(tabUrl, relay);
+    }
+  }
+  const dedupedRelays = [...bestByTabUrl.values()];
+  if (dedupedRelays.length < newRelays.length) {
+    logInfo('discovery', 'Deduped relays by tabUrl (preferring newest)', {
+      before: newRelays.length,
+      after: dedupedRelays.length,
+      dropped: newRelays.filter(r => !dedupedRelays.includes(r)).map(r => ({port: r.port, tabUrl: r.data?.tabUrl, startedAt: r.data?.startedAt})),
+    });
+  }
 
-  if (newRelays.length > 0) {
-    logInfo('discovery', `Processing ${newRelays.length} new relay(s)`);
+  result.newRelayCount = dedupedRelays.length;
+
+  if (dedupedRelays.length > 0) {
+    logInfo('discovery', `Processing ${dedupedRelays.length} new relay(s)`);
   }
 
   // 全ての新しい relay を処理（並列ではなく順次）
-  for (const relay of newRelays) {
+  for (const relay of dedupedRelays) {
     logInfo('discovery', 'Processing relay', {port: relay.port, tabUrl: relay.data.tabUrl});
     debugLog('Processing new relay:', relay.port, relay.data.tabUrl);
     let ok = false;
@@ -1259,5 +1312,7 @@ chrome.runtime.onStartup.addListener(() => {
   scheduleDiscovery();
 });
 scheduleDiscovery();  // Start immediately
+// Ensure keepAlive is active from the start to prevent SW termination during discovery
+ensureKeepAliveAlarm('startup');
 
 logInfo('background', 'Extension loaded (discovery active)');

package/build/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "chrome-ai-bridge Extension",
-  "version": "2.0.23",
+  "version": "2.0.28",
   "key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqDLiSB+b/gbnQ4zWRP65jnd27KmzpjJyR1JAQIjCD/dNORzTgk6+G0TjYEDZLIDceKHzGJudqnwq4q9g3T1eJ0SECZNXnaoE00WkgXfAUSQn6cmmXR3aQGFky/zbCmxnkRa0vYupxszlhw0yrlSZrIJd/weWF75Byh0zJfZ84kqDDhaj7TlB5laHICnoSLmPTif4mQcUW9oOKmAJPriPw4CWATKZsrQ4X46djxefSmfbqYfb9rttAqJVst40gO0Gsl6GOGxMHMds5Cl9GELc0dI3Gpobw07hQldZb8TeyilI/SnOaeS3HPtrp+KyEgRu8SgRdlrvuq6DeEZsP+kK7wIDAQAB",
   "description": "Bridge between Chrome tabs and chrome-ai-bridge MCP server",
   "permissions": ["debugger", "activeTab", "tabs", "storage", "alarms"],

package/build/extension/relay-server.ts

@@ -55,6 +55,12 @@ export class RelayServer extends EventEmitter {
   private discoveryServer: http.Server | null = null;
   private discoveryPort: number | null = null;
   private keepAliveTimer: ReturnType<typeof setInterval> | null = null;
+  private _lastDiscoveryOptions: {
+    tabUrl?: string;
+    tabId?: number;
+    newTab?: boolean;
+    allowTabTakeover?: boolean;
+  } = {};
 
   constructor(options: RelayServerOptions = {}) {
     super();
@@ -219,6 +225,9 @@ export class RelayServer extends EventEmitter {
           this.ready = true;
           debugLog(`[RelayServer] Connection ready for tab ${this.tabId}`);
           this.emit('ready', this.tabId);
+          // Release discovery port after WebSocket is established.
+          // 1-second grace period lets Extension finish processing the response.
+          setTimeout(() => this.stopDiscoveryServer(), 1000);
           break;
         case 'pong':
           debugLog('[RelayServer] Received keep-alive pong');
@@ -333,6 +342,7 @@ export class RelayServer extends EventEmitter {
     newTab?: boolean;
     allowTabTakeover?: boolean;
   } = {}): Promise<number | null> {
+    this._lastDiscoveryOptions = options;
     const ports = [38765, 38766, 38767, 38768, 38769, 38770, 38771, 38772, 38773, 38774, 38775];
     const wsUrl = this.getConnectionURL();
 
@@ -404,6 +414,34 @@ export class RelayServer extends EventEmitter {
     return null;
   }
 
+  /**
+   * Release the discovery HTTP server (port).
+   * Called automatically after the Extension WebSocket connects (ready event).
+   * The port becomes available for other sessions.
+   */
+  stopDiscoveryServer(): void {
+    if (this.discoveryServer) {
+      this.discoveryServer.close();
+      debugLog(`[RelayServer] Discovery server released (port ${this.discoveryPort})`);
+      this.discoveryServer = null;
+      this.discoveryPort = null;
+    }
+  }
+
+  /**
+   * Re-acquire a discovery port (e.g. after WebSocket disconnect for reconnection).
+   * Uses the same options as the last startDiscoveryServer() call.
+   */
+  async restartDiscoveryServer(options?: {
+    tabUrl?: string;
+    tabId?: number;
+    newTab?: boolean;
+    allowTabTakeover?: boolean;
+  }): Promise<number | null> {
+    this.stopDiscoveryServer();
+    return this.startDiscoveryServer(options || this._lastDiscoveryOptions);
+  }
+
   /**
    * Stop server
    */
@@ -425,11 +463,7 @@ export class RelayServer extends EventEmitter {
       new Error('RELAY_STOPPED: Relay stopped before request completion'),
     );
 
-    if (this.discoveryServer) {
-      this.discoveryServer.close();
-      this.discoveryServer = null;
-      this.discoveryPort = null;
-    }
+    this.stopDiscoveryServer();
 
     if (this.wss) {
       return new Promise((resolve) => {

package/build/src/extension/relay-server.js

@@ -29,6 +29,7 @@ export class RelayServer extends EventEmitter {
     discoveryServer = null;
     discoveryPort = null;
     keepAliveTimer = null;
+    _lastDiscoveryOptions = {};
     constructor(options = {}) {
         super();
         this.host = options.host || '127.0.0.1';
@@ -172,6 +173,9 @@ export class RelayServer extends EventEmitter {
                     this.ready = true;
                     debugLog(`[RelayServer] Connection ready for tab ${this.tabId}`);
                     this.emit('ready', this.tabId);
+                    // Release discovery port after WebSocket is established.
+                    // 1-second grace period lets Extension finish processing the response.
+                    setTimeout(() => this.stopDiscoveryServer(), 1000);
                     break;
                 case 'pong':
                     debugLog('[RelayServer] Received keep-alive pong');
@@ -269,6 +273,7 @@ export class RelayServer extends EventEmitter {
      * Extension polls this endpoint when user clicks the extension icon.
      */
     async startDiscoveryServer(options = {}) {
+        this._lastDiscoveryOptions = options;
         const ports = [38765, 38766, 38767, 38768, 38769, 38770, 38771, 38772, 38773, 38774, 38775];
         const wsUrl = this.getConnectionURL();
         for (const port of ports) {
@@ -332,6 +337,27 @@ export class RelayServer extends EventEmitter {
         debugLog('[RelayServer] Could not start discovery server on any port');
         return null;
     }
+    /**
+     * Release the discovery HTTP server (port).
+     * Called automatically after the Extension WebSocket connects (ready event).
+     * The port becomes available for other sessions.
+     */
+    stopDiscoveryServer() {
+        if (this.discoveryServer) {
+            this.discoveryServer.close();
+            debugLog(`[RelayServer] Discovery server released (port ${this.discoveryPort})`);
+            this.discoveryServer = null;
+            this.discoveryPort = null;
+        }
+    }
+    /**
+     * Re-acquire a discovery port (e.g. after WebSocket disconnect for reconnection).
+     * Uses the same options as the last startDiscoveryServer() call.
+     */
+    async restartDiscoveryServer(options) {
+        this.stopDiscoveryServer();
+        return this.startDiscoveryServer(options || this._lastDiscoveryOptions);
+    }
     /**
      * Stop server
      */
@@ -349,11 +375,7 @@ export class RelayServer extends EventEmitter {
         this.ready = false;
         this.tabId = null;
         this.rejectPendingRequests(new Error('RELAY_STOPPED: Relay stopped before request completion'));
-        if (this.discoveryServer) {
-            this.discoveryServer.close();
-            this.discoveryServer = null;
-            this.discoveryPort = null;
-        }
+        this.stopDiscoveryServer();
         if (this.wss) {
             return new Promise((resolve) => {
                 this.wss.close(() => {

package/build/src/fast-cdp/extension-raw.js

@@ -5,7 +5,10 @@ import { RelayServer } from '../extension/relay-server.js';
 import { logRelay, logExtension, logInfo, logError } from './mcp-logger.js';
 // Stable extension ID (from manifest.json key)
 const EXTENSION_ID = 'ibjplbopgmcacpmfpnaeoloepdhenlbm';
-const ENABLE_WAKE_CONNECT_PAGE = process.env.CAI_ENABLE_WAKE_CONNECT_PAGE !== '0';
+// Wake connect page disabled by default — it opens a chrome-extension:// URL
+// that gets ERR_BLOCKED_BY_CLIENT and annoys users. Discovery polling is the
+// primary mechanism; wake is only useful in rare edge cases.
+const ENABLE_WAKE_CONNECT_PAGE = process.env.CAI_ENABLE_WAKE_CONNECT_PAGE === '1';
 /**
  * Get Chrome executable path for current platform
  */

package/build/src/fast-cdp/fast-chat.js

@@ -2032,16 +2032,20 @@ async function askChatGPTFastInternal(question, debug) {
         summary: interceptor.getSummary(),
     });
     // Hybrid: prefer network text (primary), DOM as fallback
+    // Use network if it captured anything and is at least 50% of DOM length
+    // (avoids using truncated network text when DOM has the full answer)
     let hybridAnswer = finalAnswer;
     let answerSource = 'dom';
-    if (networkResult.text.length > 50) {
+    const netLen = networkResult.text.length;
+    const domLen = finalAnswer.length;
+    if (netLen > 0 && (domLen === 0 || netLen >= domLen * 0.5)) {
         hybridAnswer = networkResult.text;
         answerSource = 'network';
     }
     logInfo('chatgpt', 'Answer source selected', {
         source: answerSource,
-        networkLen: networkResult.text.length,
-        domLen: finalAnswer.length,
+        networkLen: netLen,
+        domLen,
     });
     return { answer: hybridAnswer, timings: fullTimings, debug: debugInfo };
 }
@@ -3030,17 +3034,20 @@ async function askGeminiFastInternal(question, debug) {
     });
     // Hybrid: prefer network text (primary), DOM as fallback
     // Normalize network text with same Gemini-specific cleanup as DOM text
+    // Use network if it captured anything and is at least 50% of DOM length
     const networkNormalized = normalizeGeminiResponse(networkResult.text, question);
     let hybridAnswer = normalized;
     let answerSource = 'dom';
-    if (networkNormalized.length > 50) {
+    const netLen = networkNormalized.length;
+    const domLen = normalized.length;
+    if (netLen > 0 && (domLen === 0 || netLen >= domLen * 0.5)) {
         hybridAnswer = networkNormalized;
         answerSource = 'network';
     }
     logInfo('gemini', 'Answer source selected', {
         source: answerSource,
-        networkLen: networkNormalized.length,
-        domLen: normalized.length,
+        networkLen: netLen,
+        domLen,
     });
     return { answer: hybridAnswer, timings: fullTimings, debug: debugInfo };
 }

package/build/src/fast-cdp/network-interceptor.js

@@ -146,8 +146,15 @@ export class NetworkInterceptor {
             const isSSE = contentType.includes('text/event-stream');
             if (isResponseUrl(url) || isSSE) {
                 this.pendingBodies.add(requestId);
-                this.fetchResponseBody(requestId, url).catch(() => {
-                    // Best-effort; failures are expected for some responses
+                this.fetchResponseBody(requestId, url).catch((err) => {
+                    console.error(`[NetworkInterceptor] fetchResponseBody error for ${url.slice(0, 80)}: ${err instanceof Error ? err.message : String(err)}`);
+                });
+            }
+            else if (!url) {
+                // Speculative capture: requestWillBeSent was missed (tab reuse scenario)
+                // Try fetching body and check if it looks like ChatGPT SSE or Gemini response
+                this.speculativeFetchBody(requestId).catch(() => {
+                    // Best-effort; silent failure expected
                 });
             }
         });
@@ -163,40 +170,87 @@ export class NetworkInterceptor {
         this.client.on(event, wrappedHandler);
     }
     async fetchResponseBody(requestId, url) {
-        try {
-            const result = await this.client.send('Network.getResponseBody', { requestId });
-            if (result?.body) {
-                let data;
-                if (result.base64Encoded) {
-                    try {
-                        data = Buffer.from(result.body, 'base64').toString('utf-8');
+        const maxRetries = 2;
+        const retryDelayMs = 500;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                const result = await this.client.send('Network.getResponseBody', { requestId });
+                if (result?.body) {
+                    let data;
+                    if (result.base64Encoded) {
+                        try {
+                            data = Buffer.from(result.body, 'base64').toString('utf-8');
+                        }
+                        catch (decodeErr) {
+                            console.error(`[NetworkInterceptor] Base64 decode failed for ${url.slice(0, 80)}: ${decodeErr instanceof Error ? decodeErr.message : String(decodeErr)}`);
+                            this.pendingBodies.delete(requestId);
+                            return;
+                        }
                     }
-                    catch (decodeErr) {
-                        console.error(`[NetworkInterceptor] Base64 decode failed for ${url.slice(0, 80)}: ${decodeErr instanceof Error ? decodeErr.message : String(decodeErr)}`);
-                        return;
+                    else {
+                        data = result.body;
                     }
+                    this.frames.push({
+                        timestamp: Date.now() / 1000,
+                        type: 'fetch-body',
+                        requestId,
+                        url,
+                        data,
+                    });
+                    console.error(`[NetworkInterceptor] Body captured: ${url.slice(0, 80)} (${data.length} bytes)`);
+                }
+                this.pendingBodies.delete(requestId);
+                return;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                const isRetryable = msg.includes('No resource') || msg.includes('No data found');
+                if (isRetryable && attempt < maxRetries) {
+                    console.error(`[NetworkInterceptor] getResponseBody retry ${attempt + 1}/${maxRetries} for ${url.slice(0, 80)}`);
+                    await new Promise(r => setTimeout(r, retryDelayMs));
+                    continue;
+                }
+                if (!isRetryable) {
+                    console.error(`[NetworkInterceptor] getResponseBody failed for ${url.slice(0, 80)}: ${msg}`);
                 }
                 else {
-                    data = result.body;
+                    console.error(`[NetworkInterceptor] getResponseBody failed after ${maxRetries} retries for ${url.slice(0, 80)}: ${msg}`);
                 }
+                this.pendingBodies.delete(requestId);
+                return;
+            }
+        }
+        this.pendingBodies.delete(requestId);
+    }
+    /**
+     * Speculative body fetch for requests where requestWillBeSent was missed
+     * (e.g., tab reuse). Checks if the body looks like a ChatGPT or Gemini response.
+     */
+    async speculativeFetchBody(requestId) {
+        try {
+            const result = await this.client.send('Network.getResponseBody', { requestId });
+            if (!result?.body)
+                return;
+            const data = result.base64Encoded
+                ? Buffer.from(result.body, 'base64').toString('utf-8')
+                : result.body;
+            // Check if body looks like ChatGPT SSE (contains "data: " lines and [DONE])
+            const isChatGPTSSE = data.includes('data: ') && data.includes('[DONE]');
+            // Check if body looks like Gemini response (starts with )]}')
+            const isGemini = data.startsWith(")]}'");
+            if (isChatGPTSSE || isGemini) {
                 this.frames.push({
                     timestamp: Date.now() / 1000,
                     type: 'fetch-body',
                     requestId,
-                    url,
+                    url: '<speculative>',
                     data,
                 });
+                console.error(`[NetworkInterceptor] Speculative capture hit: ${isChatGPTSSE ? 'ChatGPT SSE' : 'Gemini'} (${data.length} bytes)`);
             }
         }
-        catch (err) {
-            // Common: "No resource with given identifier" for redirects/cancelled requests
-            const msg = err instanceof Error ? err.message : String(err);
-            if (!msg.includes('No resource') && !msg.includes('No data found')) {
-                console.error(`[NetworkInterceptor] getResponseBody failed for ${url.slice(0, 80)}: ${msg}`);
-            }
-        }
-        finally {
-            this.pendingBodies.delete(requestId);
+        catch {
+            // Silent: speculative capture is best-effort
         }
     }
     stopCapture() {
@@ -212,14 +266,30 @@ export class NetworkInterceptor {
     }
     /**
      * Wait for all pending response body fetches, then stop capture.
+     * IMPORTANT: capturing remains true during the wait so that late-arriving
+     * loadingFinished events are still processed (this was the root cause of
+     * textLength=0 — setting capturing=false first dropped those events).
      */
-    async stopCaptureAndWait(timeoutMs = 3000) {
-        this.capturing = false; // Stop receiving new events
-        // Wait for pending body fetches
+    async stopCaptureAndWait(timeoutMs = 15000) {
+        // Phase 1: Wait for pending body fetches (capturing stays true)
         const deadline = Date.now() + timeoutMs;
         while (this.pendingBodies.size > 0 && Date.now() < deadline) {
             await new Promise(r => setTimeout(r, 100));
         }
+        // Phase 2: Grace period — if no frames captured yet, wait for late loadingFinished
+        if (this.frames.length === 0) {
+            const graceDeadline = Math.min(Date.now() + 3000, deadline);
+            console.error('[NetworkInterceptor] No frames yet, waiting grace period for late events...');
+            while (this.frames.length === 0 && Date.now() < graceDeadline) {
+                await new Promise(r => setTimeout(r, 100));
+                // Also wait for any new pending bodies that appeared during grace
+                while (this.pendingBodies.size > 0 && Date.now() < graceDeadline) {
+                    await new Promise(r => setTimeout(r, 100));
+                }
+            }
+        }
+        // Phase 3: Now stop capturing
+        this.capturing = false;
         // Warn if pending bodies remain after timeout
         if (this.pendingBodies.size > 0) {
             console.warn(`[NetworkInterceptor] Timeout: ${this.pendingBodies.size} pending bodies abandoned (requestIds: ${[...this.pendingBodies].slice(0, 3).join(', ')}${this.pendingBodies.size > 3 ? '...' : ''})`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-ai-bridge",
-  "version": "2.3.10",
+  "version": "2.4.0",
   "description": "MCP server bridging Chrome extension and AI assistants (ChatGPT, Gemini). Extension-only mode - no Puppeteer.",
   "type": "module",
   "bin": "./scripts/cli.mjs",