cdp-tunnel 2.7.4 → 2.7.6

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

@@ -65,8 +65,7 @@ var SpecialHandler = (function() {
 
         if (State.isCDPCreatedTab(tabId)) {
           addTabToAutomationGroup(tabId, clientId);
-        } else {
-          State.addPreExistingTab(tabId);
+        } else {          State.addPreExistingTab(tabId);
           Logger.info('[CDP] Target.attachToTarget: user tab not CDP-created, treating as pre-existing. tabId:', tabId);
         }
 
@@ -141,12 +140,9 @@ var SpecialHandler = (function() {
 
   function groupTabSilently(tabId, clientId) {
     return new Promise(function(resolve) {
-      try {
-        addTabToAutomationGroup(tabId, clientId);
-      } catch (e) {
-        Logger.error('[TabGroup] addTabToAutomationGroup threw:', e.message || e);
-      }
-      setTimeout(resolve, 100);
+      addTabToAutomationGroup(tabId, clientId, function(success) {
+        setTimeout(resolve, 50);
+      });
     });
   }
 
@@ -162,7 +158,7 @@ var SpecialHandler = (function() {
     });
   }
 
-  function addTabToAutomationGroup(tabId, clientId) {
+  function addTabToAutomationGroup(tabId, clientId, callback) {
     Logger.info('[TabGroup] Starting addTabToAutomationGroup for tabId:', tabId, 'clientId:', clientId);
 
     WebSocketManager.send({ type: 'tabgroup-debug', tabId: tabId, clientId: clientId, phase: 'start' });
@@ -183,21 +179,23 @@ var SpecialHandler = (function() {
         Logger.warn('[TabGroup] No clientId for tab:', tabId, 'fallback to first client:', groupClientId);
       } else {
         Logger.warn('[TabGroup] No clientId for tab:', tabId, '— skipping group operation');
+        if (callback) callback(false);
         return;
       }
     }
     var baseName = CDPUtils.getGroupBaseName(groupClientId);
 
     Logger.info('[TabGroup] Grouping tab immediately for:', baseName);
-    doGroup(tabId, groupClientId, baseName);
+    doGroup(tabId, groupClientId, baseName, 0, callback);
   }
 
-  function doGroup(tabId, clientId, baseName, retries) {
+  function doGroup(tabId, clientId, baseName, retries, callback) {
     retries = retries || 0;
     Logger.info('[TabGroup] doGroup: tabId=' + tabId + ' clientId=' + (clientId || 'none') + ' baseName=' + baseName + ' retry=' + retries);
     if (!chrome.tabGroups) {
       Logger.warn('[TabGroup] chrome.tabGroups API not available (headless mode?), skipping grouping for tab:', tabId);
       EventBuilder.send('CDPTunnel.debug', { source: 'doGroup', phase: 'skip', reason: 'tabGroups-unavailable', tabId: tabId });
+      if (callback) callback(false);
       return;
     }
     chrome.tabGroups.query({}, function(allGroups) {
@@ -214,12 +212,15 @@ var SpecialHandler = (function() {
             Logger.error('[TabGroup] Failed to add tab to group:', chrome.runtime.lastError.message, 'retries:', retries);
             EventBuilder.send('CDPTunnel.debug', { source: 'doGroup', phase: 'addToExisting', error: chrome.runtime.lastError.message, tabId: tabId, groupId: existing.id });
             if (retries < 3) {
-              setTimeout(function() { doGroup(tabId, clientId, baseName, retries + 1); }, 500);
+              setTimeout(function() { doGroup(tabId, clientId, baseName, retries + 1, callback); }, 500);
+            } else {
+              if (callback) callback(false);
             }
           } else {
             State.setGroupIdForClient(clientId, existing.id);
             updateTabGroupName(clientId);
             Logger.info('[TabGroup] Tab', tabId, 'added to existing group:', existing.id);
+            if (callback) callback(true);
           }
         });
       } else {
@@ -229,7 +230,9 @@ var SpecialHandler = (function() {
             Logger.error('[TabGroup] Failed to create group:', chrome.runtime.lastError.message, 'retries:', retries);
             EventBuilder.send('CDPTunnel.debug', { source: 'doGroup', phase: 'createGroup', error: chrome.runtime.lastError.message, tabId: tabId });
             if (retries < 3) {
-              setTimeout(function() { doGroup(tabId, clientId, baseName, retries + 1); }, 500);
+              setTimeout(function() { doGroup(tabId, clientId, baseName, retries + 1, callback); }, 500);
+            } else {
+              if (callback) callback(false);
             }
             return;
           }
@@ -250,13 +253,16 @@ var SpecialHandler = (function() {
                   updateTabGroupName(clientId);
                   Logger.info('[TabGroup] Group updated:', groupId, baseName);
                 }
+                if (callback) callback(true);
               });
             } else {
               State.setGroupIdForClient(clientId, groupId);
               Logger.info('[TabGroup] Group created but tabGroups.update unavailable (headless):', groupId);
+              if (callback) callback(true);
             }
           } else {
             Logger.error('[TabGroup] chrome.tabs.group returned null groupId');
+            if (callback) callback(false);
           }
         });
       }

package/extension-new/core/websocket.js

@@ -281,22 +281,50 @@ var WebSocketManager = (function() {
     Logger.info('[WS] Closing tab group for client:', clientId);
     
     return new Promise(function(resolve) {
-        var groupId = State.getGroupIdForClient(clientId);
+      var timeoutId = setTimeout(function() {
+        Logger.warn('[WS] closeTabGroupByClientId timeout for client:', clientId, '— forcing cleanup');
+        cleanupStaleState(clientId);
+        resolve();
+      }, 5000);
         
-        if (groupId) {
-            closeGroupById(groupId, clientId, resolve);
-        } else {
-            var baseName = CDPUtils.getGroupBaseName(clientId);
-            chrome.tabGroups.query({}, function(allGroups) {
-                var match = CDPUtils.findGroupByName(allGroups, baseName);
-                if (match) {
-                    closeGroupById(match.id, clientId, resolve);
-                } else {
-                    Logger.info('[WS] No tab group found, closing tabs by clientId:', clientId);
-                    closeTabsByClientId(clientId, resolve);
-                }
+      var groupId = State.getGroupIdForClient(clientId);
+      
+      if (groupId) {
+        closeGroupById(groupId, clientId, function() {
+          clearTimeout(timeoutId);
+          cleanupStaleState(clientId);
+          resolve();
+        });
+      } else {
+        var baseName = CDPUtils.getGroupBaseName(clientId);
+        chrome.tabGroups.query({}, function(allGroups) {
+          var match = CDPUtils.findGroupByName(allGroups, baseName);
+          if (match) {
+            closeGroupById(match.id, clientId, function() {
+              clearTimeout(timeoutId);
+              cleanupStaleState(clientId);
+              resolve();
             });
-        }
+          } else {
+            Logger.info('[WS] No tab group found, closing tabs by clientId:', clientId);
+            closeTabsByClientId(clientId, function() {
+              clearTimeout(timeoutId);
+              cleanupStaleState(clientId);
+              resolve();
+            });
+          }
+        });
+      }
+    });
+  }
+
+  function cleanupStaleState(clientId) {
+    if (!clientId) return;
+    var attachedTabs = State.getAttachedTabIds();
+    attachedTabs.forEach(function(tabId) {
+      if (State.getClientIdByTabId(tabId) === clientId) {
+        State.removeTabIdToClientId(tabId);
+      }
     });
   }
 
@@ -306,6 +334,7 @@ var WebSocketManager = (function() {
         if (!tabs || tabs.length === 0) {
             Logger.info('[WS] No tabs in group:', groupId);
             State.removeGroupForClient(clientId);
+            removeEmptyGroup(groupId);
             resolve();
             return;
         }
@@ -338,11 +367,33 @@ var WebSocketManager = (function() {
             });
             
             State.removeGroupForClient(clientId);
+            removeEmptyGroup(groupId);
             resolve();
         });
     });
   }
 
+  function removeEmptyGroup(groupId) {
+    if (!groupId || !chrome.tabGroups) return;
+    setTimeout(function() {
+      chrome.tabGroups.query({ groupId: groupId }, function(groups) {
+        if (chrome.runtime.lastError) return;
+        if (groups && groups.length > 0) {
+          chrome.tabs.query({ groupId: groupId }, function(tabs) {
+            if (chrome.runtime.lastError) return;
+            if (!tabs || tabs.length === 0) {
+              chrome.tabGroups.remove(groupId, function() {
+                if (!chrome.runtime.lastError) {
+                  Logger.info('[WS] Removed empty group:', groupId);
+                }
+              });
+            }
+          });
+        }
+      });
+    }, 500);
+  }
+
   function closeTabsByClientId(clientId, resolve) {
     var attachedTabs = State.getAttachedTabIds();
     var cdpCreatedTabs = State.getCDPCreatedTabIds();

package/extension-new/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "CDP Bridge",
-  "version": "2.7.4",
+  "version": "2.7.6",
   "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:58288/plugin',
   RECONNECT_DELAY: 3000,
   DEBUGGER_VERSION: '1.3',
   HEARTBEAT_INTERVAL: 25000,

package/extension-new/utils/helpers.js

@@ -44,7 +44,13 @@ var CDPUtils = (function() {
 
   function buildGroupName(clientId) {
     if (!clientId) return 'CDP';
-    var suffix = clientId.length > 8 ? clientId.substring(clientId.length - 8) : clientId;
+    var hash = 0;
+    for (var i = 0; i < clientId.length; i++) {
+      var chr = clientId.charCodeAt(i);
+      hash = ((hash << 5) - hash) + chr;
+      hash = hash | 0;
+    }
+    var suffix = Math.abs(hash).toString(16).substring(0, 8).padStart(8, '0');
     return 'CDP-' + suffix;
   }
 
@@ -55,7 +61,7 @@ var CDPUtils = (function() {
   function findGroupByName(allGroups, baseName) {
     for (var i = 0; i < allGroups.length; i++) {
       var g = allGroups[i];
-      if (g.title && g.title.indexOf(baseName) === 0) return g;
+      if (g.title === baseName || (g.title && g.title.indexOf(baseName + ' (') === 0)) return g;
     }
     return null;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdp-tunnel",
-  "version": "2.7.4",
+  "version": "2.7.6",
   "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",
@@ -16,6 +16,10 @@
     "benchmark:proxy": "node benchmark/run-all.js --proxy",
     "demo": "node demo/server.js",
     "test:compare": "node tests/cdp-compare/cdp-compare-runner.js",
+    "test": "node tests/e2e/run-all.js",
+    "test:e2e": "node tests/e2e/run-all.js",
+    "test:core": "SKIP_EXTENDED=1 node tests/e2e/run-all.js",
+    "test:smoke": "ONLY=test-default-page,test-strict-isolation,test-no-user-tab-grab node tests/e2e/run-all.js",
     "prepare": "husky"
   },
   "keywords": [

package/server/proxy-server.js

@@ -487,11 +487,33 @@ function cleanupClient(ws, id, reason) {
     }
 
     if (ws.pairedPlugin) {
-        safeSend(ws.pairedPlugin, JSON.stringify({
+        const sendOk = safeSend(ws.pairedPlugin, JSON.stringify({
             type: 'client-disconnected',
             clientId: id,
             sessions: []
         }), 'plugin');
+        if (!sendOk) {
+            console.log(`[WARN] cleanupClient: failed to send client-disconnected for ${id} to plugin`);
+        }
+
+        const pluginNs = getNamespace(ws.pairedPlugin);
+        if (pluginNs) {
+            const targetsToClose = [];
+            for (const [tId, cId] of pluginNs.targetIdToClientId.entries()) {
+                if (cId === id) {
+                    targetsToClose.push(tId);
+                }
+            }
+            targetsToClose.forEach(function(tId) {
+                const closeReq = JSON.stringify({
+                    id: -1,
+                    method: 'Target.closeTarget',
+                    params: { targetId: tId },
+                    __clientId: id
+                });
+                safeSend(ws.pairedPlugin, closeReq, 'plugin');
+            });
+        }
     }
 
     broadcastClientList();
@@ -797,25 +819,7 @@ function handlePluginConnection(ws, clientInfo, request) {
                         pendingMap.set(targetId, { parsed: JSON.parse(JSON.stringify(parsed)), cdpData });
                         console.log(`[TARGET EVENT PENDING] ${parsed.method} targetId=${targetId?.substring(0,8) || 'none'} (cached, waiting for createTarget response)`);
                     } else {
-                        // Broadcast to discovering clients
-                        let routedToDiscoverer = false;
-                        if (ns.discoveringClientIds.size > 0) {
-                            for (const [discClientId, timestamp] of ns.discoveringClientIds) {
-                                if (Date.now() - timestamp < 30000) {
-                                    const discWs = clientById.get(discClientId);
-                                    if (discWs && discWs.readyState === WebSocket.OPEN) {
-                                        discWs.send(cdpData);
-                                        routedToDiscoverer = true;
-                                    }
-                                } else {
-                                    ns.discoveringClientIds.delete(discClientId);
-                                }
-                            }
-                        }
-                        if (!routedToDiscoverer) {
-                            pendingMap.set(targetId, { parsed: JSON.parse(JSON.stringify(parsed)), cdpData });
-                            console.log(`[TARGET EVENT PENDING] ${parsed.method} targetId=${targetId?.substring(0,8) || 'none'} (cached, no discoverer)`);
-                        }
+                        console.log(`[TARGET EVENT DROPPED] ${parsed.method} targetId=${targetId?.substring(0,8) || 'none'} (no owner, dropped for isolation)`);
                     }
                 } else {
                     console.log(`[TARGET EVENT DROPPED] ${parsed.method} targetId=${targetId?.substring(0,8) || 'none'} (no owner, dropped for isolation)`);
@@ -948,15 +952,33 @@ function handlePluginConnection(ws, clientInfo, request) {
                         invalidateTargetsCache(ws);
                     }
                     
-                    const originalId = mapping.originalId;
-                    parsed.id = originalId;
-                    if (mapping.sessionId && !parsed.sessionId) {
-                        parsed.sessionId = mapping.sessionId;
+                    if (mapping.isAutoDefaultPage) {
+                        console.log(`[AUTO DEFAULT PAGE] createTarget response received for client=${mapping.clientId}, targetId=${parsed.result?.targetId?.substring(0,8) || 'none'} — skipping response send to client`);
+                        
+                        if (mapping.pendingSetAutoAttach) {
+                            const pending = mapping.pendingSetAutoAttach;
+                            const pendingParsed = pending.parsed;
+                            const pendingClientId = pending.clientId;
+                            
+                            console.log(`[AUTO DEFAULT PAGE] Now forwarding pending setAutoAttach for client=${pendingClientId}`);
+                            
+                            if (ws.readyState === WebSocket.OPEN) {
+                                const forwardMsg = { ...pendingParsed, __clientId: pendingClientId };
+                                ws.send(JSON.stringify(forwardMsg));
+                                console.log(`[SEND TO PLUGIN] Forwarding setAutoAttach for client=${pendingClientId}`);
+                            }
+                        }
+                    } else {
+                        const originalId = mapping.originalId;
+                        parsed.id = originalId;
+                        if (mapping.sessionId && !parsed.sessionId) {
+                            parsed.sessionId = mapping.sessionId;
+                        }
+                        const responseStr = JSON.stringify(parsed);
+                        console.log(`[SEND TO CLIENT] ${responseStr.substring(0, 300)}`);
+                        clientWs.send(responseStr);
+                        console.log(`[ROUTE] Response global=${globalId} -> original=${originalId} -> client=${mapping.clientId} sessionId=${parsed.sessionId?.substring(0,8) || 'none'}`);
                     }
-                    const responseStr = JSON.stringify(parsed);
-                    console.log(`[SEND TO CLIENT] ${responseStr.substring(0, 300)}`);
-                    clientWs.send(responseStr);
-                    console.log(`[ROUTE] Response global=${globalId} -> original=${originalId} -> client=${mapping.clientId} sessionId=${parsed.sessionId?.substring(0,8) || 'none'}`);
                 }
                 globalRequestIdMap.delete(globalId);
             } else {
@@ -1052,6 +1074,52 @@ function handlePluginConnection(ws, clientInfo, request) {
     }));
 }
 
+function autoCreateDefaultPageAndForward(clientWs, setAutoAttachParsed, originalData, clientId, originalRequestId) {
+    const pluginWs = clientWs.pairedPlugin;
+    if (!pluginWs || pluginWs.readyState !== WebSocket.OPEN) {
+        forwardToPlugin(clientWs, originalData, clientId);
+        return;
+    }
+
+    globalRequestIdCounter++;
+    const createGlobalId = globalRequestIdCounter;
+
+    globalRequestIdMap.set(createGlobalId, {
+        clientId: clientId,
+        originalId: -1,
+        sessionId: null,
+        method: 'Target.createTarget',
+        isCreateTarget: true,
+        isAutoDefaultPage: true,
+        pendingSetAutoAttach: {
+            parsed: setAutoAttachParsed,
+            data: originalData,
+            clientId: clientId,
+            originalRequestId: originalRequestId
+        }
+    });
+
+    const request = {
+        id: createGlobalId,
+        method: 'Target.createTarget',
+        params: { url: 'about:blank' },
+        __clientId: clientId
+    };
+
+    console.log(`[AUTO DEFAULT PAGE] Sending Target.createTarget for client=${clientId} globalId=${createGlobalId}, will forward setAutoAttach after`);
+    pluginWs.send(JSON.stringify(request));
+}
+
+function forwardToPlugin(clientWs, data, clientId) {
+    const pluginWs = clientWs.pairedPlugin;
+    if (pluginWs && pluginWs.readyState === WebSocket.OPEN) {
+        console.log(`[SEND TO PLUGIN] method=Target.setAutoAttach clientId=${clientId}`);
+        pluginWs.send(data);
+    } else {
+        broadcastToPlugins(data, clientWs);
+    }
+}
+
 /**
  * 处理 CDP 客户端连接 (Playwright/Puppeteer)
  */
@@ -1254,6 +1322,12 @@ function handleClientConnection(ws, clientInfo, customClientId = null, targetPlu
             }
         }
 
+        if (parsed && parsed.method === 'Target.setAutoAttach' && parsed.params?.autoAttach && !ws._autoDefaultPageSent) {
+            ws._autoDefaultPageSent = true;
+            autoCreateDefaultPageAndForward(ws, parsed, modifiedData, id, originalId);
+            return;
+        }
+
         if (parsed && parsed.method === 'Browser.close') {
             if (shouldLog('info')) {
                 console.log(`\n[BROWSER CLOSE] Client ${id} requested Browser.close, forwarding to plugin`);