chrome-cdp-cli 2.1.0 → 2.1.2

package/dist/proxy/server/MessageStore.js

@@ -1,291 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageStore = void 0;
-const logger_1 = require("../../utils/logger");
-class MessageStore {
-    constructor(maxConsoleMessages = 1000, maxNetworkRequests = 500) {
-        this.consoleMessages = new Map();
-        this.networkRequests = new Map();
-        this.maxConsoleMessages = maxConsoleMessages;
-        this.maxNetworkRequests = maxNetworkRequests;
-        this.logger = new logger_1.Logger();
-    }
-    addConsoleMessage(connectionId, message) {
-        if (!this.consoleMessages.has(connectionId)) {
-            this.consoleMessages.set(connectionId, []);
-        }
-        const messages = this.consoleMessages.get(connectionId);
-        messages.push(message);
-        if (messages.length > this.maxConsoleMessages) {
-            const removed = messages.splice(0, messages.length - this.maxConsoleMessages);
-            this.logger.debug(`Removed ${removed.length} old console messages for connection ${connectionId}`);
-        }
-        this.logger.debug(`Added console message (${message.type}) for connection ${connectionId}: ${message.text.substring(0, 100)}`);
-    }
-    getConsoleMessages(connectionId, filter) {
-        const messages = this.consoleMessages.get(connectionId) || [];
-        if (!filter) {
-            return [...messages];
-        }
-        let filteredMessages = [...messages];
-        if (filter.types && filter.types.length > 0) {
-            filteredMessages = filteredMessages.filter(msg => filter.types.includes(msg.type));
-        }
-        if (filter.textPattern) {
-            const pattern = new RegExp(filter.textPattern, 'i');
-            filteredMessages = filteredMessages.filter(msg => pattern.test(msg.text));
-        }
-        if (filter.source) {
-            filteredMessages = filteredMessages.filter(msg => msg.source === filter.source);
-        }
-        if (filter.startTime) {
-            filteredMessages = filteredMessages.filter(msg => msg.timestamp >= filter.startTime);
-        }
-        if (filter.endTime) {
-            filteredMessages = filteredMessages.filter(msg => msg.timestamp <= filter.endTime);
-        }
-        if (filter.maxMessages && filter.maxMessages > 0) {
-            filteredMessages = filteredMessages.slice(-filter.maxMessages);
-        }
-        return filteredMessages;
-    }
-    getLatestConsoleMessage(connectionId, filter) {
-        const messages = this.getConsoleMessages(connectionId, filter);
-        return messages.length > 0 ? messages[messages.length - 1] : null;
-    }
-    clearConsoleMessages(connectionId) {
-        this.consoleMessages.delete(connectionId);
-        this.logger.debug(`Cleared console messages for connection ${connectionId}`);
-    }
-    getConsoleMessageCount(connectionId, filter) {
-        return this.getConsoleMessages(connectionId, filter).length;
-    }
-    addNetworkRequest(connectionId, request) {
-        if (!this.networkRequests.has(connectionId)) {
-            this.networkRequests.set(connectionId, []);
-        }
-        const requests = this.networkRequests.get(connectionId);
-        requests.push(request);
-        if (requests.length > this.maxNetworkRequests) {
-            const removed = requests.splice(0, requests.length - this.maxNetworkRequests);
-            this.logger.debug(`Removed ${removed.length} old network requests for connection ${connectionId}`);
-        }
-        this.logger.debug(`Added network request for connection ${connectionId}: ${request.method} ${request.url}`);
-    }
-    updateNetworkRequest(connectionId, requestId, update) {
-        const requests = this.networkRequests.get(connectionId);
-        if (!requests) {
-            return;
-        }
-        const request = requests.find(r => r.requestId === requestId);
-        if (request) {
-            Object.assign(request, update);
-            this.logger.debug(`Updated network request ${requestId} for connection ${connectionId}`);
-        }
-    }
-    getNetworkRequests(connectionId, filter) {
-        const requests = this.networkRequests.get(connectionId) || [];
-        if (!filter) {
-            return [...requests];
-        }
-        let filteredRequests = [...requests];
-        if (filter.methods && filter.methods.length > 0) {
-            filteredRequests = filteredRequests.filter(req => filter.methods.includes(req.method.toUpperCase()));
-        }
-        if (filter.statusCodes && filter.statusCodes.length > 0) {
-            filteredRequests = filteredRequests.filter(req => req.status && filter.statusCodes.includes(req.status));
-        }
-        if (filter.urlPattern) {
-            const pattern = new RegExp(filter.urlPattern, 'i');
-            filteredRequests = filteredRequests.filter(req => pattern.test(req.url));
-        }
-        if (filter.startTime) {
-            filteredRequests = filteredRequests.filter(req => req.timestamp >= filter.startTime);
-        }
-        if (filter.endTime) {
-            filteredRequests = filteredRequests.filter(req => req.timestamp <= filter.endTime);
-        }
-        if (!filter.includeResponseBody) {
-            filteredRequests = filteredRequests.map(req => ({
-                ...req,
-                responseBody: undefined
-            }));
-        }
-        if (filter.maxRequests && filter.maxRequests > 0) {
-            filteredRequests = filteredRequests.slice(-filter.maxRequests);
-        }
-        return filteredRequests;
-    }
-    getLatestNetworkRequest(connectionId, filter) {
-        const requests = this.getNetworkRequests(connectionId, filter);
-        return requests.length > 0 ? requests[requests.length - 1] : null;
-    }
-    clearNetworkRequests(connectionId) {
-        this.networkRequests.delete(connectionId);
-        this.logger.debug(`Cleared network requests for connection ${connectionId}`);
-    }
-    getNetworkRequestCount(connectionId, filter) {
-        return this.getNetworkRequests(connectionId, filter).length;
-    }
-    cleanupConnection(connectionId) {
-        this.clearConsoleMessages(connectionId);
-        this.clearNetworkRequests(connectionId);
-        this.logger.info(`Cleaned up all data for connection ${connectionId}`);
-    }
-    clearAll() {
-        this.consoleMessages.clear();
-        this.networkRequests.clear();
-        this.logger.info('Cleared all stored messages and requests');
-    }
-    enforceMemoryLimits() {
-        let totalConsoleMessages = 0;
-        let totalNetworkRequests = 0;
-        for (const messages of this.consoleMessages.values()) {
-            totalConsoleMessages += messages.length;
-        }
-        for (const requests of this.networkRequests.values()) {
-            totalNetworkRequests += requests.length;
-        }
-        this.logger.debug(`Memory usage: ${totalConsoleMessages} console messages, ${totalNetworkRequests} network requests`);
-        if (totalConsoleMessages > this.maxConsoleMessages * 2) {
-            this.cleanupOldestConsoleMessages();
-        }
-        if (totalNetworkRequests > this.maxNetworkRequests * 2) {
-            this.cleanupOldestNetworkRequests();
-        }
-    }
-    getStorageStats() {
-        const stats = {
-            connections: 0,
-            totalConsoleMessages: 0,
-            totalNetworkRequests: 0,
-            consoleMessagesByConnection: {},
-            networkRequestsByConnection: {}
-        };
-        const connectionIds = new Set([
-            ...this.consoleMessages.keys(),
-            ...this.networkRequests.keys()
-        ]);
-        stats.connections = connectionIds.size;
-        for (const connectionId of connectionIds) {
-            const consoleCount = this.consoleMessages.get(connectionId)?.length || 0;
-            const networkCount = this.networkRequests.get(connectionId)?.length || 0;
-            stats.consoleMessagesByConnection[connectionId] = consoleCount;
-            stats.networkRequestsByConnection[connectionId] = networkCount;
-            stats.totalConsoleMessages += consoleCount;
-            stats.totalNetworkRequests += networkCount;
-        }
-        return stats;
-    }
-    processConsoleAPIEvent(connectionId, params) {
-        try {
-            const message = {
-                connectionId,
-                type: this.mapConsoleType(params.type),
-                text: this.formatConsoleArgs(params.args || []),
-                args: (params.args || []).map((arg) => arg.value || arg.description || ''),
-                timestamp: params.timestamp || Date.now(),
-                stackTrace: params.stackTrace ? this.convertStackTrace(params.stackTrace.callFrames) : undefined,
-                source: 'Runtime.consoleAPICalled'
-            };
-            this.addConsoleMessage(connectionId, message);
-        }
-        catch (error) {
-            this.logger.error('Error processing console API event:', error);
-        }
-    }
-    processLogEntryEvent(connectionId, params) {
-        try {
-            const entry = params.entry;
-            const message = {
-                connectionId,
-                type: this.mapLogLevel(entry.level),
-                text: entry.text || '',
-                args: [entry.text || ''],
-                timestamp: entry.timestamp || Date.now(),
-                stackTrace: entry.url && entry.lineNumber ? [{
-                        functionName: '<unknown>',
-                        url: entry.url,
-                        lineNumber: entry.lineNumber,
-                        columnNumber: 0
-                    }] : undefined,
-                source: 'Log.entryAdded'
-            };
-            this.addConsoleMessage(connectionId, message);
-        }
-        catch (error) {
-            this.logger.error('Error processing log entry event:', error);
-        }
-    }
-    mapConsoleType(cdpType) {
-        switch (cdpType) {
-            case 'log': return 'log';
-            case 'info': return 'info';
-            case 'warning': return 'warn';
-            case 'error': return 'error';
-            case 'debug': return 'debug';
-            default: return 'log';
-        }
-    }
-    mapLogLevel(logLevel) {
-        switch (logLevel.toLowerCase()) {
-            case 'verbose':
-            case 'info': return 'info';
-            case 'warning': return 'warn';
-            case 'error': return 'error';
-            default: return 'log';
-        }
-    }
-    formatConsoleArgs(args) {
-        return args.map(arg => {
-            if (arg.value !== undefined) {
-                if (typeof arg.value === 'string') {
-                    return arg.value;
-                }
-                return JSON.stringify(arg.value);
-            }
-            return arg.description || '';
-        }).join(' ');
-    }
-    convertStackTrace(callFrames) {
-        return callFrames.map(frame => ({
-            functionName: frame.functionName || '<anonymous>',
-            url: frame.url,
-            lineNumber: frame.lineNumber,
-            columnNumber: frame.columnNumber
-        }));
-    }
-    cleanupOldestConsoleMessages() {
-        let maxMessages = 0;
-        let connectionToCleanup = '';
-        for (const [connectionId, messages] of this.consoleMessages) {
-            if (messages.length > maxMessages) {
-                maxMessages = messages.length;
-                connectionToCleanup = connectionId;
-            }
-        }
-        if (connectionToCleanup) {
-            const messages = this.consoleMessages.get(connectionToCleanup);
-            const toRemove = Math.floor(messages.length * 0.2);
-            messages.splice(0, toRemove);
-            this.logger.info(`Cleaned up ${toRemove} old console messages from connection ${connectionToCleanup}`);
-        }
-    }
-    cleanupOldestNetworkRequests() {
-        let maxRequests = 0;
-        let connectionToCleanup = '';
-        for (const [connectionId, requests] of this.networkRequests) {
-            if (requests.length > maxRequests) {
-                maxRequests = requests.length;
-                connectionToCleanup = connectionId;
-            }
-        }
-        if (connectionToCleanup) {
-            const requests = this.networkRequests.get(connectionToCleanup);
-            const toRemove = Math.floor(requests.length * 0.2);
-            requests.splice(0, toRemove);
-            this.logger.info(`Cleaned up ${toRemove} old network requests from connection ${connectionToCleanup}`);
-        }
-    }
-}
-exports.MessageStore = MessageStore;

package/dist/proxy/server/PerformanceMonitor.js

@@ -1,277 +0,0 @@
-"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.PerformanceMonitor = void 0;
-const logger_1 = require("../../utils/logger");
-const os = __importStar(require("os"));
-class PerformanceMonitor {
-    constructor(connectionPool, messageStore, thresholds) {
-        this.metricsHistory = [];
-        this.maxHistorySize = 100;
-        this.lastAlertTimes = new Map();
-        this.alertCooldownMs = 300000;
-        this.logger = (0, logger_1.createLogger)({ component: 'PerformanceMonitor' });
-        this.connectionPool = connectionPool;
-        this.messageStore = messageStore;
-        this.startTime = Date.now();
-        this.thresholds = {
-            memoryUtilizationWarning: 80,
-            memoryUtilizationCritical: 95,
-            heapUtilizationWarning: 80,
-            heapUtilizationCritical: 95,
-            connectionCountWarning: 50,
-            connectionCountCritical: 100,
-            messageCountWarning: 10000,
-            messageCountCritical: 50000,
-            ...thresholds
-        };
-    }
-    start(intervalMs = 60000) {
-        if (this.monitoringInterval) {
-            this.logger.warn('Performance monitoring is already running');
-            return;
-        }
-        this.logger.info('Starting performance monitoring', {
-            intervalMs,
-            thresholds: this.thresholds
-        });
-        this.collectMetrics();
-        this.monitoringInterval = setInterval(() => {
-            this.collectMetrics();
-        }, intervalMs);
-    }
-    stop() {
-        if (this.monitoringInterval) {
-            clearInterval(this.monitoringInterval);
-            this.monitoringInterval = undefined;
-            this.logger.info('Performance monitoring stopped');
-        }
-    }
-    collectMetrics() {
-        const now = Date.now();
-        const memoryUsage = process.memoryUsage();
-        const connections = this.connectionPool.getAllConnections();
-        const storageStats = this.messageStore.getStorageStats();
-        const loadAvg = os.loadavg();
-        const freeMemory = os.freemem();
-        const totalMemory = os.totalmem();
-        const memoryUtilization = ((totalMemory - freeMemory) / totalMemory) * 100;
-        const heapUtilization = (memoryUsage.heapUsed / memoryUsage.heapTotal) * 100;
-        const healthyConnections = connections.filter(c => c.isHealthy).length;
-        const totalClientConnections = connections.reduce((sum, c) => sum + c.clientCount, 0);
-        const averageClientCount = connections.length > 0 ? totalClientConnections / connections.length : 0;
-        const averageMessagesPerConnection = connections.length > 0
-            ? storageStats.totalConsoleMessages / connections.length
-            : 0;
-        const averageRequestsPerConnection = connections.length > 0
-            ? storageStats.totalNetworkRequests / connections.length
-            : 0;
-        const metrics = {
-            timestamp: now,
-            uptime: now - this.startTime,
-            memory: {
-                heapUsed: memoryUsage.heapUsed,
-                heapTotal: memoryUsage.heapTotal,
-                external: memoryUsage.external,
-                rss: memoryUsage.rss,
-                heapUtilization
-            },
-            system: {
-                loadAverage: loadAvg,
-                freeMemory,
-                totalMemory,
-                memoryUtilization,
-                cpuCount: os.cpus().length
-            },
-            connections: {
-                total: connections.length,
-                healthy: healthyConnections,
-                unhealthy: connections.length - healthyConnections,
-                averageClientCount,
-                totalClientConnections
-            },
-            messages: {
-                totalConsoleMessages: storageStats.totalConsoleMessages,
-                totalNetworkRequests: storageStats.totalNetworkRequests,
-                averageMessagesPerConnection,
-                averageRequestsPerConnection
-            },
-            performance: {}
-        };
-        this.metricsHistory.push(metrics);
-        if (this.metricsHistory.length > this.maxHistorySize) {
-            this.metricsHistory.shift();
-        }
-        this.logger.logPerformanceMetrics('PerformanceMonitor', {
-            uptime: metrics.uptime,
-            memoryUtilization: metrics.system.memoryUtilization,
-            heapUtilization: metrics.memory.heapUtilization,
-            connectionCount: metrics.connections.total,
-            messageCount: metrics.messages.totalConsoleMessages,
-            requestCount: metrics.messages.totalNetworkRequests,
-            loadAverage: metrics.system.loadAverage[0]
-        });
-        this.checkThresholds(metrics);
-        return metrics;
-    }
-    checkThresholds(metrics) {
-        if (metrics.system.memoryUtilization >= this.thresholds.memoryUtilizationCritical) {
-            this.sendAlert('memory-critical', 'Critical system memory utilization', {
-                utilization: metrics.system.memoryUtilization,
-                threshold: this.thresholds.memoryUtilizationCritical,
-                freeMemory: metrics.system.freeMemory,
-                totalMemory: metrics.system.totalMemory
-            });
-        }
-        else if (metrics.system.memoryUtilization >= this.thresholds.memoryUtilizationWarning) {
-            this.sendAlert('memory-warning', 'High system memory utilization', {
-                utilization: metrics.system.memoryUtilization,
-                threshold: this.thresholds.memoryUtilizationWarning,
-                freeMemory: metrics.system.freeMemory,
-                totalMemory: metrics.system.totalMemory
-            });
-        }
-        if (metrics.memory.heapUtilization >= this.thresholds.heapUtilizationCritical) {
-            this.sendAlert('heap-critical', 'Critical heap memory utilization', {
-                utilization: metrics.memory.heapUtilization,
-                threshold: this.thresholds.heapUtilizationCritical,
-                heapUsed: metrics.memory.heapUsed,
-                heapTotal: metrics.memory.heapTotal
-            });
-        }
-        else if (metrics.memory.heapUtilization >= this.thresholds.heapUtilizationWarning) {
-            this.sendAlert('heap-warning', 'High heap memory utilization', {
-                utilization: metrics.memory.heapUtilization,
-                threshold: this.thresholds.heapUtilizationWarning,
-                heapUsed: metrics.memory.heapUsed,
-                heapTotal: metrics.memory.heapTotal
-            });
-        }
-        if (metrics.connections.total >= this.thresholds.connectionCountCritical) {
-            this.sendAlert('connections-critical', 'Critical number of connections', {
-                connectionCount: metrics.connections.total,
-                threshold: this.thresholds.connectionCountCritical,
-                healthyConnections: metrics.connections.healthy,
-                totalClientConnections: metrics.connections.totalClientConnections
-            });
-        }
-        else if (metrics.connections.total >= this.thresholds.connectionCountWarning) {
-            this.sendAlert('connections-warning', 'High number of connections', {
-                connectionCount: metrics.connections.total,
-                threshold: this.thresholds.connectionCountWarning,
-                healthyConnections: metrics.connections.healthy,
-                totalClientConnections: metrics.connections.totalClientConnections
-            });
-        }
-        const totalMessages = metrics.messages.totalConsoleMessages + metrics.messages.totalNetworkRequests;
-        if (totalMessages >= this.thresholds.messageCountCritical) {
-            this.sendAlert('messages-critical', 'Critical number of stored messages', {
-                totalMessages,
-                threshold: this.thresholds.messageCountCritical,
-                consoleMessages: metrics.messages.totalConsoleMessages,
-                networkRequests: metrics.messages.totalNetworkRequests
-            });
-        }
-        else if (totalMessages >= this.thresholds.messageCountWarning) {
-            this.sendAlert('messages-warning', 'High number of stored messages', {
-                totalMessages,
-                threshold: this.thresholds.messageCountWarning,
-                consoleMessages: metrics.messages.totalConsoleMessages,
-                networkRequests: metrics.messages.totalNetworkRequests
-            });
-        }
-    }
-    sendAlert(alertType, message, data) {
-        const now = Date.now();
-        const lastAlert = this.lastAlertTimes.get(alertType);
-        if (!lastAlert || (now - lastAlert) >= this.alertCooldownMs) {
-            this.logger.warn(`[PERFORMANCE ALERT] ${message}`, data);
-            this.lastAlertTimes.set(alertType, now);
-        }
-    }
-    getCurrentMetrics() {
-        return this.metricsHistory.length > 0
-            ? this.metricsHistory[this.metricsHistory.length - 1]
-            : null;
-    }
-    getMetricsHistory(count) {
-        if (count && count < this.metricsHistory.length) {
-            return this.metricsHistory.slice(-count);
-        }
-        return [...this.metricsHistory];
-    }
-    getPerformanceSummary(periodMs = 3600000) {
-        const now = Date.now();
-        const cutoff = now - periodMs;
-        const recentMetrics = this.metricsHistory.filter(m => m.timestamp >= cutoff);
-        if (recentMetrics.length === 0) {
-            return {
-                averageMemoryUtilization: 0,
-                averageHeapUtilization: 0,
-                averageConnectionCount: 0,
-                averageMessageCount: 0,
-                peakMemoryUtilization: 0,
-                peakConnectionCount: 0,
-                alertCount: 0
-            };
-        }
-        const avgMemoryUtilization = recentMetrics.reduce((sum, m) => sum + m.system.memoryUtilization, 0) / recentMetrics.length;
-        const avgHeapUtilization = recentMetrics.reduce((sum, m) => sum + m.memory.heapUtilization, 0) / recentMetrics.length;
-        const avgConnectionCount = recentMetrics.reduce((sum, m) => sum + m.connections.total, 0) / recentMetrics.length;
-        const avgMessageCount = recentMetrics.reduce((sum, m) => sum + m.messages.totalConsoleMessages + m.messages.totalNetworkRequests, 0) / recentMetrics.length;
-        const peakMemoryUtilization = Math.max(...recentMetrics.map(m => m.system.memoryUtilization));
-        const peakConnectionCount = Math.max(...recentMetrics.map(m => m.connections.total));
-        const alertCount = Math.floor(periodMs / this.alertCooldownMs) * this.lastAlertTimes.size;
-        return {
-            averageMemoryUtilization: avgMemoryUtilization,
-            averageHeapUtilization: avgHeapUtilization,
-            averageConnectionCount: avgConnectionCount,
-            averageMessageCount: avgMessageCount,
-            peakMemoryUtilization,
-            peakConnectionCount,
-            alertCount
-        };
-    }
-    updateThresholds(newThresholds) {
-        this.thresholds = { ...this.thresholds, ...newThresholds };
-        this.logger.info('Performance thresholds updated', { thresholds: this.thresholds });
-    }
-    clearHistory() {
-        this.metricsHistory = [];
-        this.lastAlertTimes.clear();
-        this.logger.info('Performance metrics history cleared');
-    }
-}
-exports.PerformanceMonitor = PerformanceMonitor;