cdp-tunnel 2.10.14 → 3.0.1

package/extension-new/manifest.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdp-tunnel",
-  "version": "2.10.14",
+  "version": "3.0.1",
   "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) : 9231,
+  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 {
@@ -790,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;
@@ -805,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;
@@ -2114,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();
+