chrome-cdp-cli 1.0.0

package/dist/cli/CLIInterface.js

@@ -0,0 +1,327 @@
+"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.CLIInterface = void 0;
+const commander_1 = require("commander");
+const path = __importStar(require("path"));
+const CLIInterface_1 = require("../interfaces/CLIInterface");
+const CommandRegistry_1 = require("./CommandRegistry");
+const CommandRouter_1 = require("./CommandRouter");
+class CLIInterface {
+    constructor() {
+        this.program = new commander_1.Command();
+        this.registry = new CommandRegistry_1.CommandRegistry();
+        this.router = new CommandRouter_1.CommandRouter(this.registry);
+        this.setupProgram();
+    }
+    setupProgram() {
+        this.program
+            .name('chrome-cli')
+            .description('Command-line tool for controlling Chrome browser via DevTools Protocol')
+            .version('1.0.0')
+            .allowUnknownOption(true)
+            .allowExcessArguments(true);
+        this.program
+            .option('-h, --host <host>', 'Chrome host address', CLIInterface_1.DEFAULT_CLI_CONFIG.host)
+            .option('-p, --port <port>', 'DevTools port', (value) => parseInt(value, 10), CLIInterface_1.DEFAULT_CLI_CONFIG.port)
+            .option('-f, --format <format>', 'Output format (json|text)', CLIInterface_1.DEFAULT_CLI_CONFIG.outputFormat)
+            .option('-v, --verbose', 'Enable verbose logging', CLIInterface_1.DEFAULT_CLI_CONFIG.verbose)
+            .option('-q, --quiet', 'Enable quiet mode', CLIInterface_1.DEFAULT_CLI_CONFIG.quiet)
+            .option('-t, --timeout <timeout>', 'Command timeout in milliseconds', (value) => parseInt(value, 10), CLIInterface_1.DEFAULT_CLI_CONFIG.timeout)
+            .option('-c, --config <config>', 'Configuration file path');
+    }
+    parseArgs(argv) {
+        try {
+            const args = argv.slice(2);
+            const options = {};
+            const commandArgs = [];
+            let i = 0;
+            while (i < args.length) {
+                const arg = args[i];
+                if (arg.startsWith('--')) {
+                    const optionName = arg.substring(2);
+                    if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+                        options[optionName] = args[i + 1];
+                        i += 2;
+                    }
+                    else {
+                        options[optionName] = true;
+                        i++;
+                    }
+                }
+                else if (arg.startsWith('-') && arg.length > 1) {
+                    const shortOption = arg.substring(1);
+                    if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+                        options[shortOption] = args[i + 1];
+                        i += 2;
+                    }
+                    else {
+                        options[shortOption] = true;
+                        i++;
+                    }
+                }
+                else {
+                    commandArgs.push(arg);
+                    i++;
+                }
+            }
+            if (options.h)
+                options.host = options.h;
+            if (options.p)
+                options.port = parseInt(options.p, 10);
+            if (options.f)
+                options.format = options.f;
+            if (options.v)
+                options.verbose = true;
+            if (options.q)
+                options.quiet = true;
+            if (options.t)
+                options.timeout = parseInt(options.t, 10);
+            if (options.c)
+                options.config = options.c;
+            if (options.port && typeof options.port === 'string') {
+                options.port = parseInt(options.port, 10);
+            }
+            if (options.timeout && typeof options.timeout === 'string') {
+                options.timeout = parseInt(options.timeout, 10);
+            }
+            const command = commandArgs[0] || 'help';
+            const remainingArgs = commandArgs.slice(1);
+            const normalizedCommand = command.replace(/-/g, '_');
+            const config = this.loadConfiguration(options.config, options);
+            const parsedArgs = this.extractCommandArgs(normalizedCommand, remainingArgs, options);
+            return {
+                name: normalizedCommand,
+                args: parsedArgs,
+                config
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to parse arguments: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    loadConfiguration(configPath, cliOptions = {}) {
+        let fileConfig = {};
+        if (configPath) {
+            fileConfig = this.loadConfigFile(configPath);
+        }
+        else {
+            const defaultPaths = [
+                '.chrome-cli.json',
+                path.join(process.env.HOME || '', '.chrome-cli.json'),
+                '/etc/chrome-cli.json'
+            ];
+            for (const defaultPath of defaultPaths) {
+                try {
+                    fileConfig = this.loadConfigFile(defaultPath);
+                    break;
+                }
+                catch {
+                }
+            }
+        }
+        return {
+            host: cliOptions.host || fileConfig.host || CLIInterface_1.DEFAULT_CLI_CONFIG.host,
+            port: cliOptions.port || fileConfig.port || CLIInterface_1.DEFAULT_CLI_CONFIG.port,
+            outputFormat: cliOptions.format || fileConfig.outputFormat || CLIInterface_1.DEFAULT_CLI_CONFIG.outputFormat,
+            verbose: cliOptions.verbose || fileConfig.verbose || CLIInterface_1.DEFAULT_CLI_CONFIG.verbose,
+            quiet: cliOptions.quiet || fileConfig.quiet || CLIInterface_1.DEFAULT_CLI_CONFIG.quiet,
+            timeout: cliOptions.timeout || fileConfig.timeout || CLIInterface_1.DEFAULT_CLI_CONFIG.timeout
+        };
+    }
+    loadConfigFile(configPath) {
+        try {
+            const content = require('fs').readFileSync(configPath, 'utf-8');
+            const config = JSON.parse(content);
+            this.validateConfig(config);
+            return config;
+        }
+        catch (error) {
+            throw new Error(`Failed to load config file "${configPath}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    validateConfig(config) {
+        if (typeof config !== 'object' || config === null) {
+            throw new Error('Configuration must be a JSON object');
+        }
+        if (config.host !== undefined && typeof config.host !== 'string') {
+            throw new Error('Configuration "host" must be a string');
+        }
+        if (config.port !== undefined && (typeof config.port !== 'number' || config.port < 1 || config.port > 65535)) {
+            throw new Error('Configuration "port" must be a number between 1 and 65535');
+        }
+        if (config.outputFormat !== undefined && !['json', 'text'].includes(config.outputFormat)) {
+            throw new Error('Configuration "outputFormat" must be "json" or "text"');
+        }
+        if (config.verbose !== undefined && typeof config.verbose !== 'boolean') {
+            throw new Error('Configuration "verbose" must be a boolean');
+        }
+        if (config.quiet !== undefined && typeof config.quiet !== 'boolean') {
+            throw new Error('Configuration "quiet" must be a boolean');
+        }
+        if (config.timeout !== undefined && (typeof config.timeout !== 'number' || config.timeout < 1)) {
+            throw new Error('Configuration "timeout" must be a positive number');
+        }
+    }
+    extractCommandArgs(command, args, options) {
+        const commandArgs = {};
+        const normalizedCommand = command.replace(/-/g, '_');
+        switch (normalizedCommand) {
+            case 'navigate':
+                commandArgs.url = args[0];
+                break;
+            case 'new_page':
+                if (options.url)
+                    commandArgs.url = options.url;
+                break;
+            case 'close_page':
+                if (options['page-id'])
+                    commandArgs.pageId = options['page-id'];
+                break;
+            case 'select_page':
+                commandArgs.pageId = args[0];
+                break;
+            case 'resize_page':
+                commandArgs.width = parseInt(args[0], 10);
+                commandArgs.height = parseInt(args[1], 10);
+                break;
+            case 'eval':
+                if (args[0] && !options.expression && !options.e && !options.file && !options.f) {
+                    commandArgs.expression = args[0];
+                }
+                else {
+                    if (options.expression || options.e)
+                        commandArgs.expression = options.expression || options.e;
+                    if (options.file || options.f)
+                        commandArgs.file = options.file || options.f;
+                }
+                commandArgs.awaitPromise = options['await-promise'] !== false;
+                commandArgs.returnByValue = options['return-by-value'] !== false;
+                break;
+            case 'click':
+            case 'hover':
+                commandArgs.selector = args[0];
+                break;
+            case 'fill':
+                commandArgs.selector = args[0];
+                commandArgs.text = args[1];
+                break;
+            case 'screenshot':
+                if (options.output || options.o)
+                    commandArgs.output = options.output || options.o;
+                if (options.width || options.w)
+                    commandArgs.width = parseInt(options.width || options.w, 10);
+                if (options.height || options.h)
+                    commandArgs.height = parseInt(options.height || options.h, 10);
+                break;
+            case 'console_messages':
+                if (options.filter)
+                    commandArgs.filter = options.filter;
+                break;
+            case 'network_requests':
+                if (options.filter)
+                    commandArgs.filter = options.filter;
+                break;
+            case 'help':
+                if (args[0])
+                    commandArgs.command = args[0];
+                break;
+            default:
+                args.forEach((arg, index) => {
+                    commandArgs[`arg${index}`] = arg;
+                });
+                break;
+        }
+        return commandArgs;
+    }
+    async execute(command) {
+        try {
+            return await this.router.execute(command);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Command execution failed: ${error instanceof Error ? error.message : String(error)}`,
+                exitCode: 1
+            };
+        }
+    }
+    formatOutput(result, format) {
+        if (format === 'json') {
+            return JSON.stringify(result, null, 2);
+        }
+        if (!result.success) {
+            return `Error: ${result.error}`;
+        }
+        if (result.data === undefined || result.data === null) {
+            return 'Success';
+        }
+        if (typeof result.data === 'string') {
+            return result.data;
+        }
+        if (typeof result.data === 'object') {
+            return JSON.stringify(result.data, null, 2);
+        }
+        return String(result.data);
+    }
+    showHelp(commandName) {
+        if (commandName) {
+            const handler = this.registry.get(commandName);
+            if (handler && handler.getHelp) {
+                return handler.getHelp();
+            }
+            else {
+                return `Unknown command: ${commandName}`;
+            }
+        }
+        return this.program.helpInformation();
+    }
+    getAvailableCommands() {
+        return this.registry.getCommandNames();
+    }
+    registerHandler(handler) {
+        this.registry.register(handler);
+    }
+    setClient(client) {
+        this.router.setClient(client);
+    }
+    getRegistry() {
+        return this.registry;
+    }
+    getRouter() {
+        return this.router;
+    }
+}
+exports.CLIInterface = CLIInterface;

package/dist/cli/CommandRegistry.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandRegistry = void 0;
+class CommandRegistry {
+    constructor() {
+        this.handlers = new Map();
+    }
+    register(handler) {
+        if (this.handlers.has(handler.name)) {
+            throw new Error(`Command handler "${handler.name}" is already registered`);
+        }
+        this.handlers.set(handler.name, handler);
+    }
+    get(name) {
+        return this.handlers.get(name);
+    }
+    getCommandNames() {
+        return Array.from(this.handlers.keys()).sort();
+    }
+    has(name) {
+        return this.handlers.has(name);
+    }
+    unregister(name) {
+        return this.handlers.delete(name);
+    }
+    clear() {
+        this.handlers.clear();
+    }
+    size() {
+        return this.handlers.size;
+    }
+}
+exports.CommandRegistry = CommandRegistry;

package/dist/cli/CommandRouter.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandRouter = exports.ExitCode = void 0;
+const logger_1 = require("../utils/logger");
+var ExitCode;
+(function (ExitCode) {
+    ExitCode[ExitCode["SUCCESS"] = 0] = "SUCCESS";
+    ExitCode[ExitCode["GENERAL_ERROR"] = 1] = "GENERAL_ERROR";
+    ExitCode[ExitCode["INVALID_COMMAND"] = 2] = "INVALID_COMMAND";
+    ExitCode[ExitCode["CONNECTION_ERROR"] = 3] = "CONNECTION_ERROR";
+    ExitCode[ExitCode["TIMEOUT_ERROR"] = 4] = "TIMEOUT_ERROR";
+    ExitCode[ExitCode["VALIDATION_ERROR"] = 5] = "VALIDATION_ERROR";
+    ExitCode[ExitCode["FILE_ERROR"] = 6] = "FILE_ERROR";
+})(ExitCode || (exports.ExitCode = ExitCode = {}));
+class CommandRouter {
+    constructor(registry) {
+        this.registry = registry;
+        this.logger = new logger_1.Logger();
+    }
+    setClient(client) {
+        this.client = client;
+    }
+    async execute(command) {
+        try {
+            if (this.isSpecialCommand(command.name)) {
+                return await this.executeSpecialCommand(command);
+            }
+            if (!this.client) {
+                return {
+                    success: false,
+                    error: 'Not connected to Chrome. Use "connect" command first.',
+                    exitCode: ExitCode.CONNECTION_ERROR
+                };
+            }
+            const handler = this.registry.get(command.name);
+            if (!handler) {
+                return {
+                    success: false,
+                    error: `Unknown command: ${command.name}. Use "help" to see available commands.`,
+                    exitCode: ExitCode.INVALID_COMMAND
+                };
+            }
+            if (handler.validateArgs && !handler.validateArgs(command.args)) {
+                return {
+                    success: false,
+                    error: `Invalid arguments for command "${command.name}". Use "help ${command.name}" for usage information.`,
+                    exitCode: ExitCode.VALIDATION_ERROR
+                };
+            }
+            if (command.config.verbose) {
+                this.logger.info(`Executing command: ${command.name}`, command.args);
+            }
+            const result = await this.executeWithTimeout(handler, command);
+            if (command.config.verbose) {
+                this.logger.info(`Command result:`, result);
+            }
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (!command.config.quiet) {
+                this.logger.error(`Command execution failed: ${errorMessage}`);
+            }
+            return {
+                success: false,
+                error: errorMessage,
+                exitCode: this.getExitCodeForError(error)
+            };
+        }
+    }
+    isSpecialCommand(commandName) {
+        const specialCommands = ['help', 'connect', 'disconnect'];
+        return specialCommands.includes(commandName);
+    }
+    async executeSpecialCommand(command) {
+        switch (command.name) {
+            case 'help':
+                return this.executeHelpCommand(command);
+            case 'connect':
+                return this.executeConnectCommand(command);
+            case 'disconnect':
+                return this.executeDisconnectCommand();
+            default:
+                return {
+                    success: false,
+                    error: `Unknown special command: ${command.name}`,
+                    exitCode: ExitCode.INVALID_COMMAND
+                };
+        }
+    }
+    executeHelpCommand(command) {
+        const commandName = command.args.command;
+        if (commandName) {
+            const normalizedCommandName = commandName.replace(/-/g, '_');
+            const handler = this.registry.get(normalizedCommandName);
+            if (!handler) {
+                return {
+                    success: false,
+                    error: `Unknown command: ${commandName}`,
+                    exitCode: ExitCode.INVALID_COMMAND
+                };
+            }
+            const helpText = handler.getHelp ? handler.getHelp() : `No help available for command: ${commandName}`;
+            return {
+                success: true,
+                data: helpText
+            };
+        }
+        else {
+            const commands = this.registry.getCommandNames();
+            const helpText = this.generateGeneralHelp(commands);
+            return {
+                success: true,
+                data: helpText
+            };
+        }
+    }
+    async executeConnectCommand(command) {
+        try {
+            return {
+                success: true,
+                data: `Connected to Chrome at ${command.config.host}:${command.config.port}`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to connect: ${error instanceof Error ? error.message : String(error)}`,
+                exitCode: ExitCode.CONNECTION_ERROR
+            };
+        }
+    }
+    async executeDisconnectCommand() {
+        try {
+            if (this.client) {
+                await this.client.disconnect();
+                this.client = undefined;
+            }
+            return {
+                success: true,
+                data: 'Disconnected from Chrome'
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to disconnect: ${error instanceof Error ? error.message : String(error)}`,
+                exitCode: ExitCode.CONNECTION_ERROR
+            };
+        }
+    }
+    async executeWithTimeout(handler, command) {
+        const timeout = command.config.timeout;
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error(`Command timeout after ${timeout}ms`));
+            }, timeout);
+        });
+        const executionPromise = handler.execute(this.client, command.args);
+        try {
+            const result = await Promise.race([executionPromise, timeoutPromise]);
+            if (!result || typeof result !== 'object') {
+                return {
+                    success: false,
+                    error: 'Invalid command result format',
+                    exitCode: ExitCode.GENERAL_ERROR
+                };
+            }
+            if (result.success && !result.exitCode) {
+                result.exitCode = ExitCode.SUCCESS;
+            }
+            return result;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('timeout')) {
+                return {
+                    success: false,
+                    error: error.message,
+                    exitCode: ExitCode.TIMEOUT_ERROR
+                };
+            }
+            throw error;
+        }
+    }
+    generateGeneralHelp(commands) {
+        return `
+Chrome DevTools CLI - Command-line tool for controlling Chrome browser
+
+Usage: chrome-cli [options] <command> [command-options]
+
+Global Options:
+  -h, --host <host>        Chrome host address (default: localhost)
+  -p, --port <port>        DevTools port (default: 9222)
+  -f, --format <format>    Output format: json|text (default: text)
+  -v, --verbose            Enable verbose logging
+  -q, --quiet              Enable quiet mode
+  -t, --timeout <ms>       Command timeout in milliseconds (default: 30000)
+  -c, --config <path>      Configuration file path
+
+Available Commands:
+${commands.map(cmd => `  ${cmd.padEnd(20)} - ${this.getCommandDescription(cmd)}`).join('\n')}
+
+Examples:
+  chrome-cli eval "document.title"
+  chrome-cli eval --file script.js
+  chrome-cli help <command>
+
+For more information about a specific command, use:
+  chrome-cli help <command>
+`;
+    }
+    getCommandDescription(commandName) {
+        const descriptions = {
+            'connect': 'Connect to Chrome instance',
+            'disconnect': 'Disconnect from Chrome instance',
+            'navigate': 'Navigate to URL',
+            'new-page': 'Create new page/tab',
+            'close-page': 'Close current or specified page',
+            'list-pages': 'List all open pages',
+            'select-page': 'Select/focus page',
+            'resize-page': 'Resize browser viewport',
+            'eval': 'Execute JavaScript code',
+            'click': 'Click element',
+            'fill': 'Fill form field',
+            'hover': 'Hover over element',
+            'screenshot': 'Take screenshot',
+            'get-html': 'Get page HTML content',
+            'console-messages': 'Get console messages',
+            'network-requests': 'Get network requests',
+            'help': 'Show help information'
+        };
+        return descriptions[commandName] || 'No description available';
+    }
+    getExitCodeForError(error) {
+        if (error instanceof Error) {
+            const message = error.message.toLowerCase();
+            if (message.includes('timeout')) {
+                return ExitCode.TIMEOUT_ERROR;
+            }
+            if (message.includes('connection') || message.includes('connect')) {
+                return ExitCode.CONNECTION_ERROR;
+            }
+            if (message.includes('file') || message.includes('path')) {
+                return ExitCode.FILE_ERROR;
+            }
+            if (message.includes('invalid') || message.includes('validation')) {
+                return ExitCode.VALIDATION_ERROR;
+            }
+        }
+        return ExitCode.GENERAL_ERROR;
+    }
+    getRegistry() {
+        return this.registry;
+    }
+}
+exports.CommandRouter = CommandRouter;

package/dist/cli/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIApplication = exports.ExitCode = exports.CommandRouter = exports.CommandRegistry = exports.CLIInterface = void 0;
+var CLIInterface_1 = require("./CLIInterface");
+Object.defineProperty(exports, "CLIInterface", { enumerable: true, get: function () { return CLIInterface_1.CLIInterface; } });
+var CommandRegistry_1 = require("./CommandRegistry");
+Object.defineProperty(exports, "CommandRegistry", { enumerable: true, get: function () { return CommandRegistry_1.CommandRegistry; } });
+var CommandRouter_1 = require("./CommandRouter");
+Object.defineProperty(exports, "CommandRouter", { enumerable: true, get: function () { return CommandRouter_1.CommandRouter; } });
+Object.defineProperty(exports, "ExitCode", { enumerable: true, get: function () { return CommandRouter_1.ExitCode; } });
+var CLIApplication_1 = require("./CLIApplication");
+Object.defineProperty(exports, "CLIApplication", { enumerable: true, get: function () { return CLIApplication_1.CLIApplication; } });