chrome-cdp-cli 2.0.5 → 2.1.1

package/dist/cli/ArgumentParser.js

@@ -6,23 +6,87 @@ class ArgumentParser {
     constructor() {
         this.commands = new Map();
         this.aliases = new Map();
+        this.globalOptionDefs = [
+            {
+                name: "host",
+                short: "h",
+                type: "string",
+                description: "Chrome host address",
+                default: "localhost",
+            },
+            {
+                name: "port",
+                short: "p",
+                type: "number",
+                description: "DevTools port",
+                default: 9222,
+            },
+            {
+                name: "format",
+                short: "f",
+                type: "string",
+                description: "Output format",
+                choices: ["json", "text"],
+                default: "text",
+            },
+            {
+                name: "verbose",
+                short: "v",
+                type: "boolean",
+                description: "Enable verbose logging",
+                default: false,
+            },
+            {
+                name: "quiet",
+                short: "q",
+                type: "boolean",
+                description: "Enable quiet mode",
+                default: false,
+            },
+            {
+                name: "timeout",
+                short: "t",
+                type: "number",
+                description: "Command timeout in milliseconds",
+                default: 30000,
+            },
+            {
+                name: "debug",
+                short: "d",
+                type: "boolean",
+                description: "Enable debug logging",
+                default: false,
+            },
+            {
+                name: "config",
+                short: "c",
+                type: "string",
+                description: "Configuration file path",
+            },
+            {
+                name: "target-index",
+                short: "i",
+                type: "number",
+                description: "Target page index (1-based, excludes DevTools windows)",
+            },
+        ];
         this.helpSystem = new HelpSystem_1.HelpSystem(undefined, this);
     }
     parseArguments(argv) {
         try {
             if (!Array.isArray(argv)) {
-                return this.createParseResult('help', {}, [], true);
+                return this.createParseResult("help", {}, [], true);
             }
             const sliceStart = Math.max(0, Math.min(2, argv.length));
             const args = argv.slice(sliceStart);
             if (args.length === 0) {
-                return this.createParseResult('help', {}, [], true);
+                return this.createParseResult("help", {}, [], true);
             }
-            if (args.includes('--help')) {
-                return this.createParseResult('help', {}, [], true);
+            if (args.includes("--help")) {
+                return this.createParseResult("help", {}, [], true);
             }
-            if (args.includes('--version') || args.includes('-V')) {
-                return this.createParseResult('version', {}, [], true);
+            if (args.includes("--version") || args.includes("-V")) {
+                return this.createParseResult("version", {}, [], true);
             }
             let globalOptions;
             let commandName;
@@ -34,41 +98,49 @@ class ArgumentParser {
                 commandArgs = parseResult.commandArgs;
             }
             catch (parseError) {
-                if (args.some(arg => arg === '--help' || arg === 'help')) {
-                    return this.createParseResult('help', {}, [], true);
+                if (args.some((arg) => arg === "--help" || arg === "help")) {
+                    return this.createParseResult("help", {}, [], true);
                 }
                 throw parseError;
             }
             const resolvedCommand = this.resolveCommandName(commandName);
-            if (resolvedCommand === 'help') {
+            if (resolvedCommand === "help") {
                 return this.createParseResult(resolvedCommand, globalOptions, [], true, commandArgs);
             }
             const commandDef = this.commands.get(resolvedCommand);
             if (!commandDef) {
-                return this.createParseResult(resolvedCommand, globalOptions, [`Unknown command: ${commandName}. Use 'help' to see available commands.`], false);
+                return this.createParseResult(resolvedCommand, globalOptions, [
+                    `Unknown command: ${commandName}. Use 'help' to see available commands.`,
+                ], false);
             }
             const parseResult = this.parseCommandArguments(commandDef, commandArgs);
-            const allOptions = { ...globalOptions, ...parseResult.options };
+            const allOptions = {
+                ...globalOptions,
+                ...parseResult.globalOptions,
+                ...parseResult.options,
+            };
             return this.createParseResult(resolvedCommand, allOptions, parseResult.errors, parseResult.errors.length === 0, parseResult.arguments);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             if (process.env.DEBUG) {
-                console.error('Parse error details:', error);
+                console.error("Parse error details:", error);
                 if (error instanceof Error && error.stack) {
-                    console.error('Stack trace:', error.stack);
+                    console.error("Stack trace:", error.stack);
                 }
             }
-            if (errorMessage.includes('Invalid count value')) {
-                return this.createParseResult('help', {}, [`Parse error: Invalid argument format. Please check your command syntax.`], false);
+            if (errorMessage.includes("Invalid count value")) {
+                return this.createParseResult("help", {}, [
+                    `Parse error: Invalid argument format. Please check your command syntax.`,
+                ], false);
             }
-            return this.createParseResult('help', {}, [`Parse error: ${errorMessage}`], false);
+            return this.createParseResult("help", {}, [`Parse error: ${errorMessage}`], false);
         }
     }
     registerCommand(command) {
         const validation = this.validateCommandDefinition(command);
         if (!validation.valid) {
-            throw new Error(`Invalid command definition: ${validation.errors.join(', ')}`);
+            throw new Error(`Invalid command definition: ${validation.errors.join(", ")}`);
         }
         this.commands.set(command.name, command);
         for (const alias of command.aliases) {
@@ -80,7 +152,7 @@ class ArgumentParser {
     }
     generateHelp(command) {
         if (command) {
-            if (command.startsWith('topic ')) {
+            if (command.startsWith("topic ")) {
                 const topicName = command.substring(6);
                 return this.helpSystem.generateTopicHelp(topicName);
             }
@@ -94,7 +166,7 @@ class ArgumentParser {
             return {
                 valid: false,
                 errors: [`Unknown command: ${command}`],
-                warnings: []
+                warnings: [],
             };
         }
         const errors = [];
@@ -104,23 +176,27 @@ class ArgumentParser {
                 errors.push(`Required option --${option.name} is missing`);
             }
         }
-        const requiredArgs = commandDef.arguments.filter(arg => arg.required);
+        const requiredArgs = commandDef.arguments.filter((arg) => arg.required);
         if (args.arguments.length < requiredArgs.length) {
             const providedCount = Math.max(0, Math.min(args.arguments.length, requiredArgs.length));
             const missingCount = Math.max(0, requiredArgs.length - providedCount);
             if (missingCount > 0) {
                 const startIndex = Math.max(0, providedCount);
                 const endIndex = Math.min(requiredArgs.length, startIndex + missingCount);
-                if (startIndex < endIndex && startIndex >= 0 && endIndex <= requiredArgs.length) {
-                    const missingArgs = requiredArgs.slice(startIndex, endIndex).map(arg => arg.name);
+                if (startIndex < endIndex &&
+                    startIndex >= 0 &&
+                    endIndex <= requiredArgs.length) {
+                    const missingArgs = requiredArgs
+                        .slice(startIndex, endIndex)
+                        .map((arg) => arg.name);
                     if (missingArgs.length > 0) {
-                        errors.push(`Missing required arguments: ${missingArgs.join(', ')}`);
+                        errors.push(`Missing required arguments: ${missingArgs.join(", ")}`);
                     }
                 }
             }
         }
         for (const [optionName, value] of Object.entries(args.options)) {
-            const optionDef = commandDef.options.find(opt => opt.name === optionName);
+            const optionDef = commandDef.options.find((opt) => opt.name === optionName);
             if (optionDef) {
                 const optionValidation = this.validateOptionValue(optionDef, value);
                 if (!optionValidation.valid) {
@@ -142,31 +218,21 @@ class ArgumentParser {
         return {
             valid: errors.length === 0,
             errors,
-            warnings
+            warnings,
         };
     }
     parseGlobalAndCommand(args) {
-        if (args.includes('--help')) {
-            return { globalOptions: {}, commandName: 'help', commandArgs: [] };
+        if (args.includes("--help")) {
+            return { globalOptions: {}, commandName: "help", commandArgs: [] };
         }
         const globalOptions = {};
-        let commandName = 'help';
+        let commandName = "help";
         let commandArgs = [];
         let i = 0;
-        const globalOptionDefs = [
-            { name: 'host', short: 'h', type: 'string', description: 'Chrome host address', default: 'localhost' },
-            { name: 'port', short: 'p', type: 'number', description: 'DevTools port', default: 9222 },
-            { name: 'format', short: 'f', type: 'string', description: 'Output format', choices: ['json', 'text'], default: 'text' },
-            { name: 'verbose', short: 'v', type: 'boolean', description: 'Enable verbose logging', default: false },
-            { name: 'quiet', short: 'q', type: 'boolean', description: 'Enable quiet mode', default: false },
-            { name: 'timeout', short: 't', type: 'number', description: 'Command timeout in milliseconds', default: 30000 },
-            { name: 'debug', short: 'd', type: 'boolean', description: 'Enable debug logging', default: false },
-            { name: 'config', short: 'c', type: 'string', description: 'Configuration file path' },
-            { name: 'target-index', type: 'number', description: 'Target page index (1-based, excludes DevTools windows)' }
-        ];
+        const globalOptionDefs = this.globalOptionDefs;
         while (i < args.length) {
             const arg = args[i];
-            if (arg.startsWith('--')) {
+            if (arg.startsWith("--")) {
                 const { option, value, consumed } = this.parseLongOption(arg, args, i, globalOptionDefs);
                 if (option) {
                     globalOptions[option.name] = value;
@@ -185,7 +251,7 @@ class ArgumentParser {
                     break;
                 }
             }
-            else if (arg.startsWith('-') && arg.length > 1) {
+            else if (arg.startsWith("-") && arg.length > 1) {
                 const { option, value, consumed } = this.parseShortOption(arg, args, i, globalOptionDefs);
                 if (option) {
                     globalOptions[option.name] = value;
@@ -222,25 +288,25 @@ class ArgumentParser {
         let optionName = arg.substring(2);
         let value;
         let consumed = 1;
-        const equalIndex = optionName.indexOf('=');
+        const equalIndex = optionName.indexOf("=");
         if (equalIndex !== -1) {
             value = optionName.substring(equalIndex + 1);
             optionName = optionName.substring(0, equalIndex);
         }
         let isNegated = false;
-        if (optionName.startsWith('no-')) {
+        if (optionName.startsWith("no-")) {
             isNegated = true;
             optionName = optionName.substring(3);
         }
-        const optionDef = optionDefs.find(opt => opt.name === optionName);
+        const optionDef = optionDefs.find((opt) => opt.name === optionName);
         if (!optionDef) {
             return { option: null, value: null, consumed: 0 };
         }
-        if (optionDef.type === 'boolean') {
+        if (optionDef.type === "boolean") {
             value = !isNegated;
         }
         else if (value === undefined) {
-            if (index + 1 < args.length && !args[index + 1].startsWith('-')) {
+            if (index + 1 < args.length && !args[index + 1].startsWith("-")) {
                 value = args[index + 1];
                 consumed = 2;
             }
@@ -256,17 +322,17 @@ class ArgumentParser {
         if (shortName.length > 1) {
             return { option: null, value: null, consumed: 0 };
         }
-        const optionDef = optionDefs.find(opt => opt.short === shortName);
+        const optionDef = optionDefs.find((opt) => opt.short === shortName);
         if (!optionDef) {
             return { option: null, value: null, consumed: 0 };
         }
         let value;
         let consumed = 1;
-        if (optionDef.type === 'boolean') {
+        if (optionDef.type === "boolean") {
             value = true;
         }
         else {
-            if (index + 1 < args.length && !args[index + 1].startsWith('-')) {
+            if (index + 1 < args.length && !args[index + 1].startsWith("-")) {
                 value = args[index + 1];
                 consumed = 2;
             }
@@ -287,49 +353,54 @@ class ArgumentParser {
     }
     parseCommandArguments(commandDef, args) {
         const options = {};
+        const lateGlobalOptions = {};
         const arguments_ = [];
         const errors = [];
         let i = 0;
         while (i < args.length) {
             const arg = args[i];
-            if (arg.startsWith('--')) {
+            if (arg.startsWith("--")) {
                 try {
                     const { option, value, consumed } = this.parseLongOption(arg, args, i, commandDef.options);
                     if (option) {
                         options[option.name] = value;
-                        if (consumed > 0) {
-                            i += consumed;
+                        i += consumed > 0 ? consumed : 1;
+                    }
+                    else {
+                        const { option: gOpt, value: gVal, consumed: gConsumed, } = this.parseLongOption(arg, args, i, this.globalOptionDefs);
+                        if (gOpt) {
+                            lateGlobalOptions[gOpt.name] = gVal;
+                            i += gConsumed > 0 ? gConsumed : 1;
                         }
                         else {
+                            errors.push(`Unknown option: ${arg}`);
                             i++;
                         }
                     }
-                    else {
-                        errors.push(`Unknown option: ${arg}`);
-                        i++;
-                    }
                 }
                 catch (error) {
                     errors.push(error instanceof Error ? error.message : String(error));
                     i++;
                 }
             }
-            else if (arg.startsWith('-') && arg.length > 1) {
+            else if (arg.startsWith("-") && arg.length > 1) {
                 try {
                     const { option, value, consumed } = this.parseShortOption(arg, args, i, commandDef.options);
                     if (option) {
                         options[option.name] = value;
-                        if (consumed > 0) {
-                            i += consumed;
+                        i += consumed > 0 ? consumed : 1;
+                    }
+                    else {
+                        const { option: gOpt, value: gVal, consumed: gConsumed, } = this.parseShortOption(arg, args, i, this.globalOptionDefs);
+                        if (gOpt) {
+                            lateGlobalOptions[gOpt.name] = gVal;
+                            i += gConsumed > 0 ? gConsumed : 1;
                         }
                         else {
+                            errors.push(`Unknown option: ${arg}`);
                             i++;
                         }
                     }
-                    else {
-                        errors.push(`Unknown option: ${arg}`);
-                        i++;
-                    }
                 }
                 catch (error) {
                     errors.push(error instanceof Error ? error.message : String(error));
@@ -341,7 +412,12 @@ class ArgumentParser {
                 i++;
             }
         }
-        return { options, arguments: arguments_, errors };
+        return {
+            options,
+            globalOptions: lateGlobalOptions,
+            arguments: arguments_,
+            errors,
+        };
     }
     convertOptionValue(optionDef, value) {
         if (value === undefined || value === null) {
@@ -349,32 +425,36 @@ class ArgumentParser {
         }
         const stringValue = String(value);
         switch (optionDef.type) {
-            case 'number': {
+            case "number": {
                 const numValue = Number(stringValue);
                 if (isNaN(numValue)) {
                     throw new Error(`Option --${optionDef.name} must be a number, got: ${stringValue}`);
                 }
                 return numValue;
             }
-            case 'boolean': {
-                if (typeof value === 'boolean') {
+            case "boolean": {
+                if (typeof value === "boolean") {
                     return value;
                 }
                 const lowerValue = stringValue.toLowerCase();
-                if (lowerValue === 'true' || lowerValue === '1' || lowerValue === 'yes') {
+                if (lowerValue === "true" ||
+                    lowerValue === "1" ||
+                    lowerValue === "yes") {
                     return true;
                 }
-                if (lowerValue === 'false' || lowerValue === '0' || lowerValue === 'no') {
+                if (lowerValue === "false" ||
+                    lowerValue === "0" ||
+                    lowerValue === "no") {
                     return false;
                 }
                 throw new Error(`Option --${optionDef.name} must be a boolean, got: ${stringValue}`);
             }
-            case 'array':
+            case "array":
                 if (Array.isArray(value)) {
                     return value;
                 }
-                return stringValue.split(',').map(s => s.trim());
-            case 'string':
+                return stringValue.split(",").map((s) => s.trim());
+            case "string":
             default:
                 return stringValue;
         }
@@ -384,7 +464,7 @@ class ArgumentParser {
         const warnings = [];
         if (optionDef.choices && optionDef.choices.length > 0) {
             if (!optionDef.choices.includes(String(value))) {
-                errors.push(`Option --${optionDef.name} must be one of: ${optionDef.choices.join(', ')}`);
+                errors.push(`Option --${optionDef.name} must be one of: ${optionDef.choices.join(", ")}`);
             }
         }
         if (optionDef.validator) {
@@ -397,24 +477,24 @@ class ArgumentParser {
         return {
             valid: errors.length === 0,
             errors,
-            warnings
+            warnings,
         };
     }
     validateArgumentValue(argDef, value) {
         const errors = [];
         const warnings = [];
         switch (argDef.type) {
-            case 'number':
+            case "number":
                 if (isNaN(Number(value))) {
                     errors.push(`Argument ${argDef.name} must be a number, got: ${value}`);
                 }
                 break;
-            case 'file':
-                if (typeof value !== 'string' || value.trim().length === 0) {
+            case "file":
+                if (typeof value !== "string" || value.trim().length === 0) {
                     errors.push(`Argument ${argDef.name} must be a valid file path`);
                 }
                 break;
-            case 'url':
+            case "url":
                 try {
                     new URL(String(value));
                 }
@@ -433,7 +513,7 @@ class ArgumentParser {
         return {
             valid: errors.length === 0,
             errors,
-            warnings
+            warnings,
         };
     }
     resolveCommandName(commandName) {
@@ -441,41 +521,41 @@ class ArgumentParser {
     }
     validateCommandDefinition(command) {
         const errors = [];
-        if (!command.name || typeof command.name !== 'string') {
-            errors.push('Command name is required and must be a string');
+        if (!command.name || typeof command.name !== "string") {
+            errors.push("Command name is required and must be a string");
         }
-        if (!command.description || typeof command.description !== 'string') {
-            errors.push('Command description is required and must be a string');
+        if (!command.description || typeof command.description !== "string") {
+            errors.push("Command description is required and must be a string");
         }
         if (!Array.isArray(command.aliases)) {
-            errors.push('Command aliases must be an array');
+            errors.push("Command aliases must be an array");
         }
         if (!Array.isArray(command.options)) {
-            errors.push('Command options must be an array');
+            errors.push("Command options must be an array");
         }
         if (!Array.isArray(command.arguments)) {
-            errors.push('Command arguments must be an array');
+            errors.push("Command arguments must be an array");
         }
         for (const option of command.options) {
-            if (!option.name || typeof option.name !== 'string') {
+            if (!option.name || typeof option.name !== "string") {
                 errors.push(`Option name is required and must be a string`);
             }
-            if (!['string', 'number', 'boolean', 'array'].includes(option.type)) {
+            if (!["string", "number", "boolean", "array"].includes(option.type)) {
                 errors.push(`Option ${option.name} has invalid type: ${option.type}`);
             }
         }
         for (const arg of command.arguments) {
-            if (!arg.name || typeof arg.name !== 'string') {
+            if (!arg.name || typeof arg.name !== "string") {
                 errors.push(`Argument name is required and must be a string`);
             }
-            if (!['string', 'number', 'file', 'url'].includes(arg.type)) {
+            if (!["string", "number", "file", "url"].includes(arg.type)) {
                 errors.push(`Argument ${arg.name} has invalid type: ${arg.type}`);
             }
         }
         return {
             valid: errors.length === 0,
             errors,
-            warnings: []
+            warnings: [],
         };
     }
     createParseResult(command, options, errors, success, arguments_ = []) {
@@ -485,7 +565,7 @@ class ArgumentParser {
             options,
             arguments: arguments_,
             errors,
-            warnings: []
+            warnings: [],
         };
     }
     getCommands() {