cdp-tunnel 2.4.3 → 2.5.0

package/extension-new/cdp/handler/special.js

@@ -59,12 +59,16 @@ var SpecialHandler = (function() {
         var sessionId = CDPUtils.generateSessionId();
         State.mapSession(sessionId, tabId, targetId);
 
-        // 保存tabId到clientId的映射
         if (clientId) {
           State.setTabIdToClientId(tabId, clientId);
         }
 
-        addTabToAutomationGroup(tabId, clientId);
+        if (State.isCDPCreatedTab(tabId)) {
+          addTabToAutomationGroup(tabId, clientId);
+        } else {
+          State.addPreExistingTab(tabId);
+          Logger.info('[CDP] Target.attachToTarget: user tab not CDP-created, treating as pre-existing. tabId:', tabId);
+        }
 
         return { sessionId: sessionId };
       });
@@ -110,10 +114,10 @@ var SpecialHandler = (function() {
         // 保存tabId到clientId的映射，用于后续分组
         if (clientId) {
           State.setTabIdToClientId(tab.id, clientId);
-          Logger.info('[TabGroup] Mapped tabId:', tab.id, '-> clientId:', clientId);
         }
 
-        // 将标签页添加到CDP Automation组，使用对应的clientId
+        State.addCDPCreatedTab(tab.id);
+
         addTabToAutomationGroup(tab.id, clientId);
 
         getTargetIdByTabId(tab.id).then(function(targetId) {
@@ -128,59 +132,53 @@ var SpecialHandler = (function() {
   function addTabToAutomationGroup(tabId, clientId) {
     Logger.info('[TabGroup] Starting addTabToAutomationGroup for tabId:', tabId, 'clientId:', clientId);
 
-    setTimeout(function() {
-      muteTabIfNeeded(tabId);
-    }, 500);
+    muteTabIfNeeded(tabId);
 
     var groupClientId = clientId;
     if (!groupClientId) {
-      var cdpClients = State.getCDPClients() || [];
-      if (cdpClients.length > 0 && cdpClients[0] && cdpClients[0].id) {
-        groupClientId = cdpClients[0].id;
-      }
+      Logger.warn('[TabGroup] No clientId for tab:', tabId, '— skipping group operation');
+      return;
     }
-
-    if (!groupClientId) return;
     var baseName = CDPUtils.getGroupBaseName(groupClientId);
     
-    setTimeout(function() {
-      Logger.info('[TabGroup] Executing group operation for:', baseName);
-      
-      chrome.tabGroups.query({}, function(allGroups) {
-        var existing = CDPUtils.findGroupByName(allGroups, baseName);
-        if (existing) {
-          chrome.tabs.group({ tabIds: tabId, groupId: existing.id }, function(result) {
-            if (chrome.runtime.lastError) {
-              Logger.error('[TabGroup] Failed to add tab to group:', chrome.runtime.lastError.message);
-            } else {
-              State.setGroupIdForClient(groupClientId, existing.id);
-              updateTabGroupName(groupClientId);
-            }
-          });
-        } else {
-          chrome.tabs.group({ tabIds: tabId }, function(groupId) {
-            if (chrome.runtime.lastError) {
-              Logger.error('[TabGroup] Failed to create group:', chrome.runtime.lastError.message);
-              return;
-            }
-            if (groupId) {
-              chrome.tabGroups.update(groupId, {
-                title: baseName,
-                color: CDPUtils.getGroupColorForClient(groupClientId),
-                collapsed: true
-              }, function() {
-                if (chrome.runtime.lastError) {
-                  Logger.error('[TabGroup] Failed to update group:', chrome.runtime.lastError.message);
-                } else {
-                  State.setGroupIdForClient(groupClientId, groupId);
-                  updateTabGroupName(groupClientId);
-                }
-              });
-            }
-          });
-        }
-      });
-    }, 2000);
+    Logger.info('[TabGroup] Executing group operation for:', baseName);
+    
+    chrome.tabGroups.query({}, function(allGroups) {
+      var existing = CDPUtils.findGroupByName(allGroups, baseName);
+      if (existing) {
+        chrome.tabs.group({ tabIds: tabId, groupId: existing.id }, function(result) {
+          if (chrome.runtime.lastError) {
+            Logger.error('[TabGroup] Failed to add tab to group:', chrome.runtime.lastError.message);
+          } else {
+            State.setGroupIdForClient(groupClientId, existing.id);
+            updateTabGroupName(groupClientId);
+            Logger.info('[TabGroup] Tab', tabId, 'added to existing group:', existing.id);
+          }
+        });
+      } else {
+        chrome.tabs.group({ tabIds: tabId }, function(groupId) {
+          if (chrome.runtime.lastError) {
+            Logger.error('[TabGroup] Failed to create group:', chrome.runtime.lastError.message);
+            return;
+          }
+          if (groupId) {
+            chrome.tabGroups.update(groupId, {
+              title: baseName,
+              color: CDPUtils.getGroupColorForClient(groupClientId),
+              collapsed: true
+            }, function() {
+              if (chrome.runtime.lastError) {
+                Logger.error('[TabGroup] Failed to update group:', chrome.runtime.lastError.message);
+              } else {
+                State.setGroupIdForClient(groupClientId, groupId);
+                updateTabGroupName(groupClientId);
+                Logger.info('[TabGroup] Created new group:', groupId, 'with tab:', tabId);
+              }
+            });
+          }
+        });
+      }
+    });
   }
 
   function updateTabGroupName(clientId) {
@@ -342,47 +340,44 @@ function checkTabVisibility(tabId) {
     return chrome.debugger.getTargets().then(function(targets) {
       var promises = [];
 
-      Logger.info('[CDP] emitAutoAttachForExistingTargets: checking', targets.length, 'targets');
-      Logger.info('[CDP] Current attachedTabIds:', State.getAttachedTabIds());
+      Logger.info('[CDP] emitAutoAttachForExistingTargets: checking', targets.length, 'targets, clientId:', clientId);
 
       targets.forEach(function(target) {
         if (target.type !== 'page' && target.type !== 'background_page') return;
         if (!target.tabId) return;
 
         var targetId = target.id;
+        var tabId = target.tabId;
         var hasEmitted = State.hasEmittedTarget(targetId);
-        Logger.info('[CDP] emitAutoAttachForExistingTargets: targetId=', targetId, 'tabId=', target.tabId, 'attached=', target.attached, 'hasEmitted=', hasEmitted);
 
         if (hasEmitted) {
-          Logger.info('[CDP] Target already emitted in emitAutoAttachForExistingTargets, skipping:', targetId);
+          Logger.info('[CDP] Target already emitted, skipping:', targetId);
           return;
         }
-        State.addEmittedTarget(targetId);
 
-        var isAttachedByUs = State.isTabAttached(target.tabId);
+        var isCDPCreated = State.isCDPCreatedTab(tabId);
+        var isOwnedByClient = isCDPCreated && State.getClientIdByTabId(tabId) === clientId;
+
+        if (!isOwnedByClient) {
+          Logger.info('[CDP] Skipping user/other-client tab:', targetId, 'tabId:', tabId, 'cdpCreated:', isCDPCreated);
+          State.addEmittedTarget(targetId);
+          return;
+        }
+
+        State.addEmittedTarget(targetId);
         var targetInfo = LocalHandler.mapToTargetInfo(target);
         
-        Logger.info('[CDP] isAttachedByUs=', isAttachedByUs, 'for tabId=', target.tabId);
-        
-        if (target.attached && !isAttachedByUs) {
-          targetInfo.attached = false;
-          Logger.info('[CDP] Target attached by another debugger, reporting as not attached:', targetId, 'tabId:', target.tabId);
-        }
+        Logger.info('[CDP] Emitting CDP-owned target:', targetId, 'tabId:', tabId);
         
         EventBuilder.send('Target.targetCreated', { targetInfo: targetInfo });
 
-        if (target.attached && isAttachedByUs) {
+        if (target.attached) {
           promises.push(Promise.resolve().then(function() {
             var sessionId = CDPUtils.generateSessionId();
-            State.mapSession(sessionId, target.tabId, targetId);
-
-            if (clientId) {
-              State.setTabIdToClientId(target.tabId, clientId);
-            }
-            State.addPreExistingTab(target.tabId);
+            State.mapSession(sessionId, tabId, targetId);
 
             if (config.waitForDebuggerOnStart) {
-              State.addPendingDebuggerTab(target.tabId);
+              State.addPendingDebuggerTab(tabId);
             }
 
             EventBuilder.send('Target.attachedToTarget', {
@@ -391,20 +386,15 @@ function checkTabVisibility(tabId) {
               waitingForDebugger: config.waitForDebuggerOnStart || false
             });
           }));
-        } else if (!target.attached) {
+        } else {
           promises.push(
-            DebuggerManager.attach(target.tabId).then(function(attached) {
+            DebuggerManager.attach(tabId).then(function(attached) {
               if (!attached) return;
               var sessionId = CDPUtils.generateSessionId();
-              State.mapSession(sessionId, target.tabId, targetId);
-
-              if (clientId) {
-                State.setTabIdToClientId(target.tabId, clientId);
-              }
-              State.addPreExistingTab(target.tabId);
+              State.mapSession(sessionId, tabId, targetId);
 
               if (config.waitForDebuggerOnStart) {
-                State.addPendingDebuggerTab(target.tabId);
+                State.addPendingDebuggerTab(tabId);
               }
 
               EventBuilder.send('Target.attachedToTarget', {

package/extension-new/core/state.js

@@ -25,7 +25,8 @@ var State = (function() {
     clientIdToSessionId: new Map(),
     tabIdToClientId: new Map(),
     clientIdToGroupId: new Map(),
-    preExistingTabIds: new Set()
+    preExistingTabIds: new Set(),
+    cdpCreatedTabIds: new Set()
   };
 
   function mapSession(sessionId, tabId, targetId) {
@@ -254,6 +255,14 @@ var State = (function() {
     _state.emittedTargets.clear();
   }
 
+  function addCDPCreatedTab(tabId) {
+    _state.cdpCreatedTabIds.add(tabId);
+  }
+
+  function isCDPCreatedTab(tabId) {
+    return _state.cdpCreatedTabIds.has(tabId);
+  }
+
   function clearAllState() {
     clearSessionState();
     _state.attachedTabIds.clear();
@@ -275,6 +284,7 @@ var State = (function() {
     _state.pendingDebuggerTabs.clear();
     _state.automatedTabs.clear();
     _state.pendingCreatedTabUrls.clear();
+    _state.cdpCreatedTabIds.clear();
     _state.cdpClients = [];
   }
 
@@ -494,6 +504,8 @@ var State = (function() {
     isPreExistingTab: isPreExistingTab,
     getPreExistingTabs: getPreExistingTabs,
     removePreExistingTab: removePreExistingTab,
-    clearPreExistingTabsForClient: clearPreExistingTabsForClient
+    clearPreExistingTabsForClient: clearPreExistingTabsForClient,
+    addCDPCreatedTab: addCDPCreatedTab,
+    isCDPCreatedTab: isCDPCreatedTab
   };
 })();

package/extension-new/core/websocket.js

@@ -24,6 +24,9 @@ var WebSocketManager = (function() {
           State.clearReconnectTimer();
           processQueue();
           broadcastStateUpdate();
+          var extVersion = (typeof chrome !== 'undefined' && chrome.runtime && chrome.runtime.getManifest) 
+            ? chrome.runtime.getManifest().version : 'unknown';
+          send({ type: 'plugin-hello', version: extVersion });
         };
 
         ws.onclose = function(event) {
@@ -208,7 +211,6 @@ var WebSocketManager = (function() {
             State.removeAttachedTab(tabId);
           });
           State.clearPreExistingTabsForClient(discClientId);
-
           State.removeCDPClient(discClientId);
           if (State.getCDPClients().length === 0) {
             State.setHasConnectedClient(false);
@@ -286,6 +288,7 @@ var WebSocketManager = (function() {
   }
 
   function closeGroupById(groupId, clientId, resolve) {
+    Logger.info('[WS] closeGroupById: groupId=' + groupId + ' clientId=' + clientId);
     chrome.tabs.query({ groupId: groupId }, function(tabs) {
         if (!tabs || tabs.length === 0) {
             Logger.info('[WS] No tabs in group:', groupId);
@@ -294,9 +297,22 @@ var WebSocketManager = (function() {
             return;
         }
         
-        var tabIds = tabs.map(function(tab) { return tab.id; });
-        Logger.info('[WS] Closing ' + tabIds.length + ' tabs in group:', groupId);
+        var ownTabs = tabs.filter(function(tab) {
+          return State.getClientIdByTabId(tab.id) === clientId;
+        });
+        var otherTabs = tabs.filter(function(tab) {
+          return State.getClientIdByTabId(tab.id) !== clientId;
+        });
+        var tabIds = ownTabs.map(function(tab) { return tab.id; });
+        Logger.info('[WS] Closing ' + tabIds.length + ' tabs in group (skipping ' + otherTabs.length + ' from other clients):', groupId);
         
+        if (tabIds.length === 0) {
+          Logger.info('[WS] No own tabs to close in group:', groupId);
+          State.removeGroupForClient(clientId);
+          resolve();
+          return;
+        }
+
         chrome.tabs.remove(tabIds, function() {
             if (chrome.runtime.lastError) {
                 Logger.error('[WS] Failed to close tabs:', chrome.runtime.lastError.message);
@@ -318,12 +334,19 @@ var WebSocketManager = (function() {
     var attachedTabs = State.getAttachedTabIds();
     var tabsToClose = [];
     
+    Logger.info('[WS] closeTabsByClientId: clientId=' + clientId + ' attachedTabs=' + JSON.stringify(attachedTabs));
     attachedTabs.forEach(function(tabId) {
-      if (State.getClientIdByTabId(tabId) === clientId && !State.isPreExistingTab(tabId)) {
+      var tabClientId = State.getClientIdByTabId(tabId);
+      var isPre = State.isPreExistingTab(tabId);
+      var isCDP = State.isCDPCreatedTab(tabId);
+      Logger.info('[WS]   tabId=' + tabId + ' clientId=' + tabClientId + ' isPre=' + isPre + ' isCDP=' + isCDP);
+      if (tabClientId === clientId && !isPre) {
         tabsToClose.push(tabId);
       }
     });
     
+    Logger.info('[WS] closeTabsByClientId: will close ' + tabsToClose.length + ' tabs');
+    
     if (tabsToClose.length === 0) {
       Logger.info('[WS] No attached tabs found for clientId:', clientId);
       resolve();

package/extension-new/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "CDP Bridge",
-  "version": "2.4.3",
+  "version": "2.5.0",
   "description": "Chrome DevTools Protocol Bridge for Playwright/Puppeteer automation",
   "permissions": [
     "debugger",

package/extension-new/utils/config.js

@@ -1,5 +1,5 @@
 var Config = {
-  WS_URL: 'ws://localhost:9221/plugin',
+  WS_URL: 'ws://localhost:43930/plugin',
   RECONNECT_DELAY: 3000,
   DEBUGGER_VERSION: '1.3',
   HEARTBEAT_INTERVAL: 25000,

package/extension-new/utils/helpers.js

@@ -44,8 +44,7 @@ var CDPUtils = (function() {
 
   function buildGroupName(clientId) {
     if (!clientId) return 'CDP';
-    var idx = getClientIndex(clientId);
-    return idx > 0 ? ('CDP #' + idx) : ('CDP-' + clientId.substring(0, 6));
+    return 'CDP-' + clientId.substring(0, 8);
   }
 
   function getGroupBaseName(clientId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdp-tunnel",
-  "version": "2.4.3",
+  "version": "2.5.0",
   "description": "Bridge Chrome's debugger API to WebSocket — control your existing browser with Playwright/Puppeteer via CDP",
   "main": "server/proxy-server.js",
   "bin": "./cli/index.js",

package/server/proxy-server.js

@@ -150,6 +150,7 @@ const clientIdToPlugin = new Map();
 const globalRequestIdMap = new Map();
 const targetIdToClientId = new Map();
 const pendingAttachedEvents = new Map();
+const pendingTargetCreatedEvents = new Map();
 const browserContextToClientId = new Map();
 const clientIdToBrowserContext = new Map();
 let globalRequestIdCounter = 0;
@@ -448,8 +449,22 @@ function handlePluginConnection(ws, clientInfo) {
             logConnectionEvent('KEEPALIVE_RECEIVED', { type: 'plugin', id: ws.id });
             return;
         }
+
+        if (parsed && parsed.type === 'plugin-hello') {
+            const extVersion = parsed.version || 'unknown';
+            ws.extVersion = extVersion;
+            const match = extVersion === PKG_VERSION;
+            const level = match ? 'info' : 'warn';
+            const label = match ? '✅' : '⚠️ VERSION MISMATCH';
+            const msg = `[VERSION CHECK] ${label} server=${PKG_VERSION} extension=${extVersion}`;
+            console.log(msg);
+            logCDP('VERSION', msg);
+            if (!match) {
+                console.log(`  ↳ Run "cdp-tunnel update" or reload the extension to sync versions`);
+            }
+            return;
+        }
         
-        // 调试：打印所有收到的消息
         console.log(`[PLUGIN MSG] id=${parsed?.id} method=${parsed?.method || 'none'} type=${parsed?.type || 'none'} sessionId=${parsed?.sessionId?.substring(0,8) || 'none'}`);
 
         // 记录所有 PLUGIN -> CLIENT 消息到日志文件
@@ -494,9 +509,12 @@ function handlePluginConnection(ws, clientInfo) {
                         clientWs.send(cdpData);
                         console.log(`[TARGET EVENT ROUTED] ${parsed.method} targetId=${targetId?.substring(0,8)} -> clientId=${eventClientId}`);
                     }
+                } else if (targetId && (parsed.method === 'Target.targetCreated' || parsed.method === 'Target.attachedToTarget')) {
+                    const pendingMap = parsed.method === 'Target.targetCreated' ? pendingTargetCreatedEvents : pendingAttachedEvents;
+                    pendingMap.set(targetId, { parsed: JSON.parse(JSON.stringify(parsed)), cdpData });
+                    console.log(`[TARGET EVENT PENDING] ${parsed.method} targetId=${targetId?.substring(0,8)} (cached, waiting for createTarget response)`);
                 } else {
-                    console.log(`[TARGET EVENT BROADCAST] ${parsed.method} targetId=${targetId?.substring(0,8) || 'none'} (no owner, broadcasting)`);
-                    broadcastToClients(cdpData, null);
+                    console.log(`[TARGET EVENT DROPPED] ${parsed.method} targetId=${targetId?.substring(0,8) || 'none'} (no owner, dropped for isolation)`);
                 }
             }
             
@@ -576,20 +594,23 @@ function handlePluginConnection(ws, clientInfo) {
                     if (mapping.isCreateTarget && parsed.result?.targetId) {
                         const targetId = parsed.result.targetId;
                         targetIdToClientId.set(targetId, mapping.clientId);
-                        console.log(`[TARGET MAPPED] targetId=${targetId} -> clientId=${mapping.clientId}`);
+                        console.log(`[TARGET MAPPED] targetId=${targetId} -> clientId=${mapping.clientId} mapSize=${targetIdToClientId.size}`);
+                        
+                        const cachedCreated = pendingTargetCreatedEvents.get(targetId);
+                        if (cachedCreated) {
+                            clientWs.send(cachedCreated.cdpData);
+                            console.log(`[TARGET CREATED EVENT] Sent cached Target.targetCreated to client: ${mapping.clientId}`);
+                            pendingTargetCreatedEvents.delete(targetId);
+                        }
                         
-                        // 检查是否有缓存的 Target.attachedToTarget 事件
                         const cachedEvent = pendingAttachedEvents.get(targetId);
                         if (cachedEvent) {
-                            if (cachedEvent.sessionId) {
-                                sessionToClientId.set(cachedEvent.sessionId, mapping.clientId);
+                            if (cachedEvent.parsed.sessionId) {
+                                sessionToClientId.set(cachedEvent.parsed.sessionId, mapping.clientId);
                             }
-                            console.log(`[SESSION MAPPED from cached] sessionId=${cachedEvent.sessionId?.substring(0,8) || 'none'} -> clientId=${mapping.clientId} (targetId=${targetId})`);
+                            console.log(`[SESSION MAPPED from cached] sessionId=${cachedEvent.parsed.sessionId?.substring(0,8) || 'none'} -> clientId=${mapping.clientId} (targetId=${targetId})`);
                             pendingAttachedEvents.delete(targetId);
                             
-                            // 先发送缓存的事件给客户端
-                            // 注意：Target.attachedToTarget 事件必须发送给 root session（没有顶层 sessionId）
-                            // sessionId 在 params 里面，不在消息顶层
                             const cdpMsg = {
                                 method: cachedEvent.parsed.method,
                                 params: cachedEvent.parsed.params
@@ -606,7 +627,7 @@ function handlePluginConnection(ws, clientInfo) {
                         parsed.result.targetInfos = parsed.result.targetInfos.filter(t => {
                             if (t.type !== 'page') return true;
                             const ownerClient = targetIdToClientId.get(t.targetId);
-                            return !ownerClient || ownerClient === clientId;
+                            return ownerClient === clientId;
                         });
                         console.log(`[GET TARGETS FILTERED] client=${clientId} returned ${parsed.result.targetInfos.filter(t => t.type === 'page').length} page targets`);
                     }