chrome-cdp-cli 1.5.0 → 1.6.0

package/dist/utils/logger.js

@@ -1,6 +1,41 @@
 "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.logger = exports.Logger = exports.LogLevel = void 0;
+exports.createLogger = exports.logger = exports.Logger = exports.LogLevel = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
@@ -9,36 +44,239 @@ var LogLevel;
     LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
 })(LogLevel || (exports.LogLevel = LogLevel = {}));
 class Logger {
-    constructor(level = LogLevel.INFO, quiet = false) {
-        this.level = level;
-        this.quiet = quiet;
+    constructor(config = {}) {
+        this.currentFileSize = 0;
+        this.config = {
+            level: LogLevel.INFO,
+            quiet: false,
+            maxFileSize: 10 * 1024 * 1024,
+            maxFiles: 5,
+            enableConsole: true,
+            enableStructured: true,
+            ...config
+        };
+        if (this.config.file) {
+            this.initializeLogFile();
+        }
+    }
+    initializeLogFile() {
+        if (!this.config.file)
+            return;
+        try {
+            const logDir = path.dirname(this.config.file);
+            if (!fs.existsSync(logDir)) {
+                fs.mkdirSync(logDir, { recursive: true });
+            }
+            if (fs.existsSync(this.config.file)) {
+                const stats = fs.statSync(this.config.file);
+                this.currentFileSize = stats.size;
+                if (this.currentFileSize >= (this.config.maxFileSize || 10 * 1024 * 1024)) {
+                    this.rotateLogFile();
+                }
+            }
+            this.logFileHandle = fs.createWriteStream(this.config.file, { flags: 'a' });
+            this.logFileHandle.on('error', (error) => {
+                console.error('Log file write error:', error);
+            });
+        }
+        catch (error) {
+            console.error('Failed to initialize log file:', error);
+        }
+    }
+    rotateLogFile() {
+        if (!this.config.file || !this.logFileHandle)
+            return;
+        try {
+            this.logFileHandle.end();
+            for (let i = (this.config.maxFiles || 5) - 1; i > 0; i--) {
+                const oldFile = `${this.config.file}.${i}`;
+                const newFile = `${this.config.file}.${i + 1}`;
+                if (fs.existsSync(oldFile)) {
+                    if (i === (this.config.maxFiles || 5) - 1) {
+                        fs.unlinkSync(oldFile);
+                    }
+                    else {
+                        fs.renameSync(oldFile, newFile);
+                    }
+                }
+            }
+            if (fs.existsSync(this.config.file)) {
+                fs.renameSync(this.config.file, `${this.config.file}.1`);
+            }
+            this.currentFileSize = 0;
+            this.logFileHandle = fs.createWriteStream(this.config.file, { flags: 'a' });
+            this.logFileHandle.on('error', (error) => {
+                console.error('Log file write error:', error);
+            });
+        }
+        catch (error) {
+            console.error('Failed to rotate log file:', error);
+        }
+    }
+    formatLogEntry(entry) {
+        if (this.config.enableStructured) {
+            return JSON.stringify(entry) + '\n';
+        }
+        else {
+            const timestamp = entry.timestamp;
+            const level = entry.level.padEnd(5);
+            const component = entry.component ? `[${entry.component}]` : '';
+            const connectionId = entry.connectionId ? `{conn:${entry.connectionId}}` : '';
+            const clientId = entry.clientId ? `{client:${entry.clientId}}` : '';
+            let message = `${timestamp} ${level} ${component}${connectionId}${clientId} ${entry.message}`;
+            if (entry.data) {
+                message += ` | Data: ${JSON.stringify(entry.data)}`;
+            }
+            if (entry.error) {
+                message += ` | Error: ${entry.error.message}`;
+                if (entry.error.stack) {
+                    message += `\nStack: ${entry.error.stack}`;
+                }
+            }
+            if (entry.metrics) {
+                message += ` | Metrics: ${JSON.stringify(entry.metrics)}`;
+            }
+            return message + '\n';
+        }
+    }
+    writeLog(entry) {
+        const formattedEntry = this.formatLogEntry(entry);
+        if (this.config.enableConsole && !this.config.quiet) {
+            const consoleMessage = this.config.enableStructured
+                ? formattedEntry.trim()
+                : formattedEntry.trim();
+            switch (entry.level) {
+                case 'ERROR':
+                    console.error(consoleMessage);
+                    break;
+                case 'WARN':
+                    console.warn(consoleMessage);
+                    break;
+                case 'INFO':
+                    console.info(consoleMessage);
+                    break;
+                case 'DEBUG':
+                    console.debug(consoleMessage);
+                    break;
+            }
+        }
+        if (this.logFileHandle) {
+            const entrySize = Buffer.byteLength(formattedEntry, 'utf8');
+            if (this.currentFileSize + entrySize >= (this.config.maxFileSize || 10 * 1024 * 1024)) {
+                this.rotateLogFile();
+            }
+            this.logFileHandle.write(formattedEntry);
+            this.currentFileSize += entrySize;
+        }
+    }
+    createLogEntry(level, message, data, error, context) {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            message,
+            component: context?.component || this.config.component
+        };
+        if (context?.connectionId)
+            entry.connectionId = context.connectionId;
+        if (context?.clientId)
+            entry.clientId = context.clientId;
+        if (data !== undefined)
+            entry.data = data;
+        if (context?.metrics)
+            entry.metrics = context.metrics;
+        if (error) {
+            entry.error = {
+                message: error.message,
+                stack: error.stack,
+                code: error.code
+            };
+        }
+        return entry;
     }
     setLevel(level) {
-        this.level = level;
+        this.config.level = level;
     }
     setQuiet(quiet) {
-        this.quiet = quiet;
+        this.config.quiet = quiet;
+    }
+    setComponent(component) {
+        this.config.component = component;
     }
-    error(message, ...args) {
-        if (!this.quiet && this.level >= LogLevel.ERROR) {
-            console.error(`[ERROR] ${message}`, ...args);
+    error(message, errorOrData, context) {
+        if (this.config.level >= LogLevel.ERROR) {
+            let error;
+            let data;
+            if (errorOrData instanceof Error) {
+                error = errorOrData;
+                data = context?.data;
+            }
+            else {
+                data = errorOrData;
+                error = undefined;
+            }
+            const entry = this.createLogEntry('ERROR', message, data, error, context);
+            this.writeLog(entry);
         }
     }
-    warn(message, ...args) {
-        if (!this.quiet && this.level >= LogLevel.WARN) {
-            console.warn(`[WARN] ${message}`, ...args);
+    warn(message, data, context) {
+        if (this.config.level >= LogLevel.WARN) {
+            const entry = this.createLogEntry('WARN', message, data, undefined, context);
+            this.writeLog(entry);
         }
     }
-    info(message, ...args) {
-        if (!this.quiet && this.level >= LogLevel.INFO) {
-            console.info(`[INFO] ${message}`, ...args);
+    info(message, data, context) {
+        if (this.config.level >= LogLevel.INFO) {
+            const entry = this.createLogEntry('INFO', message, data, undefined, context);
+            this.writeLog(entry);
         }
     }
-    debug(message, ...args) {
-        if (!this.quiet && this.level >= LogLevel.DEBUG) {
-            console.debug(`[DEBUG] ${message}`, ...args);
+    debug(message, data, context) {
+        if (this.config.level >= LogLevel.DEBUG) {
+            const entry = this.createLogEntry('DEBUG', message, data, undefined, context);
+            this.writeLog(entry);
+        }
+    }
+    logServerEvent(event, message, data, error) {
+        const metrics = event === 'startup' || event === 'shutdown' ? {
+            memoryUsage: process.memoryUsage()
+        } : undefined;
+        const entry = this.createLogEntry(event === 'error' ? 'ERROR' : 'INFO', `[SERVER-${event.toUpperCase()}] ${message}`, data, error, { component: 'ProxyServer', metrics });
+        this.writeLog(entry);
+    }
+    logConnectionEvent(event, connectionId, message, data, error) {
+        const entry = this.createLogEntry(error ? 'ERROR' : 'INFO', `[CONNECTION-${event.toUpperCase()}] ${message}`, data, error, { component: 'ConnectionPool', connectionId });
+        this.writeLog(entry);
+    }
+    logClientEvent(event, clientId, message, data, error) {
+        const entry = this.createLogEntry(error ? 'ERROR' : 'INFO', `[CLIENT-${event.toUpperCase()}] ${message}`, data, error, { component: 'WSProxy', clientId });
+        this.writeLog(entry);
+    }
+    logMemoryEvent(event, message, metrics) {
+        const entry = this.createLogEntry('INFO', `[MEMORY-${event.toUpperCase()}] ${message}`, undefined, undefined, { component: 'MemoryManager', metrics });
+        this.writeLog(entry);
+    }
+    logAPIEvent(method, path, statusCode, duration, clientIP, error) {
+        const entry = this.createLogEntry(error ? 'ERROR' : 'INFO', `[API] ${method} ${path} - ${statusCode} (${duration}ms)`, { clientIP, duration, statusCode }, error, { component: 'ProxyAPI' });
+        this.writeLog(entry);
+    }
+    logSecurityEvent(event, message, data, error) {
+        const entry = this.createLogEntry(error ? 'ERROR' : 'WARN', `[SECURITY-${event.toUpperCase()}] ${message}`, data, error, { component: 'SecurityManager' });
+        this.writeLog(entry);
+    }
+    logPerformanceMetrics(component, metrics) {
+        const entry = this.createLogEntry('INFO', `[PERFORMANCE] ${component} metrics`, undefined, undefined, { component, metrics });
+        this.writeLog(entry);
+    }
+    close() {
+        if (this.logFileHandle) {
+            this.logFileHandle.end();
+            this.logFileHandle = undefined;
         }
     }
 }
 exports.Logger = Logger;
 exports.logger = new Logger();
+const createLogger = (config = {}) => {
+    return new Logger(config);
+};
+exports.createLogger = createLogger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-cdp-cli",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "LLM-first browser automation CLI via Chrome DevTools Protocol. Eval-first design optimized for AI assistants - LLMs write JavaScript scripts for rapid validation. Features: JavaScript execution, element interaction, screenshots, DOM snapshots, console/network monitoring. Built-in IDE integration for Cursor and Claude.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,8 +20,10 @@
     "build:prod": "node scripts/build.js production",
     "build:watch": "tsc --watch",
     "dev": "ts-node src/index.ts",
+    "dev:proxy": "ts-node src/proxy/index.ts",
     "demo": "ts-node demo.ts",
     "start": "node dist/index.js",
+    "start:proxy": "node dist/proxy/index.js",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
@@ -58,10 +60,14 @@
   "homepage": "https://github.com/nicoster/chrome-devtools-cli#readme",
   "dependencies": {
     "commander": "^11.1.0",
+    "express": "^4.18.2",
+    "express-rate-limit": "^8.2.1",
     "node-fetch": "^2.7.0",
     "ws": "^8.14.2"
   },
   "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/express-rate-limit": "^5.1.3",
     "@types/jest": "^29.5.8",
     "@types/node": "^20.9.0",
     "@types/node-fetch": "^2.6.13",