cdp-tunnel 2.7.9 → 2.8.0

package/extension-new/core/connection-state.js

@@ -0,0 +1,355 @@
+function ConnectionState(connectionId) {
+  this.connectionId = connectionId;
+  this.ws = null;
+  this.reconnectTimer = null;
+  this._hasConnectedClient = false;
+  this.cdpClients = [];
+  this.currentTabId = null;
+  this.isAttached = false;
+
+  this.sessionIdToTabId = new Map();
+  this.sessionIdToTargetId = new Map();
+  this.tabIdToClientId = new Map();
+  this.clientIdToGroupId = new Map();
+  this.attachedTabIds = new Set();
+  this.cdpCreatedTabIds = new Set();
+  this.emittedTargets = new Set();
+  this.pendingCreatedTabUrls = new Set();
+  this.preExistingTabIds = new Set();
+  this.pendingDebuggerTabs = new Set();
+  this.autoAttachConfig = {
+    autoAttach: false,
+    waitForDebuggerOnStart: false,
+    flatten: true
+  };
+  this.discoverTargetsEnabled = false;
+  this.browserContextIds = new Set(['default']);
+  this.screencastPollingSessions = new Map();
+  this.automatedTabs = new Set();
+}
+
+ConnectionState.prototype.mapSession = function(sessionId, tabId, targetId) {
+  this.sessionIdToTabId.set(sessionId, tabId);
+  this.sessionIdToTargetId.set(sessionId, targetId);
+  this.attachedTabIds.add(tabId);
+};
+
+ConnectionState.prototype.unmapSession = function(sessionId) {
+  var tabId = this.sessionIdToTabId.get(sessionId);
+  this.sessionIdToTabId.delete(sessionId);
+  this.sessionIdToTargetId.delete(sessionId);
+  if (tabId && !this.hasOtherSessionForTab(tabId)) {
+    this.attachedTabIds.delete(tabId);
+  }
+  return tabId;
+};
+
+ConnectionState.prototype.getTabIdBySession = function(sessionId) {
+  return this.sessionIdToTabId.get(sessionId);
+};
+
+ConnectionState.prototype.getTargetIdBySession = function(sessionId) {
+  return this.sessionIdToTargetId.get(sessionId);
+};
+
+ConnectionState.prototype.findSessionByTabId = function(tabId) {
+  var lastMatch = null;
+  this.sessionIdToTabId.forEach(function(mappedTabId, sessionId) {
+    if (mappedTabId === tabId) lastMatch = sessionId;
+  });
+  return lastMatch;
+};
+
+ConnectionState.prototype.findSessionsByTabId = function(tabId) {
+  var sessions = [];
+  this.sessionIdToTabId.forEach(function(mappedTabId, sessionId) {
+    if (mappedTabId === tabId) sessions.push(sessionId);
+  });
+  return sessions;
+};
+
+ConnectionState.prototype.findSessionByTargetId = function(targetId) {
+  var entries = this.sessionIdToTargetId.entries();
+  var entry = entries.next();
+  while (!entry.done) {
+    if (entry.value[1] === targetId) return entry.value[0];
+    entry = entries.next();
+  }
+  return null;
+};
+
+ConnectionState.prototype.getTabIdByTargetId = function(targetId) {
+  var sessionId = this.findSessionByTargetId(targetId);
+  if (sessionId) return this.sessionIdToTabId.get(sessionId);
+  return null;
+};
+
+ConnectionState.prototype.hasOtherSessionForTab = function(tabId) {
+  var count = 0;
+  this.sessionIdToTabId.forEach(function(mappedTabId) {
+    if (mappedTabId === tabId) count++;
+  });
+  return count > 0;
+};
+
+ConnectionState.prototype.addAttachedTab = function(tabId) {
+  this.attachedTabIds.add(tabId);
+};
+
+ConnectionState.prototype.removeAttachedTab = function(tabId) {
+  this.attachedTabIds.delete(tabId);
+};
+
+ConnectionState.prototype.isTabAttached = function(tabId) {
+  return this.attachedTabIds.has(tabId);
+};
+
+ConnectionState.prototype.getAttachedTabIds = function() {
+  return Array.from(this.attachedTabIds);
+};
+
+ConnectionState.prototype.addEmittedTarget = function(targetId) {
+  this.emittedTargets.add(targetId);
+};
+
+ConnectionState.prototype.hasEmittedTarget = function(targetId) {
+  return this.emittedTargets.has(targetId);
+};
+
+ConnectionState.prototype.setAutoAttachConfig = function(config) {
+  Object.assign(this.autoAttachConfig, config);
+};
+
+ConnectionState.prototype.getAutoAttachConfig = function() {
+  return Object.assign({}, this.autoAttachConfig);
+};
+
+ConnectionState.prototype.setDiscoverTargets = function(enabled) {
+  this.discoverTargetsEnabled = enabled;
+};
+
+ConnectionState.prototype.addPendingDebuggerTab = function(tabId) {
+  this.pendingDebuggerTabs.add(tabId);
+};
+
+ConnectionState.prototype.removePendingDebuggerTab = function(tabId) {
+  this.pendingDebuggerTabs.delete(tabId);
+};
+
+ConnectionState.prototype.isPendingDebuggerTab = function(tabId) {
+  return this.pendingDebuggerTabs.has(tabId);
+};
+
+ConnectionState.prototype.addBrowserContext = function(id) {
+  this.browserContextIds.add(id);
+};
+
+ConnectionState.prototype.removeBrowserContext = function(id) {
+  this.browserContextIds.delete(id);
+};
+
+ConnectionState.prototype.getBrowserContexts = function() {
+  return Array.from(this.browserContextIds);
+};
+
+ConnectionState.prototype.getCurrentTabId = function() {
+  return this.currentTabId;
+};
+
+ConnectionState.prototype.setCurrentTabId = function(tabId) {
+  this.currentTabId = tabId;
+};
+
+ConnectionState.prototype.getWs = function() {
+  return this.ws;
+};
+
+ConnectionState.prototype.setWs = function(ws) {
+  this.ws = ws;
+};
+
+ConnectionState.prototype.clearReconnectTimer = function() {
+  if (this.reconnectTimer) {
+    clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = null;
+  }
+};
+
+ConnectionState.prototype.setReconnectTimer = function(timer) {
+  this.reconnectTimer = timer;
+};
+
+ConnectionState.prototype.hasConnectedClient = function() {
+  return this._hasConnectedClient;
+};
+
+ConnectionState.prototype.setHasConnectedClient = function(value) {
+  this._hasConnectedClient = value;
+};
+
+ConnectionState.prototype.addPendingCreatedTabUrl = function(url) {
+  this.pendingCreatedTabUrls.add(url);
+};
+
+ConnectionState.prototype.removePendingCreatedTabUrl = function(url) {
+  this.pendingCreatedTabUrls.delete(url);
+};
+
+ConnectionState.prototype.hasPendingCreatedTabUrl = function(url) {
+  return this.pendingCreatedTabUrls.has(url);
+};
+
+ConnectionState.prototype.addCDPCreatedTab = function(tabId) {
+  this.cdpCreatedTabIds.add(tabId);
+};
+
+ConnectionState.prototype.isCDPCreatedTab = function(tabId) {
+  return this.cdpCreatedTabIds.has(tabId);
+};
+
+ConnectionState.prototype.getCDPCreatedTabIds = function() {
+  return Array.from(this.cdpCreatedTabIds);
+};
+
+ConnectionState.prototype.getScreencastSession = function(tabId) {
+  return this.screencastPollingSessions.get(tabId);
+};
+
+ConnectionState.prototype.setScreencastSession = function(tabId, session) {
+  this.screencastPollingSessions.set(tabId, session);
+};
+
+ConnectionState.prototype.deleteScreencastSession = function(tabId) {
+  this.screencastPollingSessions.delete(tabId);
+};
+
+ConnectionState.prototype.addAutomatedTab = function(tabId) {
+  this.automatedTabs.add(tabId);
+};
+
+ConnectionState.prototype.removeAutomatedTab = function(tabId) {
+  this.automatedTabs.delete(tabId);
+};
+
+ConnectionState.prototype.getAutomatedTabs = function() {
+  return Array.from(this.automatedTabs);
+};
+
+ConnectionState.prototype.setTabIdToClientId = function(tabId, clientId) {
+  this.tabIdToClientId.set(tabId, clientId);
+};
+
+ConnectionState.prototype.removeTabIdToClientId = function(tabId) {
+  this.tabIdToClientId.delete(tabId);
+};
+
+ConnectionState.prototype.getClientIdByTabId = function(tabId) {
+  return this.tabIdToClientId.get(tabId);
+};
+
+ConnectionState.prototype.setGroupIdForClient = function(clientId, groupId) {
+  this.clientIdToGroupId.set(clientId, groupId);
+};
+
+ConnectionState.prototype.getGroupIdForClient = function(clientId) {
+  return this.clientIdToGroupId.get(clientId);
+};
+
+ConnectionState.prototype.removeGroupForClient = function(clientId) {
+  this.clientIdToGroupId.delete(clientId);
+};
+
+ConnectionState.prototype.addPreExistingTab = function(tabId) {
+  this.preExistingTabIds.add(tabId);
+};
+
+ConnectionState.prototype.isPreExistingTab = function(tabId) {
+  return this.preExistingTabIds.has(tabId);
+};
+
+ConnectionState.prototype.getPreExistingTabs = function() {
+  return Array.from(this.preExistingTabIds);
+};
+
+ConnectionState.prototype.removePreExistingTab = function(tabId) {
+  this.preExistingTabIds.delete(tabId);
+};
+
+ConnectionState.prototype.clearPreExistingTabsForClient = function(clientId) {
+  var self = this;
+  this.preExistingTabIds.forEach(function(tabId) {
+    if (self.getClientIdByTabId(tabId) === clientId) {
+      self.preExistingTabIds.delete(tabId);
+    }
+  });
+};
+
+ConnectionState.prototype.addCDPClient = function(clientId, info) {
+  var exists = false;
+  for (var i = 0; i < this.cdpClients.length; i++) {
+    if (this.cdpClients[i].id === clientId) { exists = true; break; }
+  }
+  if (!exists) {
+    this.cdpClients.push({ id: clientId, connectedAt: Date.now() });
+  }
+};
+
+ConnectionState.prototype.removeCDPClient = function(clientId) {
+  var newClients = [];
+  for (var i = 0; i < this.cdpClients.length; i++) {
+    if (this.cdpClients[i].id !== clientId) newClients.push(this.cdpClients[i]);
+  }
+  this.cdpClients = newClients;
+};
+
+ConnectionState.prototype.getCDPClients = function() {
+  return this.cdpClients;
+};
+
+ConnectionState.prototype.setCDPClients = function(clients) {
+  this.cdpClients = clients || [];
+};
+
+ConnectionState.prototype.clearSessionState = function() {
+  this.sessionIdToTabId.clear();
+  this.sessionIdToTargetId.clear();
+  this.pendingDebuggerTabs.clear();
+  this.emittedTargets.clear();
+};
+
+ConnectionState.prototype.clearAllState = function() {
+  this.clearSessionState();
+  this.attachedTabIds.clear();
+  this.emittedTargets.clear();
+  this.screencastPollingSessions.clear();
+  this.browserContextIds = new Set(['default']);
+  this.autoAttachConfig = { autoAttach: false, waitForDebuggerOnStart: false, flatten: true };
+  this.discoverTargetsEnabled = false;
+  this._hasConnectedClient = false;
+  this.tabIdToClientId.clear();
+  this.clientIdToGroupId.clear();
+  this.preExistingTabIds.clear();
+  this.pendingDebuggerTabs.clear();
+  this.automatedTabs.clear();
+  this.pendingCreatedTabUrls.clear();
+  this.cdpCreatedTabIds.clear();
+  this.cdpClients = [];
+};
+
+ConnectionState.prototype.persist = function(tabId, attached) {
+  this.currentTabId = tabId;
+  this.isAttached = attached;
+  return new Promise(function(resolve) {
+    chrome.storage.local.set({ currentTabId: tabId, isAttached: attached }, resolve);
+  }.bind(this));
+};
+
+ConnectionState.prototype.loadPersisted = function() {
+  return new Promise(function(resolve) {
+    chrome.storage.local.get(['currentTabId', 'isAttached'], function(result) {
+      this.currentTabId = result.currentTabId || null;
+      this.isAttached = result.isAttached || false;
+      resolve(result);
+    }.bind(this));
+  }.bind(this));
+};

package/extension-new/core/debugger.js

@@ -8,17 +8,14 @@ var DebuggerManager = (function() {
   
   function isInternalUrl(url) {
     if (!url) return false;
-    // Whitelist: only allow http/https/about/data/blob/file
     if (url.startsWith('http:') || url.startsWith('https:') || url.startsWith('about:') || url.startsWith('data:') || url.startsWith('blob:') || url.startsWith('file:')) {
       return false;
     }
-    // Also check explicit blocked list for common custom protocols
     for (var i = 0; i < blockedProtocols.length; i++) {
       if (url.startsWith(blockedProtocols[i])) {
         return true;
       }
     }
-    // Block any other custom protocol (xxx://)
     var colonIdx = url.indexOf(':');
     if (colonIdx > 0 && colonIdx < 20 && url.substring(colonIdx, colonIdx + 3) === '://') {
       return true;
@@ -26,7 +23,6 @@ var DebuggerManager = (function() {
     return false;
   }
   
-  // 拦截 iframe 创建
   var originalCreateElement = document.createElement;
   document.createElement = function(tagName) {
     var element = originalCreateElement.call(document, tagName);
@@ -43,7 +39,6 @@ var DebuggerManager = (function() {
     return element;
   };
   
-  // 拦截 window.open
   var originalWindowOpen = window.open;
   window.open = function(url) {
     if (isInternalUrl(url)) {
@@ -53,7 +48,6 @@ var DebuggerManager = (function() {
     return originalWindowOpen.apply(this, arguments);
   };
   
-  // 拦截 location 修改
   var locationDescriptor = Object.getOwnPropertyDescriptor(window, 'location');
   if (locationDescriptor && typeof locationDescriptor.set === 'function') {
     try {
@@ -71,7 +65,6 @@ var DebuggerManager = (function() {
         configurable: true
       });
     } catch(e) {
-      // location property cannot be redefined on some contexts, skip silently
     }
   }
   
@@ -79,7 +72,8 @@ var DebuggerManager = (function() {
 })();
 `;
 
-  function attach(tabId) {
+  function attach(tabId, connState) {
+    var state = connState || _getAnyStateForTab(tabId);
     if (tabId == null) {
       return Promise.resolve(false);
     }
@@ -87,7 +81,7 @@ var DebuggerManager = (function() {
     return ensureTabExists(tabId).then(function(exists) {
       if (!exists) {
         Logger.warn('[Debugger] Tab', tabId, 'does not exist');
-        State.persist(null, false);
+        if (state) state.persist(null, false);
         return false;
       }
 
@@ -95,23 +89,28 @@ var DebuggerManager = (function() {
         if (isAttached) {
           Logger.info('[Debugger] Tab', tabId, 'already attached, detaching first...');
           return chrome.debugger.detach({ tabId: tabId }).catch(function() {}).then(function() {
-            return doAttach(tabId);
+            return doAttach(tabId, state);
           });
         }
-        return doAttach(tabId);
+        return doAttach(tabId, state);
       });
     });
   }
 
-  function doAttach(tabId) {
+  function _getAnyStateForTab(tabId) {
+    var entry = ConnectionManager.getConnectionByTabId(tabId);
+    return entry ? entry.state : null;
+  }
+
+  function doAttach(tabId, state) {
     return chrome.debugger.attach({ tabId: tabId }, Config.DEBUGGER_VERSION)
       .then(function() {
         Logger.info('[Debugger] Attached to tab', tabId);
-        State.addAttachedTab(tabId);
-        State.setCurrentTabId(tabId);
-        State.persist(tabId, true);
-        
-        // 注入内部URL拦截脚本
+        if (state) {
+          state.addAttachedTab(tabId);
+          state.setCurrentTabId(tabId);
+          state.persist(tabId, true);
+        }
         return injectInternalUrlBlocker(tabId);
       })
       .then(function() {
@@ -142,7 +141,8 @@ var DebuggerManager = (function() {
     });
   }
 
-  function detach(tabId) {
+  function detach(tabId, connState) {
+    var state = connState || _getAnyStateForTab(tabId);
     if (tabId == null) {
       return Promise.resolve();
     }
@@ -152,16 +152,18 @@ var DebuggerManager = (function() {
     return chrome.debugger.detach({ tabId: tabId })
       .then(function() {
         Logger.info('[Debugger] Detached from tab', tabId);
-        State.removeAttachedTab(tabId);
+        if (state) {
+          state.removeAttachedTab(tabId);
+          if (state.getCurrentTabId() === tabId) {
+            state.persist(null, false);
+          }
+        }
         AutomationBadge.remove(tabId);
         Screencast.stopPolling(tabId);
-        if (State.getCurrentTabId() === tabId) {
-          State.persist(null, false);
-        }
       })
       .catch(function(error) {
         Logger.error('[Debugger] Failed to detach from tab', tabId, ':', error.message);
-        State.removeAttachedTab(tabId);
+        if (state) state.removeAttachedTab(tabId);
         AutomationBadge.remove(tabId);
         Screencast.stopPolling(tabId);
       });
@@ -191,11 +193,17 @@ var DebuggerManager = (function() {
   }
 
   function handleDebuggerEvent(source, method, params) {
-    if (!State.isTabAttached(source.tabId)) {
+    var entry = ConnectionManager.getConnectionByTabId(source.tabId);
+    if (!entry) return;
+
+    var state = entry.state;
+    var wsManager = entry.wsManager;
+
+    if (!state.isTabAttached(source.tabId)) {
       return;
     }
 
-    if (!State.hasConnectedClient()) {
+    if (!state.hasConnectedClient()) {
       return;
     }
 
@@ -203,20 +211,19 @@ var DebuggerManager = (function() {
       return;
     }
 
-    var sessionIds = State.findSessionsByTabId(source.tabId);
+    var sessionIds = state.findSessionsByTabId(source.tabId);
     Logger.info('[Event] method=' + method + ' tabId=' + source.tabId + ' sessions=' + sessionIds.length);
-    
+
     if (method === 'Runtime.executionContextCreated' && params && params.context) {
       var context = params.context;
       var isPlaywrightContext = context.name && context.name.indexOf('__playwright') === 0;
       var isDefaultContext = context.auxData && context.auxData.isDefault;
-      
+
       if (!isPlaywrightContext && !isDefaultContext) {
         Logger.info('[Event] Filtering non-Playwright Runtime.executionContextCreated:', context.name);
         return;
       }
-      
-      // 在新的执行上下文中也注入拦截脚本（data: URL 上下文跳过，避免干扰导航）
+
       if (isDefaultContext) {
         chrome.tabs.get(source.tabId, function(tab) {
           if (chrome.runtime.lastError) return;
@@ -234,7 +241,7 @@ var DebuggerManager = (function() {
         });
       }
     }
-    
+
     if (method === 'Page.frameRequestedNavigation' && params) {
       var url = params.url || '';
       var reason = params.reason || '';
@@ -245,12 +252,11 @@ var DebuggerManager = (function() {
       Logger.warn('  Reason:', reason);
       Logger.warn('  Disposition:', disposition);
       Logger.warn('  FrameId:', frameId);
-      
+
       if (url && !url.startsWith('http://') && !url.startsWith('https://') && !url.startsWith('about:') && !url.startsWith('data:') && !url.startsWith('blob:') && !url.startsWith('file://')) {
         Logger.error('[NAVIGATION] ⚠️ 检测到导航到内部页面，尝试阻止!');
         Logger.error('[NAVIGATION] 目标URL:', url);
-        
-        // 尝试方法1: 停止页面加载
+
         chrome.debugger.sendCommand(
           { tabId: source.tabId },
           'Page.stopLoading',
@@ -260,8 +266,7 @@ var DebuggerManager = (function() {
         }).catch(function(e) {
           Logger.error('[NAVIGATION] Page.stopLoading 失败:', e.message);
         });
-        
-        // 尝试方法2: 获取当前页面URL并导航回去
+
         chrome.tabs.get(source.tabId, function(tab) {
           if (tab && tab.url && !tab.url.startsWith('bitbrowser://')) {
             Logger.info('[NAVIGATION] 尝试导航回原页面:', tab.url);
@@ -278,36 +283,44 @@ var DebuggerManager = (function() {
             }, 100);
           }
         });
-        
-        // 不转发这个导航事件给客户端
+
         Logger.warn('[NAVIGATION] 阻止转发导航事件到客户端');
         return;
       }
     }
-    
+
     for (var i = 0; i < sessionIds.length; i++) {
-      EventBuilder.send(method, params, sessionIds[i]);
+      EventBuilder.send(method, params, sessionIds[i], wsManager);
     }
   }
 
   function handleDetach(source, reason) {
     Logger.info('[Debugger] Detached from tab', source.tabId, ', reason:', reason);
-    State.removeAttachedTab(source.tabId);
+
+    var entry = ConnectionManager.getConnectionByTabId(source.tabId);
+    var state = entry ? entry.state : null;
+    var wsManager = entry ? entry.wsManager : null;
+
+    if (state) {
+      state.removeAttachedTab(source.tabId);
+    }
     Screencast.stopPolling(source.tabId);
     AutomationBadge.remove(source.tabId);
 
-    var sessionId = State.findSessionByTabId(source.tabId);
-    if (sessionId) {
-      var targetId = State.getTargetIdBySession(sessionId);
-      EventBuilder.send('Target.detachedFromTarget', {
-        sessionId: sessionId,
-        targetId: targetId
-      });
-      State.unmapSession(sessionId);
-    }
+    if (state) {
+      var sessionId = state.findSessionByTabId(source.tabId);
+      if (sessionId) {
+        var targetId = state.getTargetIdBySession(sessionId);
+        EventBuilder.send('Target.detachedFromTarget', {
+          sessionId: sessionId,
+          targetId: targetId
+        }, null, wsManager);
+        state.unmapSession(sessionId);
+      }
 
-    if (State.getCurrentTabId() === source.tabId) {
-      State.persist(null, false);
+      if (state.getCurrentTabId() === source.tabId) {
+        state.persist(null, false);
+      }
     }
   }