cdp-tunnel 2.5.22 → 2.6.0

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

@@ -422,51 +422,51 @@ function checkTabVisibility(tabId) {
 
         var isCDPCreated = State.isCDPCreatedTab(tabId);
         var isOwnedByClient = isCDPCreated && State.getClientIdByTabId(tabId) === clientId;
+        var otherClientOwns = isCDPCreated && !isOwnedByClient;
 
-        if (!isOwnedByClient) {
-          Logger.info('[CDP] Skipping user/other-client tab:', targetId, 'tabId:', tabId, 'cdpCreated:', isCDPCreated);
+        if (otherClientOwns) {
+          Logger.info('[CDP] Skipping other-client tab:', targetId, 'tabId:', tabId);
           State.addEmittedTarget(targetId);
           return;
         }
 
         State.addEmittedTarget(targetId);
         var targetInfo = LocalHandler.mapToTargetInfo(target);
+        var isPreExisting = !isCDPCreated;
         
-        Logger.info('[CDP] Emitting CDP-owned target:', targetId, 'tabId:', tabId);
+        Logger.info('[CDP] Emitting target:', targetId, 'tabId:', tabId, 'preExisting:', isPreExisting);
         
         EventBuilder.send('Target.targetCreated', { targetInfo: targetInfo });
 
-        if (target.attached) {
-          promises.push(Promise.resolve().then(function() {
-            var sessionId = CDPUtils.generateSessionId();
-            State.mapSession(sessionId, tabId, targetId);
+        var attachLogic = function(attached) {
+          var sessionId = CDPUtils.generateSessionId();
+          State.mapSession(sessionId, tabId, targetId);
 
-            if (config.waitForDebuggerOnStart) {
-              State.addPendingDebuggerTab(tabId);
-            }
+          if (isPreExisting && clientId) {
+            State.setTabIdToClientId(tabId, clientId);
+          }
+          if (isPreExisting) {
+            State.addPreExistingTab(tabId);
+          }
 
-            EventBuilder.send('Target.attachedToTarget', {
-              sessionId: sessionId,
-              targetInfo: Object.assign({}, targetInfo, { attached: true }),
-              waitingForDebugger: config.waitForDebuggerOnStart || false
-            });
-          }));
+          if (config.waitForDebuggerOnStart) {
+            State.addPendingDebuggerTab(tabId);
+          }
+
+          EventBuilder.send('Target.attachedToTarget', {
+            sessionId: sessionId,
+            targetInfo: Object.assign({}, targetInfo, { attached: true }),
+            waitingForDebugger: config.waitForDebuggerOnStart || false
+          });
+        };
+
+        if (target.attached) {
+          promises.push(Promise.resolve().then(function() { attachLogic(true); }));
         } else {
           promises.push(
             DebuggerManager.attach(tabId).then(function(attached) {
               if (!attached) return;
-              var sessionId = CDPUtils.generateSessionId();
-              State.mapSession(sessionId, tabId, targetId);
-
-              if (config.waitForDebuggerOnStart) {
-                State.addPendingDebuggerTab(tabId);
-              }
-
-              EventBuilder.send('Target.attachedToTarget', {
-                sessionId: sessionId,
-                targetInfo: Object.assign({}, targetInfo, { attached: true }),
-                waitingForDebugger: config.waitForDebuggerOnStart || false
-              });
+              attachLogic(attached);
             })
           );
         }

package/extension-new/core/debugger.js

@@ -33,25 +33,12 @@ var DebuggerManager = (function() {
     if (tagName.toLowerCase() === 'iframe') {
       var originalSetAttribute = element.setAttribute;
       element.setAttribute = function(name, value) {
-        if (name.toLowerCase() === 'src' && isInternalUrl(value)) {
+        if (name.toLowerCase() === 'src' && isInternalUrl(String(value || ''))) {
           console.warn('[CDP-BLOCK] Blocked iframe src:', value);
-          return;
+          return element;
         }
         return originalSetAttribute.call(this, name, value);
       };
-      
-      Object.defineProperty(element, 'src', {
-        set: function(value) {
-          if (isInternalUrl(value)) {
-            console.warn('[CDP-BLOCK] Blocked iframe src via property:', value);
-            return;
-          }
-          originalSetAttribute.call(this, 'src', value);
-        },
-        get: function() {
-          return element.getAttribute('src');
-        }
-      });
     }
     return element;
   };
@@ -68,18 +55,25 @@ var DebuggerManager = (function() {
   
   // 拦截 location 修改
   var locationDescriptor = Object.getOwnPropertyDescriptor(window, 'location');
-  Object.defineProperty(window, 'location', {
-    set: function(value) {
-      if (isInternalUrl(String(value))) {
-        console.warn('[CDP-BLOCK] Blocked location change:', value);
-        return;
-      }
-      locationDescriptor.set.call(window, value);
-    },
-    get: function() {
-      return locationDescriptor.get.call(window);
+  if (locationDescriptor && typeof locationDescriptor.set === 'function') {
+    try {
+      Object.defineProperty(window, 'location', {
+        set: function(value) {
+          if (isInternalUrl(String(value))) {
+            console.warn('[CDP-BLOCK] Blocked location change:', value);
+            return;
+          }
+          locationDescriptor.set.call(window, value);
+        },
+        get: function() {
+          return locationDescriptor.get.call(window);
+        },
+        configurable: true
+      });
+    } catch(e) {
+      // location property cannot be redefined on some contexts, skip silently
     }
-  });
+  }
   
   console.log('[CDP-BLOCK] Internal URL block script injected');
 })();
@@ -222,17 +216,22 @@ var DebuggerManager = (function() {
         return;
       }
       
-      // 在新的执行上下文中也注入拦截脚本
+      // 在新的执行上下文中也注入拦截脚本（data: URL 上下文跳过，避免干扰导航）
       if (isDefaultContext) {
-        chrome.debugger.sendCommand(
-          { tabId: source.tabId },
-          'Runtime.evaluate',
-          { 
-            expression: INTERNAL_URL_BLOCK_SCRIPT,
-            contextId: context.id,
-            runImmediately: true
-          }
-        ).catch(function() {});
+        chrome.tabs.get(source.tabId, function(tab) {
+          if (chrome.runtime.lastError) return;
+          var tabUrl = tab ? (tab.url || tab.pendingUrl || '') : '';
+          if (tabUrl.startsWith('data:')) return;
+          chrome.debugger.sendCommand(
+            { tabId: source.tabId },
+            'Runtime.evaluate',
+            { 
+              expression: INTERNAL_URL_BLOCK_SCRIPT,
+              contextId: context.id,
+              runImmediately: true
+            }
+          ).catch(function() {});
+        });
       }
     }
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdp-tunnel",
-  "version": "2.5.22",
+  "version": "2.6.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

@@ -167,6 +167,7 @@ class PluginNamespace {
         this.cachedTargets = [];
         this.lastTargetsUpdate = 0;
         this.cachedBrowserVersion = null;
+        this.discoveringClientIds = new Map();
     }
 }
 
@@ -505,6 +506,7 @@ function cleanupClient(ws, id, reason) {
         if (ns.clientIdToBrowserContext.has(id)) {
             ns.clientIdToBrowserContext.delete(id);
         }
+        ns.discoveringClientIds.delete(id);
     }
     for (const [gId, mapping] of globalRequestIdMap.entries()) {
         if (mapping.clientId === id) globalRequestIdMap.delete(gId);
@@ -787,8 +789,27 @@ function handlePluginConnection(ws, clientInfo, request) {
                     }
                 } else if (targetId && (parsed.method === 'Target.targetCreated' || parsed.method === 'Target.attachedToTarget')) {
                     const pendingMap = parsed.method === 'Target.targetCreated' ? ns.pendingTargetCreatedEvents : ns.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)`);
+                    
+                    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);
+                                    console.log(`[TARGET EVENT DISCOVERED] ${parsed.method} targetId=${targetId?.substring(0,8)} -> discovering client=${discClientId}`);
+                                    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)} (cached, waiting for createTarget response)`);
+                    }
                 } else {
                     console.log(`[TARGET EVENT DROPPED] ${parsed.method} targetId=${targetId?.substring(0,8) || 'none'} (no owner, dropped for isolation)`);
                 }
@@ -905,9 +926,11 @@ function handlePluginConnection(ws, clientInfo, request) {
                     }
                     if (mapping.isGetTargets && parsed.result && parsed.result.targetInfos) {
                         const clientId = mapping.clientId;
+                        const pluginWsForGetTargets = ws;
                         parsed.result.targetInfos = parsed.result.targetInfos.filter(t => {
                             if (t.type !== 'page') return true;
                             const ownerClient = ns.targetIdToClientId.get(t.targetId);
+                            if (!ownerClient) return true;
                             return ownerClient === clientId;
                         });
                         console.log(`[GET TARGETS FILTERED] client=${clientId} returned ${parsed.result.targetInfos.filter(t => t.type === 'page').length} page targets`);
@@ -1218,6 +1241,14 @@ function handleClientConnection(ws, clientInfo, customClientId = null, targetPlu
             }
         }
 
+        if (parsed && (parsed.method === 'Target.setDiscoverTargets' || parsed.method === 'Target.setAutoAttach')) {
+            const ns = ws.pairedPlugin ? getNamespace(ws.pairedPlugin) : null;
+            if (ns) {
+                ns.discoveringClientIds.set(id, Date.now());
+                console.log(`[DISCOVERING] client=${id} method=${parsed.method}`);
+            }
+        }
+
         if (parsed && parsed.method === 'Browser.close') {
             if (shouldLog('info')) {
                 console.log(`\n[BROWSER CLOSE] Client ${id} requested Browser.close, forwarding to plugin`);