cdp-tunnel 2.10.12 → 3.0.0

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

@@ -1,4 +1,13 @@
 var ForwardHandler = (function() {
+  // 合成输入事件（keyboard/mouse）需要页面 visibility=visible 才能投递到 DOM。
+  // cdp-tunnel 的隔离 tab（active:false + 折叠分组）默认 visibility=hidden，
+  // 导致 Input.dispatchKeyEvent/dispatchMouseEvent 被 Chromium 丢弃。
+  // 这些命令发送前需要 Page.bringToFront 让页面变 visible + 恢复焦点。
+  var SYNTHETIC_INPUT_METHODS = [
+    'Input.dispatchKeyEvent',
+    'Input.dispatchMouseEvent'
+  ];
+
   function execute(context) {
     var id = context.id;
     var method = context.method;
@@ -19,11 +28,52 @@ var ForwardHandler = (function() {
     }
 
     Logger.debug('[Forward]', method, '-> tabId:', tabId);
+
+    // 合成输入事件需要页面 visible：先 ensureVisible 再发命令
+    if (SYNTHETIC_INPUT_METHODS.indexOf(method) >= 0) {
+      return ensureVisible(tabId).then(function() {
+        return chrome.debugger.sendCommand({ tabId: tabId }, method, params);
+      }).then(function(result) {
+        return result || {};
+      });
+    }
+
     return chrome.debugger.sendCommand({ tabId: tabId }, method, params).then(function(result) {
       return result || {};
     });
   }
 
+  /**
+   * 让 tab 变 visible：Page.bringToFront + 等 visibilitychange + 恢复焦点。
+   * bringToFront 会重置页面元素焦点，需要保存/恢复。
+   */
+  function ensureVisible(tabId) {
+    // 1. 保存焦点：给 activeElement 打标记
+    return chrome.debugger.sendCommand({ tabId: tabId }, 'Runtime.evaluate', {
+      expression: '(function(){var el=document.activeElement;if(el&&el!==document.body&&el.focus){el.setAttribute("data-cdp-saved-focus","1");return 1}return 0})()',
+      returnByValue: true
+    }).catch(function() { return { result: { value: 0 } }; }).then(function(res) {
+      var hadFocus = res && res.result && res.result.value;
+
+      // 2. bringToFront 让 visibility 从 hidden→visible
+      return chrome.debugger.sendCommand({ tabId: tabId }, 'Page.bringToFront', {}).then(function() {
+        // 3. 等 visibilitychange 事件 + 双 rAF（确保 renderer 完成切换）
+        return chrome.debugger.sendCommand({ tabId: tabId }, 'Runtime.evaluate', {
+          expression: 'new Promise(function(r){function ok(){requestAnimationFrame(function(){requestAnimationFrame(function(){r(1)})})}if(document.visibilityState==="visible"){ok()}else{var d=function(){if(document.visibilityState==="visible"){document.removeEventListener("visibilitychange",d);ok()}};document.addEventListener("visibilitychange",d);setTimeout(function(){document.removeEventListener("visibilitychange",d);ok()},3000)}})',
+          awaitPromise: true
+        });
+      }).then(function() {
+        // 4. 恢复焦点
+        if (hadFocus) {
+          return chrome.debugger.sendCommand({ tabId: tabId }, 'Runtime.evaluate', {
+            expression: '(function(){var el=document.querySelector("[data-cdp-saved-focus]");if(el){el.removeAttribute("data-cdp-saved-focus");el.focus();return 1}return 0})()',
+            returnByValue: true
+          }).catch(function() {});
+        }
+      });
+    });
+  }
+
   function resolveTabId(sessionId, state) {
     if (!state) return null;
     if (sessionId) {

package/extension-new/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "CDP Bridge",
-  "version": "2.10.12",
+  "version": "3.0.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:19286/plugin',
+  WS_URL: 'ws://localhost:9221/plugin',
   RECONNECT_DELAY: 3000,
   DEBUGGER_VERSION: '1.3',
   HEARTBEAT_INTERVAL: 25000,

package/package.json

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

@@ -11,7 +11,10 @@ const CONFIG = {
   AUTO_RESTART: process.env.AUTO_RESTART === 'true',
   CHROME_RESTART_COOLDOWN: 30000,
   PLUGIN_MAX_MISSED_PINGS: 3,
-  TAKEOVER_PORT: process.env.TAKEOVER_PORT ? parseInt(process.env.TAKEOVER_PORT) : (parseInt(process.env.PORT || '9221') + 1)
+  TAKEOVER_PORT: process.env.TAKEOVER_PORT ? parseInt(process.env.TAKEOVER_PORT) : (parseInt(process.env.PORT || '9221') + 1),
+  POOL_TAKEOVER_PORT: process.env.POOL_TAKEOVER_PORT ? parseInt(process.env.POOL_TAKEOVER_PORT) : 9220,
+  POOL_START: process.env.POOL_START ? parseInt(process.env.POOL_START) : 9222,
+  POOL_SIZE: process.env.POOL_SIZE ? parseInt(process.env.POOL_SIZE) : 9
 };
 
 const LOG_LEVELS = {

package/server/modules/port-pool.js

@@ -0,0 +1,319 @@
+'use strict';
+
+/**
+ * 端口池管理器（v3.0）
+ *
+ * 在现有 proxy 之外，额外启动一组 create 端口（9222-9230）+ 一个 takeover 端口（9220）。
+ * 每个 create 端口 = 一个独立的隔离环境。
+ *
+ * 核心设计：
+ * - 复用现有的 plugin 连接（扩展只连一次 9221/plugin）
+ * - 每个 create 端口有独立的 PortSession（targetId 集合）
+ * - 命令转发给 plugin 时带 __portIndex 标记
+ * - plugin 返回的事件按 __portIndex 路由回对应端口
+ * - 对齐原生 Chrome：多客户端共享、断开不清理 tab
+ */
+
+const http = require('http');
+const WebSocket = require('ws');
+const { CONFIG } = require('./config');
+
+class PortPoolManager {
+  constructor(mainProxy) {
+    this.mainProxy = mainProxy;  // 现有 proxy 的引用（拿 plugin 连接）
+    this.createServers = [];      // [http.Server] 每个 create 端口一个
+    this.createWss = [];          // [WebSocket.Server] 每个 create 端口一个
+    this.portSessions = [];       // [PortSession] 每个 create 端口一个
+    this.takeoverServer = null;
+    this.takeoverWss = null;
+    this.targetToPort = new Map();   // targetId → portIndex（事件路由用）
+    this.sessionToPort = new Map();  // CDP sessionId → portIndex
+  }
+
+  /**
+   * PortSession：一个 create 端口的隔离状态
+   */
+  static PortSession = class {
+    constructor(portIndex, port) {
+      this.portIndex = portIndex;
+      this.port = port;
+      this.targetIds = new Set();        // 这个端口创建的所有 targetId
+      this.tabIds = new Set();           // Chrome tabId（扩展端返回的）
+      this.clients = new Set();          // 连接到这个端口的 client WebSocket
+      this.cdpIdCounter = 1;             // CDP 命令 id 计数器
+      this.pendingRequests = new Map();  // id → {clientWs, resolve, reject}
+      this.targetToClient = new Map();   // targetId → clientWs（attachToTarget 时绑定）
+      this.browserWsUrl = null;          // /json/version 返回的 webSocketDebuggerUrl
+    }
+  };
+
+  start() {
+    // 启动 create 端口（9222-9230）
+    for (let i = 0; i < CONFIG.POOL_SIZE; i++) {
+      const port = CONFIG.POOL_START + i;
+      this._startCreatePort(i, port);
+    }
+
+    // 启动 takeover 端口（9220）
+    this._startTakeoverPort();
+
+    console.log(`\n[PORT POOL] Started: takeover=${CONFIG.POOL_TAKEOVER_PORT}, create=${CONFIG.POOL_START}-${CONFIG.POOL_START + CONFIG.POOL_SIZE - 1}`);
+  }
+
+  _startCreatePort(portIndex, port) {
+    const session = new PortPoolManager.PortSession(portIndex, port);
+    this.portSessions[portIndex] = session;
+
+    const server = http.createServer((req, res) => {
+      this._handleHttp(req, res, session);
+    });
+
+    const wss = new WebSocket.Server({ noServer: true });
+
+    server.on('upgrade', (req, socket, head) => {
+      const url = new URL(req.url, `http://localhost:${port}`);
+      const path = url.pathname;
+
+      // 只允许 client 连接（plugin 连的是 9221）
+      if (path !== '/client' && !path.startsWith('/client/') &&
+          !path.startsWith('/devtools/browser/') && !path.startsWith('/devtools/page/')) {
+        socket.destroy();
+        return;
+      }
+
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        this._handleClientConnect(ws, req, session);
+      });
+    });
+
+    server.on('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        console.error(`[PORT POOL] Port ${port} in use, skipping create port ${portIndex}`);
+      } else {
+        console.error(`[PORT POOL] Create port ${port} error:`, err.message);
+      }
+    });
+
+    server.listen(port, '0.0.0.0', () => {
+      console.log(`[CREATE PORT ${portIndex}] Listening on ${port}`);
+    });
+
+    this.createServers[portIndex] = server;
+    this.createWss[portIndex] = wss;
+  }
+
+  _startTakeoverPort() {
+    const port = CONFIG.POOL_TAKEOVER_PORT;
+    const server = http.createServer((req, res) => {
+      // takeover 的 HTTP 请求转发给主 proxy 的 handleHttpRequest
+      req._takeoverMode = true;
+      this.mainProxy.handleHttpRequest(req, res);
+    });
+
+    server.on('upgrade', (req, socket, head) => {
+      req._takeoverMode = true;
+      // takeover 的 WS 连接转发给主 proxy 的 wss
+      this.mainProxy.handleTakeoverUpgrade(req, socket, head);
+    });
+
+    server.on('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        console.error(`[PORT POOL] Takeover port ${port} in use`);
+      }
+    });
+
+    server.listen(port, '0.0.0.0', () => {
+      console.log(`[TAKEOVER POOL] Listening on ${port}`);
+    });
+
+    this.takeoverServer = server;
+  }
+
+  /**
+   * HTTP 请求处理（/json/version, /json/list 等）
+   * 每个 create 端口只返回自己的 target
+   */
+  async _handleHttp(req, res, session) {
+    const url = new URL(req.url, `http://localhost:${session.port}`);
+    const path = url.pathname;
+
+    if (path === '/json/version') {
+      // 返回版本信息，webSocketDebuggerUrl 指向当前端口
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        Browser: 'Chrome/131.0.6778.86 (cdp-tunnel)',
+        'Protocol-Version': '1.3',
+        'User-Agent': 'cdp-tunnel/3.0',
+        'webSocketDebuggerUrl': `ws://localhost:${session.port}/devtools/browser/pool_${session.portIndex}`
+      }));
+      return;
+    }
+
+    if (path === '/json' || path === '/json/list') {
+      // 只返回这个端口的 target（从主 proxy 拿全量后过滤）
+      const allTargets = await this.mainProxy.getAllTargets(session.portIndex);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(allTargets));
+      return;
+    }
+
+    if (path === '/json/new') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Use Target.createTarget via WebSocket' }));
+      return;
+    }
+
+    res.writeHead(404, { 'Content-Type': 'text/plain' });
+    res.end('Not Found');
+  }
+
+  /**
+   * Client WebSocket 连接处理
+   */
+  _handleClientConnect(ws, req, session) {
+    session.clients.add(ws);
+    console.log(`[PORT ${session.port}] Client connected (total: ${session.clients.size})`);
+
+    // 找到 plugin 连接（从主 proxy 获取）
+    const pluginWs = this.mainProxy.getPluginConnection();
+    if (!pluginWs) {
+      ws.close(1011, 'No extension connected');
+      return;
+    }
+
+    // 消息处理：client → plugin（带 portIndex 标记）
+    ws.on('message', (data) => {
+      let msg;
+      try { msg = JSON.parse(data.toString()); } catch { return; }
+
+      if (msg.id !== undefined) {
+        // 命令：分配新 id，记录映射，转发给 plugin
+        const newId = `pool${session.portIndex}_${msg.id}`;
+        session.pendingRequests.set(newId, {
+          originalId: msg.id,
+          clientWs: ws
+        });
+
+        // 特殊处理 createTarget：记录 targetId 归属
+        if (msg.method === 'Target.createTarget') {
+          msg.params = msg.params || {};
+        }
+
+        const forwarded = { ...msg, id: newId, __portIndex: session.portIndex };
+        pluginWs.send(JSON.stringify(forwarded));
+      } else {
+        // 无 id 的消息（事件），直接转发
+        pluginWs.send(JSON.stringify({ ...msg, __portIndex: session.portIndex }));
+      }
+    });
+
+    ws.on('close', () => {
+      session.clients.delete(ws);
+      console.log(`[PORT ${session.port}] Client disconnected (remaining: ${session.clients.size})`);
+      // 对齐原生 Chrome：断开不清理 tab
+    });
+
+    ws.on('error', () => {
+      session.clients.delete(ws);
+    });
+  }
+
+  /**
+   * 处理从 plugin 返回的消息（按 portIndex 路由回对应端口的 client）
+   * 返回 true 表示已处理（端口池的消息），false 表示不是端口池的
+   */
+  handlePluginMessage(msg, pluginWs) {
+    if (!msg) return false;
+
+    // 1. 响应消息：id 以 pool 开头
+    if (msg.id && typeof msg.id === 'string' && msg.id.startsWith('pool')) {
+      const match = msg.id.match(/^pool(\d+)_(.+)$/);
+      if (!match) return false;
+
+      const portIndex = parseInt(match[1]);
+      const originalId = match[2];
+      const session = this.portSessions[portIndex];
+      if (!session) return false;
+
+      const pending = session.pendingRequests.get(msg.id);
+      session.pendingRequests.delete(msg.id);
+
+      // 如果是 createTarget 响应，记录 targetId → portIndex 归属
+      if (msg.result && msg.result.targetId) {
+        session.targetIds.add(msg.result.targetId);
+        this.targetToPort.set(msg.result.targetId, portIndex);
+        console.log(`[PORT POOL] targetId=${msg.result.targetId.slice(0,12)} → port ${session.port}`);
+      }
+
+      // 如果是 attachToTarget 响应，记录 sessionId → portIndex
+      if (msg.result && msg.result.sessionId) {
+        this.sessionToPort.set(msg.result.sessionId, portIndex);
+        console.log(`[PORT POOL] sessionId=${msg.result.sessionId.slice(0,12)} → port ${session.port}`);
+      }
+
+      // 恢复原始 id，发给发起请求的 client
+      const response = { ...msg, id: this._parseOriginalId(originalId) };
+      if (pending && pending.clientWs && pending.clientWs.readyState === WebSocket.OPEN) {
+        pending.clientWs.send(JSON.stringify(response));
+      } else {
+        // 广播给这个端口的所有 client
+        this._broadcastToPort(portIndex, response);
+      }
+      return true;
+    }
+
+    // 2. 事件消息（无 id）：按 targetId 路由
+    if (msg.method && msg.params) {
+      // 从事件参数里提取 targetId
+      let targetId = null;
+      if (msg.params.targetId) targetId = msg.params.targetId;
+      else if (msg.params.targetInfo && msg.params.targetInfo.targetId) targetId = msg.params.targetInfo.targetId;
+
+      if (targetId) {
+        const portIndex = this.targetToPort.get(targetId);
+        if (portIndex !== undefined) {
+          const session = this.portSessions[portIndex];
+          if (session) {
+            this._broadcastToPort(portIndex, msg);
+            return true;
+          }
+        }
+      }
+
+      // sessionId 路由（attachedToTarget 后的 session 事件）
+      if (msg.sessionId) {
+        const portIndex = this.sessionToPort.get(msg.sessionId);
+        if (portIndex !== undefined) {
+          this._broadcastToPort(portIndex, msg);
+          return true;
+        }
+      }
+    }
+
+    return false;  // 不是端口池的消息
+  }
+
+  _parseOriginalId(idStr) {
+    const n = parseInt(idStr);
+    return isNaN(n) ? idStr : n;
+  }
+
+  _broadcastToPort(portIndex, msg) {
+    const session = this.portSessions[portIndex];
+    if (!session) return;
+    const data = JSON.stringify(msg);
+    session.clients.forEach(clientWs => {
+      if (clientWs.readyState === WebSocket.OPEN) {
+        clientWs.send(data);
+      }
+    });
+  }
+
+  stop() {
+    this.createServers.forEach(s => { try { s.close(); } catch {} });
+    if (this.takeoverServer) { try { this.takeoverServer.close(); } catch {} }
+    console.log('[PORT POOL] Stopped');
+  }
+}
+
+module.exports = { PortPoolManager };

package/server/proxy-server.js

@@ -16,7 +16,11 @@ const path = require('path');
 const os = require('os');
 const { execSync, spawn: spawnProcess } = require('child_process');
 const { CONFIG, BROWSER_ID, shouldLog } = require('./modules/config');
+const { PortPoolManager } = require('./modules/port-pool');
 const TAKEOVER_PORT = CONFIG.TAKEOVER_PORT;
+
+// v3.0 端口池（提前声明，后面初始化）
+let portPool = null;
 const { logCDP, logEvent, clearLog, logStatus, logConnectionEvent, flushAllLogs, logDisconnect } = require('./modules/logger');
 
 try {
@@ -394,7 +398,31 @@ async function handleHttpRequest(req, res) {
         res.end(JSON.stringify(targetList));
         return;
     }
-    
+
+    if (url.pathname === '/debug/maps') {
+        const stats = {};
+        for (const [pluginWs, ns] of pluginNamespaces) {
+            stats.targetIdToClientId = ns.targetIdToClientId.size;
+            stats.sessionToClientId = ns.sessionToClientId.size;
+            stats.browserContextToClientId = ns.browserContextToClientId.size;
+            stats.clientIdToBrowserContext = ns.clientIdToBrowserContext.size;
+            stats.pendingAttachedEvents = ns.pendingAttachedEvents.size;
+            stats.pendingTargetCreatedEvents = ns.pendingTargetCreatedEvents.size;
+            stats.pendingSessionToClientId = (ns.pendingSessionToClientId || new Map()).size;
+            stats.discoveringClientIds = ns.discoveringClientIds.size;
+            stats.cachedTargets = ns.cachedTargets.length;
+        }
+        stats.globalRequestIdMap = globalRequestIdMap.size;
+        stats.connectionPairs = connectionPairs.size;
+        stats.clientById = clientById.size;
+        stats.clientIdToPlugin = clientIdToPlugin.size;
+        stats.clientConnections = clientConnections.size;
+        stats.pluginConnections = pluginConnections.size;
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(stats, null, 2));
+        return;
+    }
+
     res.writeHead(404, { 'Content-Type': 'text/plain' });
     res.end('Not Found');
 }
@@ -543,6 +571,33 @@ function cleanupClient(ws, id, reason) {
         for (const [tId, cId] of ns.targetIdToClientId.entries()) {
             if (cId === id) ns.targetIdToClientId.delete(tId);
         }
+        // session 清理：value 可能是 clientId（正常）或 targetId（旧 bug 残留，兼容清理）
+        const clientTargetIds = new Set();
+        for (const [tId, cId] of ns.targetIdToClientId.entries()) {
+            if (cId === id) clientTargetIds.add(tId);
+        }
+        for (const [sId, val] of ns.sessionToClientId.entries()) {
+            if (val === id || clientTargetIds.has(val)) {
+                ns.sessionToClientId.delete(sId);
+            }
+        }
+        // 清理 pending session（归属未定的暂存）
+        if (ns.pendingSessionToClientId) {
+            for (const [pSid, pTid] of ns.pendingSessionToClientId.entries()) {
+                if (clientTargetIds.has(pTid)) ns.pendingSessionToClientId.delete(pSid);
+            }
+        }
+        // 清理 pending 事件（targetCreated/attachedToTarget 缓存，防止泄漏）
+        if (ns.pendingAttachedEvents) {
+            for (const [pTid] of ns.pendingAttachedEvents.entries()) {
+                if (clientTargetIds.has(pTid)) ns.pendingAttachedEvents.delete(pTid);
+            }
+        }
+        if (ns.pendingTargetCreatedEvents) {
+            for (const [pTid] of ns.pendingTargetCreatedEvents.entries()) {
+                if (clientTargetIds.has(pTid)) ns.pendingTargetCreatedEvents.delete(pTid);
+            }
+        }
         for (const [bcId, cId] of ns.browserContextToClientId.entries()) {
             if (cId === id) ns.browserContextToClientId.delete(bcId);
         }
@@ -739,7 +794,7 @@ function handlePluginConnection(ws, clientInfo, request) {
     // 消息转发: Plugin -> Client
     ws.on('message', (data) => {
         console.log(`[PLUGIN MESSAGE] size=${data.length}`);
-        
+
         const messageSize = data.length;
         let messagePreview;
         let parsed;
@@ -754,7 +809,12 @@ function handlePluginConnection(ws, clientInfo, request) {
         if (shouldLog('debug')) {
             console.log(`[PLUGIN -> CLIENT] ${id}: ${messagePreview}`);
         }
-        
+
+        // v3.0 端口池 hook：先让 PortPoolManager 处理端口池的消息
+        if (parsed && portPool && portPool.handlePluginMessage(parsed, ws)) {
+            return;  // 已被端口池处理
+        }
+
         // 处理 keepalive 消息
         if (parsed && parsed.type === 'keepalive') {
             ws.isAlive = true;
@@ -874,8 +934,11 @@ function handlePluginConnection(ws, clientInfo, request) {
                         ns.sessionToClientId.set(sessionId, clientId);
                         console.log(`[SESSION MAPPED] sessionId=${sessionId?.substring(0,8) || 'none'} -> clientId=${clientId?.substring(0,8) || 'none'}`);
                     } else {
-                        ns.sessionToClientId.set(sessionId, targetId);
-                        console.log(`[SESSION MAPPED] sessionId=${sessionId?.substring(0,8) || 'none'} -> targetId=${targetId?.substring(0,8) || 'none'} (no pairedClientId)`);
+                        // 以前这里存 targetId 作为 value，导致 cleanupClient 按 clientId 匹配时清不掉（泄漏）
+                        // 改为：暂存到 pendingSessionToClientId，等 targetId 归属绑定时再补绑
+                        if (!ns.pendingSessionToClientId) ns.pendingSessionToClientId = new Map();
+                        ns.pendingSessionToClientId.set(sessionId, targetId);
+                        console.log(`[SESSION MAPPED] sessionId=${sessionId?.substring(0,8) || 'none'} -> targetId=${targetId?.substring(0,8) || 'none'} (pending, no clientId yet)`);
                     }
                 }
             }
@@ -940,7 +1003,19 @@ function handlePluginConnection(ws, clientInfo, request) {
                         const targetId = parsed.result.targetId;
                         ns.targetIdToClientId.set(targetId, mapping.clientId);
                         console.log(`[TARGET MAPPED] targetId=${targetId} -> clientId=${mapping.clientId} mapSize=${ns.targetIdToClientId.size}`);
-                        
+
+                        // 补绑 pending 的 session（之前 targetId 归属未定时暂存的）
+                        if (ns.pendingSessionToClientId && ns.pendingSessionToClientId.size > 0) {
+                            const pendingSessionId = null;
+                            for (const [pSid, pTid] of ns.pendingSessionToClientId.entries()) {
+                                if (pTid === targetId) {
+                                    ns.sessionToClientId.set(pSid, mapping.clientId);
+                                    ns.pendingSessionToClientId.delete(pSid);
+                                    console.log(`[SESSION MAPPED from pending] sessionId=${pSid?.substring(0,8)} -> clientId=${mapping.clientId?.substring(0,8)} (targetId=${targetId?.substring(0,8)})`);
+                                }
+                            }
+                        }
+
                         const cachedCreated = ns.pendingTargetCreatedEvents.get(targetId);
                         if (cachedCreated) {
                             clientWs.send(cachedCreated.cdpData);
@@ -2048,3 +2123,29 @@ takeoverServer.on('error', (err) => {
 takeoverServer.listen(TAKEOVER_PORT, '0.0.0.0', () => {
     console.log(`[TAKEOVER] Listening on port ${TAKEOVER_PORT}`);
 });
+
+// v3.0 端口池启动
+portPool = new PortPoolManager({
+    getPluginConnection: () => {
+        for (const ws of pluginConnections) return ws;
+        return null;
+    },
+    getAllTargets: async (portIndex) => {
+        const session = portPool.portSessions[portIndex];
+        if (!session) return [];
+        // 从主 proxy 的 namespace 拿所有 target，过滤出这个端口的
+        const targets = [];
+        for (const [, ns] of pluginNamespaces) {
+            if (ns.cachedTargets) {
+                for (const t of ns.cachedTargets) {
+                    if (session.targetIds.has(t.targetId)) {
+                        targets.push(t);
+                    }
+                }
+            }
+        }
+        return targets;
+    }
+});
+portPool.start();
+