cdp-tunnel 2.8.3 → 2.9.0

package/extension-new/background.js

@@ -341,7 +341,7 @@ importScripts('features/automation-badge.js');
   chrome.runtime.onInstalled.addListener(function(details) {
     Logger.info('[Runtime] Extension installed/updated:', details.reason);
     State.persist(null, false);
-    setBadgeStatus('ON');
+    setBadgeStatus('OFF');
     init();
   });
 

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

@@ -42,9 +42,35 @@ var LocalHandler = (function() {
     var state = _getState(context);
     var params = context.params;
     var wsManager = context._wsManager;
+    var mode = context ? context.mode : null;
     state.setDiscoverTargets(!!(params && params.discover));
 
     if (params && params.discover) {
+      if (mode === 'takeover') {
+        return chrome.debugger.getTargets().then(function(targets) {
+          return new Promise(function(resolve) {
+            var pageTargets = targets.filter(function(t) { return t.type === 'page' && t.tabId; });
+            var checked = 0;
+            if (pageTargets.length === 0) { resolve({}); return; }
+            pageTargets.forEach(function(target) {
+              var tabId = target.tabId;
+              var targetId = target.id;
+              chrome.tabs.get(tabId, function(tab) {
+                checked++;
+                if (chrome.runtime.lastError || !tab) { if (checked === pageTargets.length) resolve({}); return; }
+                var isGrouped = tab.groupId != null && tab.groupId !== -1;
+                var isCDPCreated = state.isCDPCreatedTab(tabId);
+                if (!isGrouped && !isCDPCreated && !state.hasEmittedTarget(targetId)) {
+                  state.addEmittedTarget(targetId);
+                  var targetInfo = mapToTargetInfo(target);
+                  EventBuilder.send('Target.targetCreated', { targetInfo: targetInfo }, null, wsManager);
+                }
+                if (checked === pageTargets.length) resolve({});
+              });
+            });
+          });
+        });
+      }
       return getTargetInfos().then(function(targets) {
         targets.forEach(function(targetInfo) {
           state.addEmittedTarget(targetInfo.targetId);
@@ -56,12 +82,51 @@ var LocalHandler = (function() {
     return Promise.resolve({});
   }
 
-  function targetGetTargets() {
+  function targetGetTargets(context) {
+    var mode = context ? context.mode : null;
+    var state = context ? context._state : null;
+
+    if (mode === 'takeover') {
+      return chrome.debugger.getTargets().then(function(targets) {
+        return filterTakeoverTargetsFromRaw(targets, state);
+      });
+    }
     return getTargetInfos().then(function(targetInfos) {
       return { targetInfos: targetInfos };
     });
   }
 
+  function filterTakeoverTargetsFromRaw(targets, state) {
+    return new Promise(function(resolve) {
+      var pageTargets = targets.filter(function(t) { return t.type === 'page' && t.tabId; });
+      var nonPageTargets = targets.filter(function(t) { return t.type !== 'page'; }).map(mapToTargetInfo);
+
+      if (pageTargets.length === 0) {
+        resolve({ targetInfos: nonPageTargets });
+        return;
+      }
+
+      var checked = 0;
+      var filtered = [];
+      pageTargets.forEach(function(target) {
+        var tabId = target.tabId;
+        chrome.tabs.get(tabId, function(tab) {
+          checked++;
+          if (!chrome.runtime.lastError && tab) {
+            var isGrouped = tab.groupId != null && tab.groupId !== -1;
+            var isCDPCreated = state ? state.isCDPCreatedTab(tabId) : false;
+            if (!isGrouped && !isCDPCreated) {
+              filtered.push(mapToTargetInfo(target));
+            }
+          }
+          if (checked === pageTargets.length) {
+            resolve({ targetInfos: nonPageTargets.concat(filtered) });
+          }
+        });
+      });
+    });
+  }
+
   function targetGetTargetInfo(params) {
     return getFallbackTargetId().then(function(fallbackId) {
       var targetId = (params && params.targetId) || fallbackId;

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

@@ -82,6 +82,10 @@ var SpecialHandler = (function() {
 
         if (state.isCDPCreatedTab(tabId)) {
           addTabToAutomationGroup(tabId, clientId, null, context);
+        } else if (context.mode === 'takeover') {
+          state.addPreExistingTab(tabId);
+          addTabToAutomationGroup(tabId, clientId, null, context);
+          Logger.info('[CDP TAKEOVER] Target.attachToTarget: added to TAKE group. tabId:', tabId);
         } else {
           state.addPreExistingTab(tabId);
           Logger.info('[CDP] Target.attachToTarget: user tab not CDP-created, treating as pre-existing. tabId:', tabId);
@@ -236,7 +240,7 @@ var SpecialHandler = (function() {
         return;
       }
     }
-    var baseName = CDPUtils.getGroupBaseName(groupClientId, _getConnectionTag(context));
+    var baseName = CDPUtils.getGroupBaseName(groupClientId, _getConnectionTag(context), context ? context.mode : null);
 
     Logger.info('[TabGroup] Grouping tab immediately for:', baseName);
     doGroup(tabId, groupClientId, baseName, 0, callback, context);
@@ -258,7 +262,7 @@ var SpecialHandler = (function() {
       Logger.info('[TabGroup] Using cached groupId:', cachedGroupId, 'for client:', clientId);
       chrome.tabs.group({ tabIds: tabId, groupId: cachedGroupId }, function(result) {
         if (!chrome.runtime.lastError) {
-          updateTabGroupName(clientId, state, wsManager);
+          updateTabGroupName(clientId, state, wsManager, context ? context.mode : null);
           Logger.info('[TabGroup] Tab', tabId, 'added to cached group:', cachedGroupId);
           if (callback) callback(true);
           return;
@@ -303,7 +307,7 @@ var SpecialHandler = (function() {
             }
           } else {
             if (state) state.setGroupIdForClient(clientId, existing.id);
-            updateTabGroupName(clientId, state, wsManager);
+            updateTabGroupName(clientId, state, wsManager, context ? context.mode : null);
             Logger.info('[TabGroup] Tab', tabId, 'added to existing group:', existing.id);
             if (callback) callback(true);
           }
@@ -335,7 +339,7 @@ var SpecialHandler = (function() {
                   EventBuilder.send('CDPTunnel.debug', { source: 'doGroup', phase: 'updateGroup', error: chrome.runtime.lastError.message, groupId: groupId }, null, wsManager);
                 } else {
                   if (state) state.setGroupIdForClient(clientId, groupId);
-                  updateTabGroupName(clientId, state, wsManager);
+                  updateTabGroupName(clientId, state, wsManager, context ? context.mode : null);
                   Logger.info('[TabGroup] Group updated:', groupId, baseName);
                 }
                 if (callback) callback(true);
@@ -354,7 +358,7 @@ var SpecialHandler = (function() {
     });
   }
 
-  function updateTabGroupName(clientId, state, wsManager) {
+  function updateTabGroupName(clientId, state, wsManager, mode) {
     if (!clientId) return;
 
     var groupId = state ? state.getGroupIdForClient(clientId) : null;
@@ -365,7 +369,7 @@ var SpecialHandler = (function() {
     chrome.tabs.query({ groupId: groupId }, function(tabs) {
       if (chrome.runtime.lastError || !tabs) return;
 
-      var baseName = CDPUtils.getGroupBaseName(clientId, connectionTag);
+      var baseName = CDPUtils.getGroupBaseName(clientId, connectionTag, mode);
       var newName = baseName + ' (' + tabs.length + ')';
 
       chrome.tabGroups.update(groupId, {
@@ -407,7 +411,7 @@ var SpecialHandler = (function() {
           chrome.tabs.remove(tabId, function() {
             state.removeAttachedTab(tabId);
             if (closeClientId) {
-              updateTabGroupName(closeClientId, state, _getWSManager(context));
+              updateTabGroupName(closeClientId, state, _getWSManager(context), context ? context.mode : null);
             }
             resolve({ success: true });
           });
@@ -516,12 +520,60 @@ function checkTabVisibility(tabId) {
     var state = _getState(context);
     var wsManager = _getWSManager(context);
     var clientId = context ? context.clientId : null;
+    var mode = context ? context.mode : null;
     var config = state.getAutoAttachConfig();
 
     return chrome.debugger.getTargets().then(function(targets) {
       var promises = [];
 
-      Logger.info('[CDP] emitAutoAttachForExistingTargets: checking', targets.length, 'targets, clientId:', clientId);
+      Logger.info('[CDP] emitAutoAttachForExistingTargets: checking', targets.length, 'targets, clientId:', clientId, 'mode:', mode);
+
+      if (mode === 'takeover') {
+        var takeoverPromises = [];
+        targets.forEach(function(target) {
+          if (target.type !== 'page' || !target.tabId) return;
+          var targetId = target.id;
+          var tabId = target.tabId;
+          if (state.hasEmittedTarget(targetId)) return;
+
+          takeoverPromises.push(new Promise(function(resolve) {
+            chrome.tabs.get(tabId, function(tab) {
+              if (chrome.runtime.lastError || !tab) { resolve(); return; }
+              var isGrouped = tab.groupId != null && tab.groupId !== -1;
+              var isCDPCreated = state.isCDPCreatedTab(tabId);
+              if (isGrouped || isCDPCreated) { resolve(); return; }
+
+              state.addEmittedTarget(targetId);
+              state.addPreExistingTab(tabId);
+              if (clientId) state.setTabIdToClientId(tabId, clientId);
+              var targetInfo = LocalHandler.mapToTargetInfo(target);
+              Logger.info('[CDP TAKEOVER] Emitting ungrouped target:', targetId, 'tabId:', tabId);
+
+              var attachLogic = function(attached) {
+                var sessionId = CDPUtils.generateSessionId();
+                state.mapSession(sessionId, tabId, targetId);
+                EventBuilder.send('Target.attachedToTarget', {
+                  sessionId: sessionId,
+                  targetInfo: Object.assign({}, targetInfo, { attached: true }),
+                  waitingForDebugger: false
+                }, null, wsManager);
+              };
+
+              if (target.attached) {
+                attachLogic(true);
+                resolve();
+              } else {
+                DebuggerManager.attach(tabId, state).then(function(attached) {
+                  if (!attached) { resolve(); return; }
+                  attachLogic(attached);
+                  resolve();
+                }).catch(resolve);
+              }
+            });
+          }));
+        });
+        return Promise.all(takeoverPromises);
+      }
 
       targets.forEach(function(target) {
         if (target.type !== 'page' && target.type !== 'background_page') return;

package/extension-new/cdp/index.js

@@ -78,7 +78,7 @@ function routeCDPCommand(message, connState, wsManager) {
   var logType = route ? route.type : 'FORWARD';
   Logger.info('[CDP] RECV id=' + id + ' method=' + method + ' type=' + logType + ' sessionId=' + (sessionId || 'null') + ' clientId=' + (clientId || 'null'));
 
-  var ctx = { id: id, method: method, params: params, sessionId: sessionId, clientId: clientId, _state: state, _wsManager: wsManager };
+  var ctx = { id: id, method: method, params: params, sessionId: sessionId, clientId: clientId, mode: message.mode, _state: state, _wsManager: wsManager };
 
   return new Promise(function(resolve) {
     if (route) {

package/extension-new/config-page.js

@@ -258,8 +258,12 @@
   function loadConnectionStatuses() {
     if (typeof chrome !== 'undefined' && chrome.runtime) {
       chrome.runtime.sendMessage({ type: 'get-connection-statuses' }, function(response) {
-        if (response && response.statuses) {
-          state.connectionStatuses = response.statuses;
+        if (response && response.connections) {
+          var statuses = {};
+          response.connections.forEach(function(conn) {
+            statuses[conn.id] = conn.status;
+          });
+          state.connectionStatuses = statuses;
         }
         loadAndRenderConnections();
       });
@@ -431,6 +435,8 @@
         addLog(message.logType, message.message);
       } else if (message.type === 'connections-updated') {
         loadAndRenderConnections();
+      } else if (message.type === 'connection-status-changed') {
+        loadConnectionStatuses();
       }
     });
   }

package/extension-new/core/websocket.js

@@ -1,3 +1,27 @@
+function updateBadgeFromAllConnections() {
+  var hasConnected = false;
+  var hasEnabled = false;
+  ConnectionManager.forEachConnection(function(entry) {
+    var ws = entry.state.getWs();
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      hasConnected = true;
+    }
+    if (entry.config && entry.config.enabled !== false) {
+      hasEnabled = true;
+    }
+  });
+  var status;
+  if (hasConnected) {
+    status = 'ON';
+  } else if (hasEnabled) {
+    status = 'ERR';
+  } else {
+    status = 'OFF';
+  }
+  setBadgeStatus(status);
+  chrome.runtime.sendMessage({ type: 'connection-status-changed' }).catch(function() {});
+}
+
 var WebSocketConnection = (function() {
   function WebSocketConnection(connectionId, state, config) {
     this.connectionId = connectionId;
@@ -24,7 +48,7 @@ var WebSocketConnection = (function() {
         wsUrl += sep + 'pluginId=' + encodeURIComponent(pluginId);
       }
       Logger.info('[WS:' + self.connectionId + '] Connecting to', wsUrl);
-      setBadgeStatus('ON');
+      updateBadgeFromAllConnections();
 
       try {
         ws = new WebSocket(wsUrl);
@@ -32,7 +56,7 @@ var WebSocketConnection = (function() {
 
         ws.onopen = function() {
           Logger.info('[WS:' + self.connectionId + '] Connected');
-          setBadgeStatus('ON');
+          updateBadgeFromAllConnections();
           self.state.clearReconnectTimer();
           self._processQueue();
           self._broadcastStateUpdate();
@@ -43,14 +67,14 @@ var WebSocketConnection = (function() {
 
         ws.onclose = function(event) {
           Logger.info('[WS:' + self.connectionId + '] Closed:', event.code, event.reason);
-          setBadgeStatus('OFF');
+          updateBadgeFromAllConnections();
           self._scheduleReconnect();
           self._broadcastStateUpdate();
         };
 
         ws.onerror = function(error) {
           Logger.error('[WS:' + self.connectionId + '] Error:', error);
-          setBadgeStatus('ERR');
+          updateBadgeFromAllConnections();
           self._broadcastStateUpdate();
         };
 
@@ -58,9 +82,9 @@ var WebSocketConnection = (function() {
           self._handleRawMessage(event.data);
         };
       } catch (error) {
-        Logger.error('[WS:' + self.connectionId + '] Failed to create:', error);
-        setBadgeStatus('ERR');
-        self._scheduleReconnect();
+      Logger.error('[WS:' + self.connectionId + '] Failed to create:', error);
+      updateBadgeFromAllConnections();
+      self._scheduleReconnect();
       }
     });
   };
@@ -203,7 +227,54 @@ var WebSocketConnection = (function() {
         Logger.info('[WS:' + self.connectionId + '] Client connected, resuming event forwarding');
         self.state.setHasConnectedClient(true);
         self.state.addCDPClient(message.clientId, message.clientId);
-        self._createGroupForClient(message.clientId);
+        self._createGroupForClient(message.clientId, message.__mode);
+        self._broadcastStateUpdate();
+        break;
+
+      case 'takeover-disconnect':
+        Logger.info('[WS:' + self.connectionId + '] Takeover disconnect:', message.clientId);
+        var takeClientId = message.clientId;
+        self._groupCreationPending.delete(takeClientId);
+        var takeAttachedTabs = self.state.getAttachedTabIds();
+        var takeToDetach = takeAttachedTabs.filter(function(tid) {
+          return self.state.getClientIdByTabId(tid) === takeClientId;
+        });
+        var takeTargetIds = [];
+        self.state.sessionIdToTargetId.forEach(function(tTargetId, sessId) {
+          var tTabId = self.state.sessionIdToTabId.get(sessId);
+          if (tTabId && self.state.getClientIdByTabId(tTabId) === takeClientId) {
+            takeTargetIds.push(tTargetId);
+          }
+        });
+        takeToDetach.forEach(function(tid) {
+          chrome.debugger.detach({ tabId: tid }).catch(function() {});
+          self.state.removeAttachedTab(tid);
+        });
+        takeTargetIds.forEach(function(tTargetId) {
+          self.state.emittedTargets.delete(tTargetId);
+        });
+        self.state.clearPreExistingTabsForClient(takeClientId);
+        var takeSessions = self.state.sessionIdToTabId.entries();
+        var takeEntry = takeSessions.next();
+        while (!takeEntry.done) {
+          var sessId = takeEntry.value[0];
+          var tTabId = takeEntry.value[1];
+          if (self.state.getClientIdByTabId(tTabId) === takeClientId) {
+            self.state.unmapSession(sessId);
+          }
+          takeEntry = takeSessions.next();
+        }
+        takeToDetach.forEach(function(tid) {
+          self.state.removeTabIdToClientId(tid);
+          var sessions = self.state.findSessionsByTabId(tid);
+          sessions.forEach(function(sid) { self.state.unmapSession(sid); });
+        });
+        self.state.removeGroupForClient(takeClientId);
+        self.state.removeCDPClient(takeClientId);
+        if (self.state.getCDPClients().length === 0) {
+          self.state.setHasConnectedClient(false);
+        }
+        self._cleanupStaleState(takeClientId);
         self._broadcastStateUpdate();
         break;
 
@@ -258,6 +329,7 @@ var WebSocketConnection = (function() {
             tabId: tabId,
             sessionId: sessionId,
             clientId: message.__clientId,
+            mode: message.__mode,
             connectionId: self.connectionId
           }, self.state, self);
         }
@@ -272,6 +344,7 @@ var WebSocketConnection = (function() {
             tabId: tabId,
             sessionId: sessionId,
             clientId: message.__clientId,
+            mode: message.__mode,
             connectionId: self.connectionId
           }, self.state, self);
         }
@@ -300,9 +373,10 @@ var WebSocketConnection = (function() {
           resolve();
         });
       } else {
-        var baseName = CDPUtils.getGroupBaseName(clientId, self.config ? self.config.tag : null);
+        var cdpBaseName = CDPUtils.getGroupBaseName(clientId, self.config ? self.config.tag : null, 'create');
+        var takeBaseName = CDPUtils.getGroupBaseName(clientId, self.config ? self.config.tag : null, 'takeover');
         chrome.tabGroups.query({}, function(allGroups) {
-          var match = CDPUtils.findGroupByName(allGroups, baseName);
+          var match = CDPUtils.findGroupByName(allGroups, cdpBaseName) || CDPUtils.findGroupByName(allGroups, takeBaseName);
           if (match) {
             self._closeGroupById(match.id, clientId, function() {
               clearTimeout(timeoutId);
@@ -464,7 +538,7 @@ var WebSocketConnection = (function() {
     });
   };
 
-  WebSocketConnection.prototype._createGroupForClient = function(clientId) {
+  WebSocketConnection.prototype._createGroupForClient = function(clientId, mode) {
     var self = this;
     if (!clientId || !chrome.tabGroups) return;
 
@@ -481,7 +555,7 @@ var WebSocketConnection = (function() {
 
     self._groupCreationPending.add(clientId);
 
-    var baseName = CDPUtils.getGroupBaseName(clientId, self.config ? self.config.tag : null);
+    var baseName = CDPUtils.getGroupBaseName(clientId, self.config ? self.config.tag : null, mode);
     chrome.tabs.query({ currentWindow: true }, function(tabs) {
       if (!tabs || tabs.length === 0) {
         Logger.warn('[WS:' + self.connectionId + '] No tabs found for group creation');

package/extension-new/manifest.json

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

package/extension-new/popup.js

@@ -76,4 +76,10 @@
   versionLink.textContent = 'v' + manifest.version;
 
   loadState();
+
+  chrome.runtime.onMessage.addListener(function(message) {
+    if (message.type === 'connection-status-changed' || message.type === 'stateUpdate') {
+      loadState();
+    }
+  });
 })();

package/extension-new/utils/config.js

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

package/extension-new/utils/helpers.js

@@ -42,7 +42,7 @@ var CDPUtils = (function() {
     return 0;
   }
 
-  function buildGroupName(clientId, connectionTag) {
+  function buildGroupName(clientId, connectionTag, mode) {
     if (!clientId) return 'CDP';
     var hash = 0;
     for (var i = 0; i < clientId.length; i++) {
@@ -52,11 +52,12 @@ var CDPUtils = (function() {
     }
     var suffix = Math.abs(hash).toString(16).substring(0, 8).padStart(8, '0');
     var tag = (connectionTag && connectionTag !== 'default') ? connectionTag + '-' : '';
-    return 'CDP-' + tag + suffix;
+    var prefix = (mode === 'takeover') ? 'TAKE-' : 'CDP-';
+    return prefix + tag + suffix;
   }
 
-  function getGroupBaseName(clientId, connectionTag) {
-    return buildGroupName(clientId, connectionTag);
+  function getGroupBaseName(clientId, connectionTag, mode) {
+    return buildGroupName(clientId, connectionTag, mode);
   }
 
   function findGroupByName(allGroups, baseName) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdp-tunnel",
-  "version": "2.8.3",
+  "version": "2.9.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/modules/config.js

@@ -10,7 +10,8 @@ const CONFIG = {
   LOG_LEVEL: process.env.LOG_LEVEL || 'info',
   AUTO_RESTART: process.env.AUTO_RESTART === 'true',
   CHROME_RESTART_COOLDOWN: 30000,
-  PLUGIN_MAX_MISSED_PINGS: 3
+  PLUGIN_MAX_MISSED_PINGS: 3,
+  TAKEOVER_PORT: process.env.TAKEOVER_PORT ? parseInt(process.env.TAKEOVER_PORT) : (parseInt(process.env.PORT || '9221') + 1)
 };
 
 const LOG_LEVELS = {

package/server/proxy-server.js

@@ -16,6 +16,7 @@ const path = require('path');
 const os = require('os');
 const { execSync, spawn: spawnProcess } = require('child_process');
 const { CONFIG, BROWSER_ID, shouldLog } = require('./modules/config');
+const TAKEOVER_PORT = CONFIG.TAKEOVER_PORT;
 const { logCDP, logEvent, clearLog, logStatus, logConnectionEvent, flushAllLogs, logDisconnect } = require('./modules/logger');
 
 try {
@@ -195,6 +196,8 @@ console.log(`  Server started on port ${PORT}`);
 console.log(`  - Plugin path: ws://localhost:${PORT}/plugin`);
 console.log(`  - Client path: ws://localhost:${PORT}/client`);
 console.log(`  - CDP endpoint: http://localhost:${PORT}`);
+console.log(`  - Takeover port: ${TAKEOVER_PORT} (mode=takeover)`);
+console.log(`  - Takeover CDP:  http://localhost:${TAKEOVER_PORT}`);
 console.log('='.repeat(60));
 
 /**
@@ -436,7 +439,8 @@ wss.on('connection', (ws, req) => {
         } else if (pathParts[0] === 'devtools' && pathParts[1] === 'browser' && pathParts[2]) {
             targetPluginId = pathParts[2];
         }
-        handleClientConnection(ws, clientInfo, customClientId, targetPluginId);
+        const mode = req._takeoverMode ? 'takeover' : 'create';
+        handleClientConnection(ws, clientInfo, customClientId, targetPluginId, mode);
     } else if (path.startsWith('/devtools/page/')) {
         const targetId = path.replace('/devtools/page/', '');
         handlePageConnection(ws, clientInfo, targetId);
@@ -449,6 +453,7 @@ wss.on('connection', (ws, req) => {
 function cleanupClient(ws, id, reason) {
     const pluginWs = ws.pairedPlugin || clientIdToPlugin.get(id);
     const ns = pluginWs ? getNamespace(pluginWs) : null;
+    const isTakeover = ws.mode === 'takeover';
 
     if (ns) {
         const sessionsToClean = [];
@@ -467,6 +472,7 @@ function cleanupClient(ws, id, reason) {
     logConnectionEvent('CLIENT_DISCONNECTED', {
         id,
         reason,
+        mode: ws.mode || 'create',
         totalPlugins: pluginConnections.size,
         totalClients: clientConnections.size
     });
@@ -474,6 +480,7 @@ function cleanupClient(ws, id, reason) {
     logDisconnect('CLIENT_CLEANUP', {
         clientId: id,
         reason,
+        mode: ws.mode || 'create',
         cdpMethodsUsed: ws.cdpTrace ? [...new Set(ws.cdpTrace)] : [],
         uptime: ws.connectedAt ? `${((Date.now() - ws.connectedAt) / 1000).toFixed(0)}s` : 'unknown',
         remainingClients: clientConnections.size,
@@ -487,32 +494,41 @@ function cleanupClient(ws, id, reason) {
     }
 
     if (ws.pairedPlugin) {
-        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);
-                }
+        if (isTakeover) {
+            safeSend(ws.pairedPlugin, JSON.stringify({
+                type: 'takeover-disconnect',
+                clientId: id,
+                sessions: []
+            }), 'plugin');
+            console.log(`[TAKEOVER DISCONNECT] client=${id} — detaching only, not closing tabs`);
+        } else {
+            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`);
             }
-            targetsToClose.forEach(function(tId) {
-                const closeReq = JSON.stringify({
-                    id: -1,
-                    method: 'Target.closeTarget',
-                    params: { targetId: tId },
-                    __clientId: id
+
+            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');
                 });
-                safeSend(ws.pairedPlugin, closeReq, 'plugin');
-            });
+            }
         }
     }
 
@@ -819,7 +835,23 @@ 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 {
-                        console.log(`[TARGET EVENT DROPPED] ${parsed.method} targetId=${targetId?.substring(0,8) || 'none'} (no owner, dropped for isolation)`);
+                        let takeoverRouted = false;
+                        ns.discoveringClientIds.forEach((timestamp, discClientId) => {
+                            if (takeoverRouted) return;
+                            const discWs = clientById.get(discClientId);
+                            if (discWs && discWs.mode === 'takeover' && discWs.readyState === WebSocket.OPEN) {
+                                discWs.send(cdpData);
+                                takeoverRouted = true;
+                                console.log(`[TAKEOVER EVENT ROUTED] ${parsed.method} targetId=${targetId?.substring(0,8)} -> clientId=${discClientId}`);
+                                if (parsed.params?.sessionId) {
+                                    ns.sessionToClientId.set(parsed.params.sessionId, discClientId);
+                                }
+                                ns.targetIdToClientId.set(targetId, discClientId);
+                            }
+                        });
+                        if (!takeoverRouted) {
+                            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)`);
@@ -893,6 +925,10 @@ function handlePluginConnection(ws, clientInfo, request) {
                     if (parsed.result?.sessionId && mapping.method === 'Target.attachToTarget') {
                         ns.sessionToClientId.set(parsed.result.sessionId, mapping.clientId);
                         console.log(`[SESSION MAPPED from attach response] sessionId=${parsed.result.sessionId?.substring(0,8)} -> clientId=${mapping.clientId?.substring(0,8)}`);
+                        if (mapping.attachTargetId && !ns.targetIdToClientId.has(mapping.attachTargetId)) {
+                            ns.targetIdToClientId.set(mapping.attachTargetId, mapping.clientId);
+                            console.log(`[TARGET MAPPED from attach] targetId=${mapping.attachTargetId?.substring(0,8)} -> clientId=${mapping.clientId}`);
+                        }
                     }
                     
                     if (mapping.isCreateTarget && parsed.result?.targetId) {
@@ -937,12 +973,16 @@ function handlePluginConnection(ws, clientInfo, request) {
                     }
                     if (mapping.isGetTargets && parsed.result && parsed.result.targetInfos) {
                         const clientId = mapping.clientId;
-                        parsed.result.targetInfos = parsed.result.targetInfos.filter(t => {
-                            if (t.type !== 'page') return true;
-                            const ownerClient = ns.targetIdToClientId.get(t.targetId);
-                            return ownerClient === clientId;
-                        });
-                        console.log(`[GET TARGETS FILTERED] client=${clientId} returned ${parsed.result.targetInfos.filter(t => t.type === 'page').length} page targets`);
+                        if (mapping.isTakeover) {
+                            console.log(`[GET TARGETS TAKEOVER] client=${clientId} returning unfiltered targets (${parsed.result.targetInfos.length})`);
+                        } else {
+                            parsed.result.targetInfos = parsed.result.targetInfos.filter(t => {
+                                if (t.type !== 'page') return true;
+                                const ownerClient = ns.targetIdToClientId.get(t.targetId);
+                                return ownerClient === clientId;
+                            });
+                            console.log(`[GET TARGETS FILTERED] client=${clientId} returned ${parsed.result.targetInfos.filter(t => t.type === 'page').length} page targets`);
+                        }
                     }
                     if (parsed.result && parsed.result.success !== undefined && mapping.method === 'Target.closeTarget') {
                         if (mapping.closeTargetId) {
@@ -1123,11 +1163,12 @@ function forwardToPlugin(clientWs, data, clientId) {
 /**
  * 处理 CDP 客户端连接 (Playwright/Puppeteer)
  */
-function handleClientConnection(ws, clientInfo, customClientId = null, targetPluginId = null) {
+function handleClientConnection(ws, clientInfo, customClientId = null, targetPluginId = null, mode = 'create') {
     clientConnections.add(ws);
     const id = customClientId || generateId('client');
+    ws.mode = mode;
     if (shouldLog('info')) {
-        console.log(`\n[CLIENT CONNECTED] ID: ${id}${customClientId ? ' (custom)' : ''}${targetPluginId ? ` targetPlugin=${targetPluginId}` : ''}`);
+        console.log(`\n[CLIENT CONNECTED] ID: ${id}${customClientId ? ' (custom)' : ''}${targetPluginId ? ` targetPlugin=${targetPluginId}` : ''} mode=${mode}`);
         console.log(`  - Remote: ${clientInfo.ip}:${clientInfo.port}`);
         console.log(`  - Total client connections: ${clientConnections.size}`);
     }
@@ -1296,6 +1337,10 @@ function handleClientConnection(ws, clientInfo, customClientId = null, targetPlu
                     safeSend(ws, errMsg, 'client');
                     return;
                 }
+                const currentMapping = globalRequestIdMap.get(parsed.id);
+                if (currentMapping && targetId) {
+                    currentMapping.attachTargetId = targetId;
+                }
             }
         }
         
@@ -1311,6 +1356,9 @@ function handleClientConnection(ws, clientInfo, customClientId = null, targetPlu
             const currentMapping = globalRequestIdMap.get(parsed.id);
             if (currentMapping) {
                 currentMapping.isGetTargets = true;
+                if (ws.mode === 'takeover') {
+                    currentMapping.isTakeover = true;
+                }
             }
         }
 
@@ -1324,17 +1372,31 @@ 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);
+            if (ws.mode === 'takeover') {
+                const takeoverMsg = { ...parsed, __clientId: id, __mode: 'takeover' };
+                if (ws.pairedPlugin && ws.pairedPlugin.readyState === WebSocket.OPEN) {
+                    ws.pairedPlugin.send(JSON.stringify(takeoverMsg));
+                }
+            } else {
+                autoCreateDefaultPageAndForward(ws, parsed, modifiedData, id, originalId);
+            }
             return;
         }
 
         if (parsed && parsed.method === 'Browser.close') {
-            console.log(`[BROWSER CLOSE] Client ${id} requested Browser.close — closing client group only`);
+            console.log(`[BROWSER CLOSE] Client ${id} mode=${ws.mode} requested Browser.close`);
             if (ws.pairedPlugin) {
-                safeSend(ws.pairedPlugin, JSON.stringify({
-                    type: 'browser-close',
-                    clientId: id
-                }), 'plugin');
+                if (ws.mode === 'takeover') {
+                    safeSend(ws.pairedPlugin, JSON.stringify({
+                        type: 'takeover-disconnect',
+                        clientId: id
+                    }), 'plugin');
+                } else {
+                    safeSend(ws.pairedPlugin, JSON.stringify({
+                        type: 'browser-close',
+                        clientId: id
+                    }), 'plugin');
+                }
             }
             safeSend(ws, JSON.stringify({ id: originalId, result: {} }), 'client');
             return;
@@ -1353,8 +1415,10 @@ function handleClientConnection(ws, clientInfo, customClientId = null, targetPlu
         // 发送给配对的 plugin (或广播)
         if (ws.pairedPlugin && ws.pairedPlugin.readyState === WebSocket.OPEN) {
             console.log(`[SEND TO PLUGIN] id=${parsed?.id} method=${parsed?.method} sessionId=${parsed?.sessionId?.substring(0,8) || 'none'} clientId=${id}`);
-            // 在消息中附加 clientId 信息
             const pluginMsg = { ...parsed, __clientId: id };
+            if (ws.mode === 'takeover') {
+                pluginMsg.__mode = 'takeover';
+            }
             ws.pairedPlugin.send(JSON.stringify(pluginMsg));
         } else {
             broadcastToPlugins(modifiedData, ws);
@@ -1920,3 +1984,35 @@ server.on('error', (err) => {
 });
 
 server.listen(PORT, '0.0.0.0');
+
+const takeoverServer = http.createServer((req, res) => handleHttpRequest(req, res));
+takeoverServer.on('upgrade', (req, socket, head) => {
+    req._takeoverMode = true;
+    const url = new URL(req.url, `http://localhost:${TAKEOVER_PORT}`);
+    const path = url.pathname;
+    const isPlugin = path === '/plugin';
+    const isClient = path === '/client' ||
+                     path.startsWith('/client/') ||
+                     path.startsWith('/client-') ||
+                     path.startsWith('/devtools/browser/') ||
+                     path.startsWith('/devtools/page/');
+
+    if (!isPlugin && !isClient) {
+        socket.destroy();
+        return;
+    }
+
+    wss.handleUpgrade(req, socket, head, (ws) => {
+        wss.emit('connection', ws, req);
+    });
+});
+takeoverServer.on('error', (err) => {
+    if (err.code === 'EADDRINUSE') {
+        console.error(`[WARN] Takeover port ${TAKEOVER_PORT} is already in use. Takeover mode disabled.`);
+    } else {
+        console.error('[WARN] Takeover server error:', err.message);
+    }
+});
+takeoverServer.listen(TAKEOVER_PORT, '0.0.0.0', () => {
+    console.log(`[TAKEOVER] Listening on port ${TAKEOVER_PORT}`);
+});