chrome-cdp-cli 1.8.1 → 2.0.0

package/dist/config/example.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.demonstrateConfigurationSystem = demonstrateConfigurationSystem;
+const ConfigurationManager_1 = require("./ConfigurationManager");
+const utils_1 = require("./utils");
+async function demonstrateConfigurationSystem() {
+    console.log('=== Configuration Management System Demo ===\n');
+    const configManager = new ConfigurationManager_1.ConfigurationManager();
+    console.log('1. Creating configuration sources...');
+    const cliOptions = {
+        verbose: true,
+        port: 8080,
+        outputFormat: 'json'
+    };
+    const sources = await configManager.createConfigurationSources(cliOptions);
+    console.log(`Created ${sources.length} configuration sources:`);
+    sources.forEach(source => {
+        console.log(`  - ${source.type} (priority: ${source.priority}) from ${source.source}`);
+    });
+    console.log('\n2. Loading and merging configuration...');
+    const config = await configManager.loadConfiguration(sources);
+    console.log('Final configuration:', JSON.stringify(config, null, 2));
+    console.log('\n3. Validating configuration...');
+    const validation = configManager.validateConfiguration(config);
+    console.log(`Validation result: ${validation.valid ? 'VALID' : 'INVALID'}`);
+    if (validation.errors.length > 0) {
+        console.log('Errors:', validation.errors);
+    }
+    if (validation.warnings.length > 0) {
+        console.log('Warnings:', validation.warnings);
+    }
+    console.log('\n4. Resolving specific configuration values...');
+    try {
+        const host = configManager.resolveConfigValue('host', 'string');
+        const port = configManager.resolveConfigValue('port', 'number');
+        const verbose = configManager.resolveConfigValue('verbose', 'boolean');
+        console.log(`Host: ${host}`);
+        console.log(`Port: ${port}`);
+        console.log(`Verbose: ${verbose}`);
+    }
+    catch (error) {
+        console.error('Error resolving config values:', error);
+    }
+    console.log('\n5. Environment configuration example...');
+    const envSource = configManager.loadEnvironmentConfig();
+    console.log('Environment variables found:', envSource.data);
+    console.log('\n6. Configuration file template (YAML):');
+    console.log('---');
+    console.log((0, utils_1.getConfigTemplate)('yaml'));
+    console.log('---');
+}
+if (require.main === module) {
+    demonstrateConfigurationSystem().catch(console.error);
+}

package/dist/config/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationManager = void 0;
+__exportStar(require("./interfaces"), exports);
+var ConfigurationManager_1 = require("./ConfigurationManager");
+Object.defineProperty(exports, "ConfigurationManager", { enumerable: true, get: function () { return ConfigurationManager_1.ConfigurationManager; } });
+__exportStar(require("./utils"), exports);

package/dist/config/interfaces.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG_PATHS = exports.DEFAULT_CONFIG_FILES = exports.ENV_PREFIX = exports.CONFIG_PRIORITIES = exports.DEFAULT_CLI_CONFIG = void 0;
+exports.DEFAULT_CLI_CONFIG = {
+    host: 'localhost',
+    port: 9222,
+    timeout: 30000,
+    outputFormat: 'text',
+    verbose: false,
+    quiet: false,
+    debug: false,
+    pluginDirs: [],
+    aliases: {},
+    commands: {}
+};
+exports.CONFIG_PRIORITIES = {
+    default: 0,
+    file: 10,
+    env: 20,
+    cli: 30
+};
+exports.ENV_PREFIX = 'CHROME_CDP_CLI_';
+exports.DEFAULT_CONFIG_FILES = [
+    '.chrome-cdp-cli.yaml',
+    '.chrome-cdp-cli.yml',
+    '.chrome-cdp-cli.json',
+    'chrome-cdp-cli.config.yaml',
+    'chrome-cdp-cli.config.yml',
+    'chrome-cdp-cli.config.json'
+];
+exports.DEFAULT_CONFIG_PATHS = [
+    process.cwd(),
+    process.env.HOME || process.env.USERPROFILE || '',
+    '/etc'
+];

package/dist/config/utils.js

@@ -0,0 +1,238 @@
+"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.createDefaultConfigSources = createDefaultConfigSources;
+exports.validateConfigFile = validateConfigFile;
+exports.getConfigTemplate = getConfigTemplate;
+exports.normalizeConfigPath = normalizeConfigPath;
+exports.configFileExists = configFileExists;
+exports.createConfigFile = createConfigFile;
+exports.getEnvironmentVariables = getEnvironmentVariables;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const interfaces_1 = require("./interfaces");
+const ConfigurationManager_1 = require("./ConfigurationManager");
+async function createDefaultConfigSources(cliOptions = {}) {
+    const configManager = new ConfigurationManager_1.ConfigurationManager();
+    return await configManager.createConfigurationSources(cliOptions);
+}
+async function validateConfigFile(filePath) {
+    const configManager = new ConfigurationManager_1.ConfigurationManager();
+    try {
+        await fs.promises.access(filePath, fs.constants.R_OK);
+        const config = await configManager.loadYAMLConfig(filePath);
+        const sources = [
+            {
+                type: 'default',
+                priority: interfaces_1.CONFIG_PRIORITIES.default,
+                data: { ...interfaces_1.DEFAULT_CLI_CONFIG },
+                source: 'defaults'
+            },
+            {
+                type: 'file',
+                priority: interfaces_1.CONFIG_PRIORITIES.file,
+                data: config,
+                source: filePath
+            }
+        ];
+        const mergedConfig = await configManager.loadConfiguration(sources);
+        return configManager.validateConfiguration(mergedConfig);
+    }
+    catch (error) {
+        return {
+            valid: false,
+            errors: [{
+                    field: 'file',
+                    message: error instanceof Error ? error.message : String(error),
+                    code: 'FILE_VALIDATION_ERROR',
+                    suggestion: 'Check file syntax and permissions'
+                }],
+            warnings: []
+        };
+    }
+}
+function getConfigTemplate(format = 'yaml') {
+    const template = {
+        profile: 'development',
+        host: 'localhost',
+        port: 9222,
+        timeout: 30000,
+        outputFormat: 'text',
+        verbose: false,
+        quiet: false,
+        debug: false,
+        plugins: {
+            directories: [
+                '~/.chrome-cdp-cli/plugins',
+                './plugins'
+            ]
+        },
+        aliases: {
+            ss: 'screenshot',
+            snap: 'snapshot',
+            js: 'eval'
+        },
+        profiles: {
+            development: {
+                host: 'localhost',
+                port: 9222,
+                debug: true,
+                verbose: true
+            },
+            production: {
+                host: 'chrome-server',
+                port: 9222,
+                quiet: true,
+                timeout: 60000
+            }
+        },
+        commands: {
+            screenshot: {
+                timeout: 10000,
+                defaults: {
+                    format: 'png',
+                    quality: 90,
+                    fullPage: false
+                }
+            },
+            eval: {
+                timeout: 5000,
+                defaults: {
+                    awaitPromise: true,
+                    returnByValue: true
+                }
+            }
+        }
+    };
+    if (format === 'json') {
+        return JSON.stringify(template, null, 2);
+    }
+    return `# Chrome CDP CLI Configuration File
+# This file supports YAML syntax for better readability
+
+# Active profile (can be overridden with --profile)
+profile: development
+
+# Global defaults
+host: localhost
+port: 9222
+timeout: 30000
+outputFormat: text
+verbose: false
+quiet: false
+debug: false
+
+# Plugin configuration
+plugins:
+  directories:
+    - ~/.chrome-cdp-cli/plugins
+    - ./plugins
+
+# Command aliases
+aliases:
+  ss: screenshot
+  snap: snapshot
+  js: eval
+
+# Profile-specific configurations
+profiles:
+  development:
+    host: localhost
+    port: 9222
+    debug: true
+    verbose: true
+  
+  production:
+    host: chrome-server
+    port: 9222
+    quiet: true
+    timeout: 60000
+
+# Command-specific defaults
+commands:
+  screenshot:
+    timeout: 10000
+    defaults:
+      format: png
+      quality: 90
+      fullPage: false
+  
+  eval:
+    timeout: 5000
+    defaults:
+      awaitPromise: true
+      returnByValue: true
+`;
+}
+function normalizeConfigPath(configPath) {
+    if (configPath.startsWith('~/')) {
+        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        return path.join(homeDir, configPath.slice(2));
+    }
+    if (!path.isAbsolute(configPath)) {
+        return path.resolve(process.cwd(), configPath);
+    }
+    return configPath;
+}
+async function configFileExists(filePath) {
+    try {
+        await fs.promises.access(normalizeConfigPath(filePath), fs.constants.R_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function createConfigFile(filePath, format = 'yaml') {
+    const normalizedPath = normalizeConfigPath(filePath);
+    const content = getConfigTemplate(format);
+    const dir = path.dirname(normalizedPath);
+    await fs.promises.mkdir(dir, { recursive: true });
+    await fs.promises.writeFile(normalizedPath, content, 'utf-8');
+}
+function getEnvironmentVariables() {
+    return [
+        'CHROME_CDP_CLI_HOST',
+        'CHROME_CDP_CLI_PORT',
+        'CHROME_CDP_CLI_TIMEOUT',
+        'CHROME_CDP_CLI_OUTPUT_FORMAT',
+        'CHROME_CDP_CLI_VERBOSE',
+        'CHROME_CDP_CLI_QUIET',
+        'CHROME_CDP_CLI_DEBUG',
+        'CHROME_CDP_CLI_PROFILE',
+        'CHROME_CDP_CLI_CONFIG_FILE',
+        'CHROME_CDP_CLI_PLUGIN_DIRS'
+    ];
+}

package/dist/handlers/EvaluateScriptHandler.js

@@ -159,7 +159,7 @@ class EvaluateScriptHandler {
                 }
                 let value = commandResult.result?.value;
                 if (commandResult.result?.type === 'undefined') {
-                    value = undefined;
+                    value = '';
                 }
                 else if (commandResult.result?.unserializableValue) {
                     value = commandResult.result.unserializableValue;
@@ -227,6 +227,10 @@ class EvaluateScriptHandler {
         }
     }
     async executeScript(client, expression, awaitPromise, returnByValue) {
+        const consoleHandler = (params) => {
+            this.handleConsoleOutput(params);
+        };
+        client.on('Runtime.consoleAPICalled', consoleHandler);
         try {
             const response = (await client.send('Runtime.evaluate', {
                 expression,
@@ -261,6 +265,52 @@ class EvaluateScriptHandler {
                 error: `CDP command failed: ${error instanceof Error ? error.message : String(error)}`
             };
         }
+        finally {
+            client.off('Runtime.consoleAPICalled', consoleHandler);
+        }
+    }
+    handleConsoleOutput(params) {
+        try {
+            const consoleParams = params;
+            const messageText = this.formatConsoleArgs(consoleParams.args || []);
+            const messageType = this.mapConsoleType(consoleParams.type);
+            if (messageType === 'log' || messageType === 'info' || messageType === 'debug') {
+                process.stdout.write(messageText + '\n');
+            }
+            else {
+                process.stderr.write(messageText + '\n');
+            }
+        }
+        catch (error) {
+            this.logger.debug('Error handling console output:', error);
+        }
+    }
+    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(' ');
+    }
+    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';
+        }
     }
     formatException(exceptionDetails) {
         if (!exceptionDetails) {
@@ -285,7 +335,10 @@ class EvaluateScriptHandler {
     }
     formatResult(result) {
         if (!result) {
-            return 'undefined';
+            return '';
+        }
+        if (result.type === 'undefined') {
+            return '';
         }
         if (result.value !== undefined) {
             return result.value;