cdp-tunnel 3.5.0 → 3.6.1

package/server/proxy-server.js

@@ -24,8 +24,10 @@ let portPool = null;
 const { logCDP, logEvent, clearLog, logStatus, logConnectionEvent, flushAllLogs, logDisconnect } = require('./modules/logger');
 
 let validateApiKey = null;
+let saasAuth = null;  // 完整 SaaS auth 模块（createApiKey/listApiKeys/revokeApiKey）
 try {
-    validateApiKey = require('./saas/auth').validateApiKey;
+    saasAuth = require('./saas/auth');
+    validateApiKey = saasAuth.validateApiKey;
     var HAS_SAAS = true;
 } catch (e) {
     var HAS_SAAS = false;
@@ -164,7 +166,6 @@ const clientConnections = new Set();
 class PluginNamespace {
     constructor() {
         this.sessionToClientId = new Map();
-        this.pendingAttachRequests = new Map();
         this.pendingAttachedEvents = new Map();
         this.pendingTargetCreatedEvents = new Map();
         this.targetIdToClientId = new Map();
@@ -318,6 +319,250 @@ function resolvePluginFromUrl(url) {
     return pluginConnections.values().next().value || null;
 }
 
+// ===== 管理控制台 API =====
+// 鉴权：ADMIN_TOKEN 环境变量（Bearer token 或 query ?token=）
+// 未设 ADMIN_TOKEN 时只允许 localhost（开发友好）
+function checkAdminAuth(req, url) {
+    const token = process.env.ADMIN_TOKEN;
+    if (!token) {
+        // 未设 token：只允许 localhost
+        const ip = req.socket.remoteAddress;
+        return ip === '127.0.0.1' || ip === '::1' || ip === '::ffff:127.0.0.1';
+    }
+    // 设了 token：校验 Bearer 或 query
+    const authHeader = req.headers.authorization || '';
+    const bearer = authHeader.startsWith('Bearer ') ? authHeader.slice(7) : null;
+    const queryToken = url.searchParams.get('token');
+    return bearer === token || queryToken === token;
+}
+
+function adminJson(res, code, data) {
+    res.writeHead(code, { 'Content-Type': 'application/json; charset=utf-8' });
+    res.end(JSON.stringify(data));
+}
+
+async function readBody(req) {
+    return new Promise(resolve => {
+        let d = ''; req.on('data', c => d += c);
+        req.on('end', () => { try { resolve(JSON.parse(d)); } catch { resolve({}); } });
+    });
+}
+
+async function handleAdminApi(req, res, url) {
+    const path = url.pathname.replace('/admin/api/', '');
+    const method = req.method;
+
+    if (!checkAdminAuth(req, url)) {
+        return adminJson(res, 401, { error: 'Unauthorized. Set ADMIN_TOKEN env or access from localhost.' });
+    }
+
+    try {
+        // 浏览器列表
+        if (path === 'browsers' && method === 'GET') {
+            const browsers = [];
+            for (const pluginWs of pluginConnections) {
+                if (pluginWs.readyState !== WebSocket.OPEN) continue;
+                const ns = getNamespace(pluginWs);
+                browsers.push({
+                    pluginId: pluginWs.pluginId,
+                    pluginName: pluginWs.pluginName || 'My Browser',
+                    userId: pluginWs.userId || null,
+                    apiKeyId: pluginWs.apiKeyId || null,
+                    browserName: ns.cachedBrowserVersion?.Browser || 'Unknown',
+                    userAgent: ns.cachedBrowserVersion?.['User-Agent'] || '',
+                    targets: ns.cachedTargets?.length || 0,
+                    connected: true,
+                    connectedAt: pluginWs.connectedAt,
+                    extVersion: pluginWs.extVersion || 'unknown'
+                });
+            }
+            return adminJson(res, 200, browsers);
+        }
+
+        // key 管理（需要 SaaS）
+        if (path === 'keys' && method === 'GET') {
+            if (!saasAuth) return adminJson(res, 503, { error: 'SaaS not available' });
+            return adminJson(res, 200, saasAuth.listApiKeys('builtin-admin'));
+        }
+        if (path === 'keys' && method === 'POST') {
+            if (!saasAuth) return adminJson(res, 503, { error: 'SaaS not available' });
+            const body = await readBody(req);
+            const name = body.name || ('browser-' + Date.now().toString(36));
+            const result = saasAuth.createApiKey('builtin-admin', name);
+            const port = PORT;
+            return adminJson(res, 200, {
+                ...result,
+                pluginUrl: `ws://localhost:${port}/plugin?key=${result.key}`,
+                clientUrl: `ws://localhost:${port}/client?key=${result.key}`
+            });
+        }
+        if (path.startsWith('keys/') && method === 'DELETE') {
+            if (!saasAuth) return adminJson(res, 503, { error: 'SaaS not available' });
+            const keyId = path.split('/')[1];
+            const result = saasAuth.revokeApiKey(keyId, 'builtin-admin');
+            return adminJson(res, result.changes > 0 ? 200 : 404, { ok: result.changes > 0, changes: result.changes });
+        }
+
+        // CDP 快捷操作（通过 pluginId 直接连已在线浏览器）
+        if (path.startsWith('cdp/') && method === 'POST') {
+            const body = await readBody(req);
+            if (!body.pluginId) return adminJson(res, 400, { error: 'Missing pluginId' });
+            const result = await execCdpViaPlugin(body.pluginId, body);
+            return adminJson(res, result.error ? 500 : 200, result);
+        }
+
+        return adminJson(res, 404, { error: 'Not found: ' + path });
+    } catch (e) {
+        return adminJson(res, 500, { error: e.message });
+    }
+}
+
+// 通过 pluginId 走端口池 /client 路径执行 CDP 命令（复用完整分组/session 路由逻辑）
+async function execCdpViaPlugin(pluginId, params) {
+    const action = params.action || 'evaluate';
+    // 找到 pluginId 对应的 plugin 连接
+    let pluginWs = null;
+    for (const ws of pluginConnections) {
+        if (ws.readyState === WebSocket.OPEN && ws.pluginId === pluginId) { pluginWs = ws; break; }
+    }
+    if (!pluginWs) return { error: 'Browser not found or offline' };
+
+    // closebrowser 特殊处理：不走 /client（会被 Browser.close 断开），
+    // 直接用 pluginWs 发 client-disconnected + closeTarget
+    if (action === 'closebrowser') {
+        // 从 apiKey 找到对应的 key session 的端口，拿到正确的 clientId
+        let clientId = `pool_${PORT}`;  // fallback
+        if (pluginWs.apiKey && portPool && portPool._keyToPortIndex) {
+            const portIdx = portPool._keyToPortIndex.get(pluginWs.apiKey);
+            if (portIdx !== undefined && portPool.portSessions[portIdx]) {
+                clientId = `pool_${portPool.portSessions[portIdx].port}`;
+            }
+        }
+        // 发 client-disconnected 让扩展关分组 + 关 tab
+        try {
+            pluginWs.send(JSON.stringify({ type: 'client-disconnected', clientId }));
+        } catch (e) {}
+        // 清理 key session（让下次连接重新分配）
+        if (pluginWs.apiKey && portPool) {
+            portPool.keySessions.delete(pluginWs.apiKey);
+            if (portPool._keyToPortIndex) portPool._keyToPortIndex.delete(pluginWs.apiKey);
+        }
+        return { closed: true };
+    }
+
+    const apiKey = pluginWs.apiKey;
+    if (!apiKey) return { error: 'Browser has no API key (not connected via /plugin?key=)' };
+
+    // 内部连 /client?key=xxx，走端口池完整路径（建组 + session 路由 + 分组）
+    const port = PORT;
+    return new Promise((resolve) => {
+        const ws = new WebSocket(`ws://127.0.0.1:${port}/client?key=${apiKey}`);
+        const pending = new Map(); let id = 1; let sessionId = null;
+        const timeout = setTimeout(() => { try { ws.close(); } catch {}; resolve({ error: 'Timeout' }); }, 15000);
+
+        function cdp(method, p = {}, sid) {
+            return new Promise((res, rej) => {
+                const i = id++; pending.set(i, { resolve: res, reject: rej });
+                const o = { id: i, method, params: p };
+                if (sid) o.sessionId = sid; else if (sessionId) o.sessionId = sessionId;
+                ws.send(JSON.stringify(o));
+                setTimeout(() => { if (pending.has(i)) { pending.delete(i); rej(new Error('CDP timeout: ' + method)); } }, 12000);
+            });
+        }
+
+        function finish(result) { clearTimeout(timeout); try { ws.close(); } catch {}; resolve(result); }
+
+        ws.on('message', async (data) => {
+            const m = JSON.parse(data.toString());
+            if (m.id && pending.has(m.id)) {
+                const { resolve: r, reject: rj } = pending.get(m.id); pending.delete(m.id);
+                m.error ? rj(new Error(JSON.stringify(m.error))) : r(m.result);
+                return;
+            }
+            // attachedToTarget 事件 → 记 sessionId
+            if (m.method === 'Target.attachedToTarget' && m.params?.sessionId && !sessionId) {
+                sessionId = m.params.sessionId;
+                try {
+                    if (action === 'evaluate') {
+                        await cdp('Runtime.enable', {}, sessionId);
+                        const ev = await cdp('Runtime.evaluate', { expression: params.expression || 'document.title', returnByValue: true }, sessionId);
+                        finish({ result: ev.result.value });
+                    } else if (action === 'screenshot') {
+                        await cdp('Page.enable', {}, sessionId);
+                        const shot = await cdp('Page.captureScreenshot', { format: 'png' }, sessionId);
+                        finish({ screenshot: shot.data });
+                    }
+                } catch (e) { finish({ error: e.message }); }
+            }
+        });
+
+        ws.on('open', async () => {
+            try {
+                // listtabs：走 /client 路径，getTargets 被端口池按 key 自动过滤
+                if (action === 'listtabs') {
+                    await cdp('Target.setAutoAttach', { autoAttach: true, waitForDebuggerOnStart: false, flatten: true });
+                    const tg = await cdp('Target.getTargets');
+                    const tabs = (tg?.targetInfos || [])
+                        .filter(t => t.type === 'page')
+                        .map(t => ({ targetId: t.targetId, url: t.url, title: t.title || '', attached: t.attached }));
+                    finish({ tabs });
+                }
+                // closetab：关闭指定 targetId
+                else if (action === 'closetab') {
+                    await cdp('Target.setAutoAttach', { autoAttach: true, waitForDebuggerOnStart: false, flatten: true });
+                    await cdp('Target.closeTarget', { targetId: params.targetId });
+                    finish({ closed: true, targetId: params.targetId });
+                }
+                // switchtab：切换到指定 targetId（bringToFront）
+                else if (action === 'switchtab') {
+                    await cdp('Target.setAutoAttach', { autoAttach: true, waitForDebuggerOnStart: false, flatten: true });
+                    const at = await cdp('Target.attachToTarget', { targetId: params.targetId, flatten: true });
+                    if (at.sessionId) {
+                        await cdp('Page.enable', {}, at.sessionId);
+                        await cdp('Page.bringToFront', {}, at.sessionId);
+                    }
+                    finish({ switched: true, targetId: params.targetId });
+                }
+                else if (action === 'newtab') {
+                    await cdp('Target.setAutoAttach', { autoAttach: true, waitForDebuggerOnStart: false, flatten: true });
+                    const created = await cdp('Target.createTarget', { url: params.url || 'about:blank' });
+                    finish({ targetId: created.targetId });
+                } else {
+                    // evaluate/screenshot：直接 getTargets + attach（不等 setAutoAttach 事件，避免超时）
+                    await cdp('Target.setAutoAttach', { autoAttach: true, waitForDebuggerOnStart: false, flatten: true });
+                    const tg = await cdp('Target.getTargets');
+                    let page = (tg.targetInfos || []).find(t => t.type === 'page');
+                    if (!page) {
+                        const created = await cdp('Target.createTarget', { url: 'about:blank' });
+                        page = { targetId: created.targetId };
+                    }
+                    // attach 后等 attachedToTarget 事件触发 evaluate/screenshot
+                    // 如果事件没来，1 秒后用手动方式（attach 响应里的 sessionId）
+                    const at = await cdp('Target.attachToTarget', { targetId: page.targetId, flatten: true });
+                    // 如果事件路径没处理，手动执行
+                    setTimeout(async () => {
+                        if (sessionId || !at.sessionId) return;
+                        sessionId = at.sessionId;
+                        try {
+                            if (action === 'evaluate') {
+                                await cdp('Runtime.enable', {}, sessionId);
+                                const ev = await cdp('Runtime.evaluate', { expression: params.expression || 'document.title', returnByValue: true }, sessionId);
+                                finish({ result: ev.result.value });
+                            } else if (action === 'screenshot') {
+                                await cdp('Page.enable', {}, sessionId);
+                                const shot = await cdp('Page.captureScreenshot', { format: 'png' }, sessionId);
+                                finish({ screenshot: shot.data });
+                            }
+                        } catch (e) { finish({ error: e.message }); }
+                    }, 1000);
+                }
+            } catch (e) { finish({ error: e.message }); }
+        });
+
+        ws.on('error', e => { clearTimeout(timeout); resolve({ error: e.message }); });
+    });
+}
+
 async function handleHttpRequest(req, res) {
     const url = new URL(req.url, `http://localhost:${PORT}`);
 
@@ -333,6 +578,21 @@ async function handleHttpRequest(req, res) {
         return;
     }
 
+    // 管理控制台：/admin 返回页面，/admin/api/* 返回 JSON
+    if (url.pathname === '/admin' || url.pathname === '/admin/') {
+        try {
+            const html = fs.readFileSync(path.join(__dirname, 'admin-console.html'), 'utf8');
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(html);
+        } catch (e) {
+            res.writeHead(500); res.end('Admin console not found: ' + e.message);
+        }
+        return;
+    }
+    if (url.pathname.startsWith('/admin/api/')) {
+        return handleAdminApi(req, res, url);
+    }
+
     if (url.pathname === '/json/browsers' || url.pathname === '/json/browsers/') {
         const browsers = [];
         for (const pluginWs of pluginConnections) {
@@ -707,8 +967,7 @@ function cleanupPlugin(ws, id, reason) {
         remainingPlugins: pluginConnections.size,
         affectedClients,
         uptime: ws.connectedAt ? `${((Date.now() - ws.connectedAt) / 1000).toFixed(0)}s` : 'unknown',
-        activeSessions: ns.sessionToClientId.size,
-        pendingRequests: ns.pendingAttachRequests.size
+        activeSessions: ns.sessionToClientId.size
     });
 
     if (ws.pairedClientId) {
@@ -756,6 +1015,7 @@ function handlePluginConnection(ws, clientInfo, request) {
                 ws.userId = keyInfo.userId;
                 ws.apiKeyId = keyInfo.keyId;
                 ws.apiKey = apiKey;  // 记录 key 字符串，供 client 连接时反查 plugin
+                ws.apiKeyName = keyInfo.keyName;  // key 名称，用作 Chrome 分组名
                 logConnectionEvent('PLUGIN_AUTHED', `userId=${keyInfo.userId} keyName=${keyInfo.keyName}`);
             } else {
                 logConnectionEvent('PLUGIN_AUTH_FAIL', 'Invalid API key');
@@ -1123,23 +1383,7 @@ function handlePluginConnection(ws, clientInfo, request) {
                         invalidateTargetsCache(ws);
                     }
                     
-                    if (mapping.isAutoDefaultPage) {
-                        console.log(`[AUTO DEFAULT PAGE] createTarget response received for client=${mapping.clientId}, targetId=${parsed.result?.targetId?.substring(0,8) || 'none'} — skipping response send to client`);
-                        
-                        if (mapping.pendingSetAutoAttach) {
-                            const pending = mapping.pendingSetAutoAttach;
-                            const pendingParsed = pending.parsed;
-                            const pendingClientId = pending.clientId;
-                            
-                            console.log(`[AUTO DEFAULT PAGE] Now forwarding pending setAutoAttach for client=${pendingClientId}`);
-                            
-                            if (ws.readyState === WebSocket.OPEN) {
-                                const forwardMsg = { ...pendingParsed, __clientId: pendingClientId };
-                                ws.send(JSON.stringify(forwardMsg));
-                                console.log(`[SEND TO PLUGIN] Forwarding setAutoAttach for client=${pendingClientId}`);
-                            }
-                        }
-                    } else {
+                    {
                         const originalId = mapping.originalId;
                         parsed.id = originalId;
                         if (mapping.sessionId && !parsed.sessionId) {
@@ -1245,52 +1489,6 @@ function handlePluginConnection(ws, clientInfo, request) {
     }));
 }
 
-function autoCreateDefaultPageAndForward(clientWs, setAutoAttachParsed, originalData, clientId, originalRequestId) {
-    const pluginWs = clientWs.pairedPlugin;
-    if (!pluginWs || pluginWs.readyState !== WebSocket.OPEN) {
-        forwardToPlugin(clientWs, originalData, clientId);
-        return;
-    }
-
-    globalRequestIdCounter++;
-    const createGlobalId = globalRequestIdCounter;
-
-    globalRequestIdMap.set(createGlobalId, {
-        clientId: clientId,
-        originalId: -1,
-        sessionId: null,
-        method: 'Target.createTarget',
-        isCreateTarget: true,
-        isAutoDefaultPage: true,
-        pendingSetAutoAttach: {
-            parsed: setAutoAttachParsed,
-            data: originalData,
-            clientId: clientId,
-            originalRequestId: originalRequestId
-        }
-    });
-
-    const request = {
-        id: createGlobalId,
-        method: 'Target.createTarget',
-        params: { url: 'about:blank' },
-        __clientId: clientId
-    };
-
-    console.log(`[AUTO DEFAULT PAGE] Sending Target.createTarget for client=${clientId} globalId=${createGlobalId}, will forward setAutoAttach after`);
-    pluginWs.send(JSON.stringify(request));
-}
-
-function forwardToPlugin(clientWs, data, clientId) {
-    const pluginWs = clientWs.pairedPlugin;
-    if (pluginWs && pluginWs.readyState === WebSocket.OPEN) {
-        console.log(`[SEND TO PLUGIN] method=Target.setAutoAttach clientId=${clientId}`);
-        pluginWs.send(data);
-    } else {
-        broadcastToPlugins(data, clientWs);
-    }
-}
-
 /**
  * 处理 CDP 客户端连接 (Playwright/Puppeteer)
  */
@@ -1513,13 +1711,9 @@ function handleClientConnection(ws, clientInfo, customClientId = null, targetPlu
 
         if (parsed && parsed.method === 'Target.setAutoAttach' && parsed.params?.autoAttach && !ws._autoDefaultPageSent) {
             ws._autoDefaultPageSent = true;
-            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);
+            const forwardMsg = { ...parsed, __clientId: id, __mode: ws.mode };
+            if (ws.pairedPlugin && ws.pairedPlugin.readyState === WebSocket.OPEN) {
+                ws.pairedPlugin.send(JSON.stringify(forwardMsg));
             }
             return;
         }
@@ -2069,10 +2263,8 @@ setInterval(() => {
     });
     
     let totalSessions = 0;
-    let totalPendingAttach = 0;
     pluginNamespaces.forEach(ns => {
         totalSessions += ns.sessionToClientId.size;
-        totalPendingAttach += ns.pendingAttachRequests.size;
     });
     
     logStatus({
@@ -2084,8 +2276,7 @@ setInterval(() => {
         pairs: connectionPairs.size,
         pluginDetails: pluginList,
         clientDetails: clientList,
-        sessions: totalSessions,
-        pendingAttach: totalPendingAttach
+        sessions: totalSessions
     });
 }, CONFIG.STATUS_PRINT_INTERVAL);
 
@@ -2162,11 +2353,6 @@ portPool = new PortPoolManager({
         if (!apiKey) return false;
         return !!validateApiKey(apiKey);
     },
-    handlePluginUpgrade: (req, socket, head) => {
-        wss.handleUpgrade(req, socket, head, (ws) => {
-            wss.emit('connection', ws, req);
-        });
-    },
     handleTakeoverUpgrade: (req, socket, head) => {
         req._takeoverMode = true;
         const url = new URL(req.url, `http://localhost:${CONFIG.TAKEOVER_PORT}`);
@@ -2186,22 +2372,6 @@ portPool = new PortPoolManager({
         wss.handleUpgrade(req, socket, head, (ws) => {
             wss.emit('connection', ws, req);
         });
-    },
-    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();