chrome-cdp-cli 1.5.0 → 1.6.0

package/dist/proxy/server/CDPProxyServer.js

@@ -0,0 +1,436 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CDPProxyServer = void 0;
+const express_1 = __importDefault(require("express"));
+const http_1 = __importDefault(require("http"));
+const ws_1 = require("ws");
+const ConnectionPool_1 = require("./ConnectionPool");
+const MessageStore_1 = require("./MessageStore");
+const HealthMonitor_1 = require("./HealthMonitor");
+const ProxyAPIServer_1 = require("./ProxyAPIServer");
+const WSProxy_1 = require("./WSProxy");
+const CDPEventMonitor_1 = require("./CDPEventMonitor");
+const PerformanceMonitor_1 = require("./PerformanceMonitor");
+const SecurityManager_1 = require("./SecurityManager");
+const FileSystemSecurity_1 = require("./FileSystemSecurity");
+const logger_1 = require("../../utils/logger");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+class CDPProxyServer {
+    constructor() {
+        this.isRunning = false;
+        this.startTime = 0;
+        this.fileSystemSecurity = new FileSystemSecurity_1.FileSystemSecurity();
+        const logDir = path.join(os.homedir(), '.chrome-cdp-cli', 'logs');
+        const logFile = path.join(logDir, 'proxy-server.log');
+        this.logger = (0, logger_1.createLogger)({
+            component: 'ProxyServer',
+            file: logFile,
+            enableStructured: true,
+            maxFileSize: 10 * 1024 * 1024,
+            maxFiles: 5
+        });
+        this.checkLogFileSecurity(logFile);
+        this.app = (0, express_1.default)();
+        this.httpServer = http_1.default.createServer(this.app);
+        this.config = this.getDefaultConfig();
+        this.messageStore = new MessageStore_1.MessageStore(this.config.maxConsoleMessages, this.config.maxNetworkRequests);
+        this.eventMonitor = new CDPEventMonitor_1.CDPEventMonitor(this.messageStore);
+        this.connectionPool = new ConnectionPool_1.ConnectionPool(this.eventMonitor, this.messageStore);
+        this.healthMonitor = new HealthMonitor_1.HealthMonitor(this.connectionPool);
+        this.performanceMonitor = new PerformanceMonitor_1.PerformanceMonitor(this.connectionPool, this.messageStore);
+        this.securityManager = new SecurityManager_1.SecurityManager();
+        this.apiServer = new ProxyAPIServer_1.ProxyAPIServer(this.connectionPool, this.messageStore, this.healthMonitor, this.performanceMonitor);
+        this.wsProxy = new WSProxy_1.WSProxy(this.connectionPool);
+    }
+    async start(configOverride) {
+        if (this.isRunning) {
+            this.logger.warn('Proxy server is already running');
+            return;
+        }
+        try {
+            this.startTime = Date.now();
+            const fileConfig = await this.loadConfigurationSecurely();
+            this.logger.logServerEvent('startup', 'Starting proxy server', {
+                config: this.config,
+                fileConfig,
+                configOverride,
+                nodeVersion: process.version,
+                platform: process.platform,
+                arch: process.arch,
+                pid: process.pid
+            });
+            this.config = { ...this.config, ...fileConfig, ...configOverride };
+            this.messageStore = new MessageStore_1.MessageStore(this.config.maxConsoleMessages, this.config.maxNetworkRequests);
+            this.eventMonitor = new CDPEventMonitor_1.CDPEventMonitor(this.messageStore);
+            this.connectionPool = new ConnectionPool_1.ConnectionPool(this.eventMonitor, this.messageStore, this.config);
+            this.healthMonitor = new HealthMonitor_1.HealthMonitor(this.connectionPool);
+            this.performanceMonitor = new PerformanceMonitor_1.PerformanceMonitor(this.connectionPool, this.messageStore);
+            this.securityManager = new SecurityManager_1.SecurityManager({
+                allowedHosts: ['localhost', '127.0.0.1', '192.168.*', '10.*', '172.*']
+            });
+            this.apiServer = new ProxyAPIServer_1.ProxyAPIServer(this.connectionPool, this.messageStore, this.healthMonitor, this.performanceMonitor, this.securityManager);
+            this.setupMiddleware();
+            this.apiServer.setupRoutes(this.app);
+            this.wsServer = new ws_1.WebSocketServer({ server: this.httpServer });
+            this.wsProxy.start(this.wsServer);
+            this.healthMonitor.start(this.config.healthCheckInterval);
+            this.performanceMonitor.start(60000);
+            this.startMemoryCleanup();
+            await this.startHttpServer();
+            this.resetAutoShutdownTimer();
+            this.isRunning = true;
+            const startupTime = Date.now() - this.startTime;
+            this.logger.logServerEvent('startup', `Proxy server started successfully on ${this.config.host}:${this.config.port}`, {
+                startupTimeMs: startupTime,
+                bindAddress: `${this.config.host}:${this.config.port}`,
+                autoShutdownTimeout: this.config.autoShutdownTimeout,
+                maxConnections: this.config.maxConsoleMessages,
+                securityEnabled: true,
+                fileSystemSecurityEnabled: true
+            });
+        }
+        catch (error) {
+            this.logger.logServerEvent('error', 'Failed to start proxy server', {
+                startupTimeMs: Date.now() - this.startTime,
+                configAttempted: this.config
+            }, error);
+            await this.cleanup();
+            throw error;
+        }
+    }
+    async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        const shutdownStartTime = Date.now();
+        this.logger.logServerEvent('shutdown', 'Stopping proxy server', {
+            uptime: Date.now() - this.startTime,
+            activeConnections: this.connectionPool.getAllConnections().length
+        });
+        try {
+            if (this.autoShutdownTimer) {
+                clearTimeout(this.autoShutdownTimer);
+                this.autoShutdownTimer = undefined;
+            }
+            if (this.memoryCleanupTimer) {
+                clearInterval(this.memoryCleanupTimer);
+                this.memoryCleanupTimer = undefined;
+            }
+            this.healthMonitor.stop();
+            this.performanceMonitor.stop();
+            await this.eventMonitor.stopAllMonitoring();
+            this.wsProxy.stop();
+            if (this.wsServer) {
+                this.wsServer.close();
+            }
+            await this.stopHttpServer();
+            await this.cleanup();
+            this.isRunning = false;
+            const shutdownTime = Date.now() - shutdownStartTime;
+            this.logger.logServerEvent('shutdown', 'Proxy server stopped successfully', {
+                shutdownTimeMs: shutdownTime,
+                totalUptime: Date.now() - this.startTime
+            });
+            this.logger.close();
+        }
+        catch (error) {
+            this.logger.logServerEvent('error', 'Error during proxy server shutdown', {
+                shutdownTimeMs: Date.now() - shutdownStartTime
+            }, error);
+            throw error;
+        }
+    }
+    isServerRunning() {
+        return this.isRunning;
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    getStatus() {
+        const memoryStats = this.messageStore.getStorageStats();
+        return {
+            isRunning: this.isRunning,
+            config: this.config,
+            connections: this.connectionPool.getAllConnections().length,
+            uptime: this.isRunning ? Date.now() - (this.connectionPool.getAllConnections()[0]?.createdAt || Date.now()) : 0,
+            memory: {
+                totalConsoleMessages: memoryStats.totalConsoleMessages,
+                totalNetworkRequests: memoryStats.totalNetworkRequests,
+                connectionsWithData: memoryStats.connections,
+                maxConsoleMessages: this.config.maxConsoleMessages,
+                maxNetworkRequests: this.config.maxNetworkRequests
+            },
+            security: {
+                securityManagerEnabled: true,
+                fileSystemSecurityEnabled: true,
+                allowedDirectories: this.fileSystemSecurity.getConfig().allowedDirectories.length
+            }
+        };
+    }
+    getFileSystemSecurity() {
+        return this.fileSystemSecurity;
+    }
+    getSecurityManager() {
+        return this.securityManager;
+    }
+    resetAutoShutdownTimer() {
+        if (this.autoShutdownTimer) {
+            clearTimeout(this.autoShutdownTimer);
+        }
+        if (this.config.autoShutdownTimeout > 0) {
+            this.autoShutdownTimer = setTimeout(async () => {
+                this.logger.logServerEvent('shutdown', 'Auto-shutdown timeout reached, stopping proxy server', {
+                    timeoutMs: this.config.autoShutdownTimeout,
+                    uptime: Date.now() - this.startTime,
+                    activeConnections: this.connectionPool.getAllConnections().length
+                });
+                await this.stop();
+            }, this.config.autoShutdownTimeout);
+        }
+    }
+    startMemoryCleanup() {
+        this.memoryCleanupTimer = setInterval(() => {
+            try {
+                const beforeStats = this.messageStore.getStorageStats();
+                const beforeMemory = process.memoryUsage();
+                this.messageStore.enforceMemoryLimits();
+                this.connectionPool.cleanupUnusedConnections(this.config.autoShutdownTimeout);
+                const afterStats = this.messageStore.getStorageStats();
+                const afterMemory = process.memoryUsage();
+                this.logger.logMemoryEvent('cleanup', 'Periodic memory cleanup completed', {
+                    memoryUsage: afterMemory,
+                    connectionCount: this.connectionPool.getAllConnections().length,
+                    messageCount: afterStats.totalConsoleMessages,
+                    requestCount: afterStats.totalNetworkRequests
+                });
+                const messagesCleanedUp = beforeStats.totalConsoleMessages - afterStats.totalConsoleMessages;
+                const requestsCleanedUp = beforeStats.totalNetworkRequests - afterStats.totalNetworkRequests;
+                if (messagesCleanedUp > 0 || requestsCleanedUp > 0) {
+                    this.logger.logMemoryEvent('cleanup', 'Memory cleanup removed old data', {
+                        messagesRemoved: messagesCleanedUp,
+                        requestsRemoved: requestsCleanedUp,
+                        memoryFreed: beforeMemory.heapUsed - afterMemory.heapUsed
+                    });
+                }
+            }
+            catch (error) {
+                this.logger.logServerEvent('error', 'Error during periodic memory cleanup', {
+                    cleanupInterval: 60000
+                }, error);
+            }
+        }, 60000);
+        this.logger.info('Started periodic memory cleanup', { intervalMs: 60000 });
+    }
+    setupMiddleware() {
+        this.app.use(this.securityManager.getSecurityHeadersMiddleware());
+        this.app.use(this.securityManager.getSecurityLoggingMiddleware());
+        this.app.use(express_1.default.json({
+            limit: this.securityManager.getConfig().maxRequestBodySize,
+            strict: true,
+            type: 'application/json'
+        }));
+        this.app.use(this.securityManager.getRequestValidationMiddleware());
+        this.app.use(this.securityManager.getInputSanitizationMiddleware());
+        this.app.use(this.securityManager.getHostValidationMiddleware());
+        this.app.use((req, res, next) => {
+            const origin = req.get('origin');
+            if (!origin || origin.includes('localhost') || origin.includes('127.0.0.1')) {
+                res.header('Access-Control-Allow-Origin', origin || 'http://localhost:*');
+            }
+            res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+            res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+            res.header('Access-Control-Max-Age', '86400');
+            if (req.method === 'OPTIONS') {
+                res.sendStatus(200);
+            }
+            else {
+                next();
+            }
+        });
+        this.app.use((req, res, next) => {
+            const startTime = Date.now();
+            this.logger.debug(`API Request: ${req.method} ${req.path}`, {
+                method: req.method,
+                path: req.path,
+                clientIP: req.ip,
+                userAgent: req.get('user-agent')
+            });
+            res.on('finish', () => {
+                const duration = Date.now() - startTime;
+                this.logger.logAPIEvent(req.method, req.path, res.statusCode, duration, req.ip);
+            });
+            this.resetAutoShutdownTimer();
+            next();
+        });
+        this.app.use((error, req, res, _next) => {
+            this.logger.logAPIEvent(req.method, req.path, 500, 0, req.ip, error);
+            this.logger.logSecurityEvent('api_error', 'API error occurred', {
+                method: req.method,
+                path: req.path,
+                ip: req.ip,
+                userAgent: req.get('user-agent'),
+                error: error.message
+            });
+            res.status(500).json({
+                success: false,
+                error: 'Internal server error',
+                timestamp: Date.now()
+            });
+        });
+    }
+    async startHttpServer() {
+        return new Promise((resolve, reject) => {
+            this.httpServer.listen(this.config.port, this.config.host, () => {
+                resolve();
+            });
+            this.httpServer.on('error', (error) => {
+                if (error.code === 'EADDRINUSE') {
+                    reject(new Error(`Port ${this.config.port} is already in use`));
+                }
+                else {
+                    reject(error);
+                }
+            });
+        });
+    }
+    async stopHttpServer() {
+        return new Promise((resolve) => {
+            if (this.httpServer) {
+                this.httpServer.close(() => {
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    async cleanup() {
+        try {
+            const connections = this.connectionPool.getAllConnections();
+            for (const connection of connections) {
+                await this.connectionPool.closeConnection(connection.id);
+            }
+            this.connectionPool.cleanup();
+            this.messageStore.clearAll();
+        }
+        catch (error) {
+            this.logger.error('Error during cleanup:', error);
+        }
+    }
+    getDefaultConfig() {
+        return {
+            port: 9223,
+            host: 'localhost',
+            maxConsoleMessages: 1000,
+            maxNetworkRequests: 500,
+            autoShutdownTimeout: 300000,
+            reconnectMaxAttempts: 5,
+            reconnectBackoffMs: 1000,
+            healthCheckInterval: 30000
+        };
+    }
+    async checkLogFileSecurity(logFile) {
+        try {
+            const securityCheck = await this.fileSystemSecurity.checkConfigurationSecurity(logFile);
+            if (!securityCheck.isSecure) {
+                this.logger.warn('Log file security issues detected', {
+                    issues: securityCheck.issues,
+                    recommendations: securityCheck.recommendations
+                });
+                try {
+                    await this.fileSystemSecurity.fixConfigurationPermissions(logFile);
+                    this.logger.info('Log file permissions fixed');
+                }
+                catch (error) {
+                    this.logger.warn('Failed to fix log file permissions', { error });
+                }
+            }
+        }
+        catch (error) {
+            this.logger.warn('Log file security check failed', { error });
+        }
+    }
+    async loadConfigurationSecurely(configPath) {
+        if (!configPath) {
+            const defaultConfigPath = path.join(os.homedir(), '.chrome-cdp-cli', 'proxy.json');
+            configPath = defaultConfigPath;
+        }
+        try {
+            const securityCheck = await this.fileSystemSecurity.checkConfigurationSecurity(configPath);
+            if (!securityCheck.isSecure) {
+                this.logger.warn('Configuration file security issues detected', {
+                    configPath: configPath.replace(os.homedir(), '~'),
+                    issues: securityCheck.issues,
+                    recommendations: securityCheck.recommendations
+                });
+                try {
+                    await this.fileSystemSecurity.fixConfigurationPermissions(configPath);
+                }
+                catch (error) {
+                    this.logger.warn('Failed to fix configuration file permissions', { error });
+                }
+            }
+            const configContent = await this.fileSystemSecurity.readFileSecurely(configPath);
+            const config = JSON.parse(configContent);
+            this.logger.info('Configuration loaded securely', {
+                configPath: configPath.replace(os.homedir(), '~'),
+                hasCustomConfig: true
+            });
+            return config;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                this.logger.info('No configuration file found, using defaults', {
+                    configPath: configPath.replace(os.homedir(), '~')
+                });
+                return {};
+            }
+            else {
+                this.logger.warn('Failed to load configuration file', {
+                    configPath: configPath.replace(os.homedir(), '~'),
+                    error: error.message
+                });
+                return {};
+            }
+        }
+    }
+}
+exports.CDPProxyServer = CDPProxyServer;