chrome-cdp-cli 1.5.0 → 1.6.0

package/dist/proxy/server/WSProxy.js

@@ -0,0 +1,456 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WSProxy = void 0;
+const WebSocket = __importStar(require("ws"));
+const logger_1 = require("../../utils/logger");
+class WSProxy {
+    constructor(connectionPool) {
+        this.connections = new Map();
+        this.eventSubscriptions = new Map();
+        this.clientEventFilters = new Map();
+        this.connectionPool = connectionPool;
+        this.logger = (0, logger_1.createLogger)({ component: 'WSProxy' });
+    }
+    start(wsServer) {
+        this.wsServer = wsServer;
+        this.wsServer.on('connection', (ws, request) => {
+            this.handleConnection(ws, request);
+        });
+        this.logger.info('WebSocket proxy started');
+    }
+    stop() {
+        if (this.wsServer) {
+            for (const [proxyId] of Array.from(this.connections)) {
+                this.closeProxyConnection(proxyId);
+            }
+            this.wsServer.close();
+            this.wsServer = undefined;
+            this.logger.info('WebSocket proxy stopped');
+        }
+    }
+    handleConnection(ws, request) {
+        try {
+            const url = new URL(request.url || '', `http://${request.headers.host}`);
+            let connectionId = url.searchParams.get('connectionId');
+            if (!connectionId) {
+                const pathParts = url.pathname.split('/');
+                if (pathParts.length >= 3 && pathParts[1] === 'ws') {
+                    connectionId = pathParts[2];
+                }
+            }
+            if (!connectionId) {
+                this.logger.logClientEvent('error', 'unknown', 'WebSocket connection rejected: Connection ID required', {
+                    clientIP: request.socket.remoteAddress,
+                    userAgent: request.headers['user-agent']
+                });
+                ws.close(1008, 'Connection ID required');
+                return;
+            }
+            const cdpConnection = this.connectionPool.getConnectionInfo(connectionId);
+            if (!cdpConnection) {
+                this.logger.logClientEvent('error', 'unknown', `WebSocket connection rejected: Invalid connection ID ${connectionId}`, {
+                    connectionId,
+                    clientIP: request.socket.remoteAddress
+                });
+                ws.close(1008, 'Invalid connection ID');
+                return;
+            }
+            if (!cdpConnection.isHealthy) {
+                this.logger.logClientEvent('error', 'unknown', `WebSocket connection rejected: CDP connection ${connectionId} is not healthy`, {
+                    connectionId,
+                    clientIP: request.socket.remoteAddress
+                });
+                ws.close(1011, 'CDP connection unavailable');
+                return;
+            }
+            const proxyId = this.generateProxyId();
+            const proxyConnection = {
+                id: proxyId,
+                clientWs: ws,
+                connectionId,
+                createdAt: Date.now(),
+                messageCount: 0
+            };
+            this.connections.set(proxyId, proxyConnection);
+            this.incrementClientCount(connectionId);
+            if (!this.eventSubscriptions.has(connectionId)) {
+                this.eventSubscriptions.set(connectionId, new Set());
+            }
+            this.eventSubscriptions.get(connectionId).add(proxyId);
+            this.clientEventFilters.set(proxyId, new Set());
+            this.logger.logClientEvent('connected', proxyId, `WebSocket proxy connection established for CDP connection ${connectionId}`, {
+                connectionId,
+                clientCount: cdpConnection.clientCount,
+                clientIP: request.socket.remoteAddress,
+                userAgent: request.headers['user-agent']
+            });
+            this.setupMessageForwarding(proxyConnection, cdpConnection);
+            ws.on('close', (code, reason) => {
+                this.logger.logClientEvent('disconnected', proxyId, `WebSocket client disconnected`, {
+                    connectionId,
+                    code,
+                    reason: reason?.toString(),
+                    messageCount: proxyConnection.messageCount,
+                    sessionDuration: Date.now() - proxyConnection.createdAt
+                });
+                this.handleClientDisconnection(proxyId);
+            });
+            ws.on('error', (error) => {
+                this.logger.error(`WebSocket proxy error for ${proxyId}:`, error);
+                this.closeProxyConnection(proxyId);
+            });
+            ws.send(JSON.stringify({
+                type: 'proxy-connected',
+                proxyId,
+                connectionId,
+                timestamp: Date.now()
+            }));
+        }
+        catch (error) {
+            this.logger.error('Error handling WebSocket connection:', error);
+            ws.close(1011, 'Internal server error');
+        }
+    }
+    forwardMessage(proxyId, message) {
+        const proxyConnection = this.connections.get(proxyId);
+        if (proxyConnection && proxyConnection.clientWs.readyState === WebSocket.OPEN) {
+            proxyConnection.clientWs.send(message);
+            proxyConnection.messageCount++;
+        }
+    }
+    closeProxyConnection(proxyId) {
+        const proxyConnection = this.connections.get(proxyId);
+        if (proxyConnection) {
+            if (proxyConnection.clientWs.readyState === WebSocket.OPEN) {
+                proxyConnection.clientWs.close(1000, 'Proxy connection closed');
+            }
+            const connectionId = proxyConnection.connectionId;
+            const subscriptions = this.eventSubscriptions.get(connectionId);
+            if (subscriptions) {
+                subscriptions.delete(proxyId);
+                if (subscriptions.size === 0) {
+                    this.eventSubscriptions.delete(connectionId);
+                }
+            }
+            this.clientEventFilters.delete(proxyId);
+            this.connectionPool.decrementClientCount(proxyConnection.connectionId);
+            this.connections.delete(proxyId);
+            this.logger.info(`WebSocket proxy connection ${proxyId} closed`);
+        }
+    }
+    getActiveProxyConnections() {
+        return Array.from(this.connections.values());
+    }
+    getProxyConnectionsForCDP(connectionId) {
+        return Array.from(this.connections.values()).filter(proxy => proxy.connectionId === connectionId);
+    }
+    broadcastToCDPClients(connectionId, message) {
+        const proxyConnections = this.getProxyConnectionsForCDP(connectionId);
+        let sentCount = 0;
+        for (const proxyConnection of proxyConnections) {
+            if (proxyConnection.clientWs.readyState === WebSocket.OPEN) {
+                try {
+                    proxyConnection.clientWs.send(message);
+                    proxyConnection.messageCount++;
+                    sentCount++;
+                }
+                catch (error) {
+                    this.logger.error(`Error broadcasting to proxy ${proxyConnection.id}:`, error);
+                    this.closeProxyConnection(proxyConnection.id);
+                }
+            }
+        }
+        if (sentCount > 0) {
+            this.logger.debug(`Broadcasted message to ${sentCount} clients for CDP connection ${connectionId}`);
+        }
+    }
+    incrementClientCount(connectionId) {
+        const cdpConnection = this.connectionPool.getConnectionInfo(connectionId);
+        if (cdpConnection) {
+            cdpConnection.clientCount++;
+            cdpConnection.lastUsed = Date.now();
+        }
+    }
+    setupMessageForwarding(proxyConnection, cdpConnection) {
+        const { clientWs, connectionId } = proxyConnection;
+        clientWs.on('message', (data) => {
+            try {
+                const message = data.toString();
+                let cdpCommand;
+                try {
+                    cdpCommand = JSON.parse(message);
+                }
+                catch (parseError) {
+                    this.logger.warn(`Invalid JSON from client ${proxyConnection.id}: ${message.substring(0, 100)}`);
+                    clientWs.send(JSON.stringify({
+                        error: { code: -32700, message: 'Parse error' },
+                        id: null
+                    }));
+                    return;
+                }
+                if (this.isProxyCommand(cdpCommand)) {
+                    this.handleProxyCommand(proxyConnection, cdpCommand);
+                    return;
+                }
+                if (!this.isValidCDPCommand(cdpCommand)) {
+                    this.logger.warn(`Invalid CDP command from client ${proxyConnection.id}:`, cdpCommand);
+                    clientWs.send(JSON.stringify({
+                        error: { code: -32600, message: 'Invalid Request' },
+                        id: cdpCommand.id || null
+                    }));
+                    return;
+                }
+                if (cdpConnection.connection.readyState === WebSocket.OPEN) {
+                    cdpConnection.connection.send(message);
+                    proxyConnection.messageCount++;
+                    this.logger.debug(`Forwarded CDP command from client ${proxyConnection.id}: ${cdpCommand.method} (id: ${cdpCommand.id})`);
+                }
+                else {
+                    this.logger.warn(`CDP connection ${connectionId} is not open, cannot forward command`);
+                    clientWs.send(JSON.stringify({
+                        error: { code: -32001, message: 'CDP connection unavailable' },
+                        id: cdpCommand.id || null
+                    }));
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error forwarding message to CDP from client ${proxyConnection.id}:`, error);
+                clientWs.send(JSON.stringify({
+                    error: { code: -32603, message: 'Internal error' },
+                    id: null
+                }));
+            }
+        });
+        const cdpMessageHandler = (data) => {
+            try {
+                const message = data.toString();
+                let cdpMessage;
+                try {
+                    cdpMessage = JSON.parse(message);
+                }
+                catch (parseError) {
+                    this.logger.warn(`Invalid JSON from CDP connection ${connectionId}: ${message.substring(0, 100)}`);
+                    return;
+                }
+                if (this.isCDPResponse(cdpMessage)) {
+                    if (clientWs.readyState === WebSocket.OPEN) {
+                        clientWs.send(message);
+                        proxyConnection.messageCount++;
+                        this.logger.debug(`Forwarded CDP response to client ${proxyConnection.id}: id ${cdpMessage.id}`);
+                    }
+                }
+                else if (this.isCDPEvent(cdpMessage)) {
+                    this.forwardEventToSubscribedClients(connectionId, cdpMessage, message);
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error forwarding message to client ${proxyConnection.id}:`, error);
+            }
+        };
+        cdpConnection.connection.on('message', cdpMessageHandler);
+        clientWs.on('close', () => {
+            cdpConnection.connection.off('message', cdpMessageHandler);
+            this.logger.debug(`Cleaned up CDP message handler for proxy ${proxyConnection.id}`);
+        });
+    }
+    forwardEventToSubscribedClients(connectionId, cdpEvent, rawMessage) {
+        const subscribedProxies = this.eventSubscriptions.get(connectionId);
+        if (!subscribedProxies || subscribedProxies.size === 0) {
+            return;
+        }
+        let forwardedCount = 0;
+        for (const proxyId of Array.from(subscribedProxies)) {
+            const proxyConnection = this.connections.get(proxyId);
+            if (!proxyConnection || proxyConnection.clientWs.readyState !== WebSocket.OPEN) {
+                continue;
+            }
+            const clientFilters = this.clientEventFilters.get(proxyId);
+            if (clientFilters && clientFilters.size > 0) {
+                if (!clientFilters.has(cdpEvent.method)) {
+                    continue;
+                }
+            }
+            try {
+                proxyConnection.clientWs.send(rawMessage);
+                proxyConnection.messageCount++;
+                forwardedCount++;
+            }
+            catch (error) {
+                this.logger.error(`Error forwarding event to proxy ${proxyId}:`, error);
+                this.closeProxyConnection(proxyId);
+            }
+        }
+        if (forwardedCount > 0) {
+            this.logger.debug(`Forwarded CDP event ${cdpEvent.method} to ${forwardedCount} clients for connection ${connectionId}`);
+        }
+    }
+    setClientEventFilters(proxyId, eventMethods) {
+        if (!this.connections.has(proxyId)) {
+            return false;
+        }
+        const filters = this.clientEventFilters.get(proxyId);
+        if (filters) {
+            filters.clear();
+            eventMethods.forEach(method => filters.add(method));
+            this.logger.debug(`Updated event filters for proxy ${proxyId}: ${eventMethods.join(', ')}`);
+            return true;
+        }
+        return false;
+    }
+    clearClientEventFilters(proxyId) {
+        if (!this.connections.has(proxyId)) {
+            return false;
+        }
+        const filters = this.clientEventFilters.get(proxyId);
+        if (filters) {
+            filters.clear();
+            this.logger.debug(`Cleared event filters for proxy ${proxyId} - will receive all events`);
+            return true;
+        }
+        return false;
+    }
+    getClientEventFilters(proxyId) {
+        const filters = this.clientEventFilters.get(proxyId);
+        return filters ? Array.from(filters) : [];
+    }
+    isValidCDPCommand(message) {
+        return (typeof message === 'object' &&
+            message !== null &&
+            typeof message.method === 'string' &&
+            (message.id === undefined || typeof message.id === 'number' || typeof message.id === 'string') &&
+            (message.params === undefined || typeof message.params === 'object'));
+    }
+    isCDPResponse(message) {
+        return (typeof message === 'object' &&
+            message !== null &&
+            (message.id !== undefined) &&
+            (message.result !== undefined || message.error !== undefined));
+    }
+    isCDPEvent(message) {
+        return (typeof message === 'object' &&
+            message !== null &&
+            typeof message.method === 'string' &&
+            message.id === undefined);
+    }
+    isProxyCommand(message) {
+        return (typeof message === 'object' &&
+            message !== null &&
+            typeof message.method === 'string' &&
+            message.method.startsWith('Proxy.'));
+    }
+    handleProxyCommand(proxyConnection, command) {
+        const { method, params, id } = command;
+        try {
+            switch (method) {
+                case 'Proxy.setEventFilters':
+                    {
+                        const eventMethods = params?.eventMethods || [];
+                        if (Array.isArray(eventMethods) && eventMethods.every(m => typeof m === 'string')) {
+                            this.setClientEventFilters(proxyConnection.id, eventMethods);
+                            proxyConnection.clientWs.send(JSON.stringify({
+                                id,
+                                result: { success: true, filters: eventMethods }
+                            }));
+                        }
+                        else {
+                            proxyConnection.clientWs.send(JSON.stringify({
+                                id,
+                                error: { code: -32602, message: 'Invalid eventMethods parameter' }
+                            }));
+                        }
+                    }
+                    break;
+                case 'Proxy.clearEventFilters':
+                    {
+                        this.clearClientEventFilters(proxyConnection.id);
+                        proxyConnection.clientWs.send(JSON.stringify({
+                            id,
+                            result: { success: true, filters: [] }
+                        }));
+                    }
+                    break;
+                case 'Proxy.getEventFilters':
+                    {
+                        const filters = this.getClientEventFilters(proxyConnection.id);
+                        proxyConnection.clientWs.send(JSON.stringify({
+                            id,
+                            result: { filters }
+                        }));
+                    }
+                    break;
+                case 'Proxy.getStatus':
+                    {
+                        const cdpConnection = this.connectionPool.getConnectionInfo(proxyConnection.connectionId);
+                        proxyConnection.clientWs.send(JSON.stringify({
+                            id,
+                            result: {
+                                proxyId: proxyConnection.id,
+                                connectionId: proxyConnection.connectionId,
+                                messageCount: proxyConnection.messageCount,
+                                createdAt: proxyConnection.createdAt,
+                                cdpConnectionHealthy: cdpConnection?.isHealthy || false,
+                                totalClients: cdpConnection?.clientCount || 0
+                            }
+                        }));
+                    }
+                    break;
+                default:
+                    proxyConnection.clientWs.send(JSON.stringify({
+                        id,
+                        error: { code: -32601, message: `Unknown proxy method: ${method}` }
+                    }));
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error handling proxy command ${method}:`, error);
+            proxyConnection.clientWs.send(JSON.stringify({
+                id,
+                error: { code: -32603, message: 'Internal error' }
+            }));
+        }
+    }
+    handleClientDisconnection(proxyId) {
+        const proxyConnection = this.connections.get(proxyId);
+        if (proxyConnection) {
+            this.logger.info(`Client disconnected from proxy ${proxyId}`);
+            this.closeProxyConnection(proxyId);
+        }
+    }
+    generateProxyId() {
+        return `proxy_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+}
+exports.WSProxy = WSProxy;

package/dist/proxy/types/ProxyTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });