@akylas/nativescript-cli 8.8.2 → 8.8.4

package/lib/common/services/auto-completion-service.js

@@ -5,15 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutoCompletionService = void 0;
 const os_1 = require("os");
@@ -121,15 +112,13 @@ class AutoCompletionService {
             this.$logger.info("Restart your shell to disable command auto-completion.");
         }
     }
-    enableAutoCompletion() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.updateCLIShellScript();
-            _.each(this.shellProfiles, (shellFile) => this.addAutoCompletionToShellScript(shellFile));
-            this.removeObsoleteAutoCompletion();
-            if (this.scriptsOk && this.scriptsUpdated) {
-                this.$logger.info("Restart your shell to enable command auto-completion.");
-            }
-        });
+    async enableAutoCompletion() {
+        await this.updateCLIShellScript();
+        _.each(this.shellProfiles, (shellFile) => this.addAutoCompletionToShellScript(shellFile));
+        this.removeObsoleteAutoCompletion();
+        if (this.scriptsOk && this.scriptsUpdated) {
+            this.$logger.info("Restart your shell to enable command auto-completion.");
+        }
     }
     isObsoleteAutoCompletionEnabled() {
         let result = true;
@@ -201,48 +190,47 @@ class AutoCompletionService {
             }
         }
     }
-    updateCLIShellScript() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const filePath = this.cliRunCommandsFile;
-            try {
-                let doUpdate = true;
-                if (this.$fs.exists(filePath)) {
-                    const contents = this.$fs.readText(filePath);
-                    const regExp = new RegExp(AutoCompletionService.GENERATED_TABTAB_COMPLETION_START);
-                    let matchCondition = contents.match(regExp);
-                    if (matchCondition) {
-                        doUpdate = false;
-                    }
+    async updateCLIShellScript() {
+        const filePath = this.cliRunCommandsFile;
+        try {
+            let doUpdate = true;
+            if (this.$fs.exists(filePath)) {
+                const contents = this.$fs.readText(filePath);
+                const regExp = new RegExp(AutoCompletionService.GENERATED_TABTAB_COMPLETION_START);
+                let matchCondition = contents.match(regExp);
+                if (matchCondition) {
+                    doUpdate = false;
                 }
-                if (doUpdate) {
-                    const clientExecutableFileName = (this.$staticConfig.CLIENT_NAME_ALIAS || this.$staticConfig.CLIENT_NAME).toLowerCase();
-                    const pathToExecutableFile = path.join(__dirname, `../../../bin/${clientExecutableFileName}.js`);
-                    if (this.$fs.exists(filePath)) {
-                        const existingText = this.$fs.readText(filePath);
-                        let newText = existingText.replace(this.getTabTabCompletionsRegex(), "");
-                        newText = this.removeOboleteTabTabCompletion(newText);
-                        if (newText !== existingText) {
-                            this.$logger.trace("Remove existing AutoCompletion from file %s.", filePath);
-                            this.$fs.writeFile(filePath, newText);
-                        }
+            }
+            if (doUpdate) {
+                const clientExecutableFileName = (this.$staticConfig.CLIENT_NAME_ALIAS || this.$staticConfig.CLIENT_NAME).toLowerCase();
+                const pathToExecutableFile = path.join(__dirname, `../../../bin/${clientExecutableFileName}.js`);
+                if (this.$fs.exists(filePath)) {
+                    const existingText = this.$fs.readText(filePath);
+                    let newText = existingText.replace(this.getTabTabCompletionsRegex(), "");
+                    newText = this.removeOboleteTabTabCompletion(newText);
+                    if (newText !== existingText) {
+                        this.$logger.trace("Remove existing AutoCompletion from file %s.", filePath);
+                        this.$fs.writeFile(filePath, newText);
                     }
-                    this.$fs.appendFile(filePath, `\n${AutoCompletionService.GENERATED_TABTAB_COMPLETION_START}\n`);
-                    yield this.$childProcess.exec(`"${process.argv[0]}" "${pathToExecutableFile}" completion_generate_script >> "${filePath}"`);
-                    this.$fs.appendFile(filePath, this.completionAliasDefinition);
-                    this.$fs.chmod(filePath, "0644");
                 }
+                this.$fs.appendFile(filePath, `\n${AutoCompletionService.GENERATED_TABTAB_COMPLETION_START}\n`);
+                await this.$childProcess.exec(`"${process.argv[0]}" "${pathToExecutableFile}" completion_generate_script >> "${filePath}"`);
+                this.$fs.appendFile(filePath, this.completionAliasDefinition);
+                this.$fs.chmod(filePath, "0644");
             }
-            catch (err) {
-                this.$logger.info("Failed to update %s. Auto-completion may not work. ", filePath);
-                this.$logger.trace(err);
-                this.scriptsOk = false;
-            }
-        });
+        }
+        catch (err) {
+            this.$logger.info("Failed to update %s. Auto-completion may not work. ", filePath);
+            this.$logger.trace(err);
+            this.scriptsOk = false;
+        }
     }
     getHomePath(fileName) {
         return path.join((0, os_1.homedir)(), fileName);
     }
 }
+exports.AutoCompletionService = AutoCompletionService;
 AutoCompletionService.COMPLETION_START_COMMENT_PATTERN = "###-%s-completion-start-###";
 AutoCompletionService.COMPLETION_END_COMMENT_PATTERN = "###-%s-completion-end-###";
 AutoCompletionService.TABTAB_COMPLETION_START_REGEX_PATTERN = "###-begin-%s-completion-###";
@@ -261,5 +249,4 @@ __decorate([
 __decorate([
     (0, decorators_1.cache)()
 ], AutoCompletionService.prototype, "completionShellScriptContent", null);
-exports.AutoCompletionService = AutoCompletionService;
 yok_1.injector.register("autoCompletionService", AutoCompletionService);

package/lib/common/services/cancellation.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const choki = require("chokidar");
 const path = require("path");
@@ -24,26 +15,24 @@ class CancellationService {
             this.$fs.createDirectory(CancellationService.killSwitchDir);
         }
     }
-    begin(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.$hostInfo.isWindows) {
-                return;
-            }
-            const triggerFile = CancellationService.makeKillSwitchFileName(name);
-            if (!this.$fs.exists(triggerFile)) {
-                this.$fs.writeFile(triggerFile, "");
-            }
-            this.$logger.trace("Starting watch on killswitch %s", triggerFile);
-            const watcher = choki
-                .watch(triggerFile, { ignoreInitial: true })
-                .on("unlink", (filePath) => {
-                this.$logger.info(`Exiting process as the file ${filePath} has been deleted. Probably reinstalling CLI while there's a working instance.`);
-                process.exit(132);
-            });
-            if (watcher) {
-                this.watches[name] = watcher;
-            }
+    async begin(name) {
+        if (!this.$hostInfo.isWindows) {
+            return;
+        }
+        const triggerFile = CancellationService.makeKillSwitchFileName(name);
+        if (!this.$fs.exists(triggerFile)) {
+            this.$fs.writeFile(triggerFile, "");
+        }
+        this.$logger.trace("Starting watch on killswitch %s", triggerFile);
+        const watcher = choki
+            .watch(triggerFile, { ignoreInitial: true })
+            .on("unlink", (filePath) => {
+            this.$logger.info(`Exiting process as the file ${filePath} has been deleted. Probably reinstalling CLI while there's a working instance.`);
+            process.exit(132);
         });
+        if (watcher) {
+            this.watches[name] = watcher;
+        }
     }
     end(name) {
         const watcher = this.watches[name];

package/lib/common/services/commands-service.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandsService = void 0;
 const jaroWinklerDistance = require("../vendor/jaro-winkler_distance");
@@ -40,48 +31,46 @@ class CommandsService {
         const commands = this.$injector.getRegisteredCommandsNames(opts.includeDevCommands);
         return _.reject(commands, (command) => _.includes(command, "|"));
     }
-    executeCommandUnchecked(commandName, commandArguments) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.commands.push({ commandName, commandArguments });
-            const command = this.$injector.resolveCommand(commandName);
-            if (command) {
-                if (!this.$staticConfig.disableAnalytics &&
-                    !command.disableAnalytics &&
-                    !this.$options.disableAnalytics) {
-                    const analyticsService = this.$injector.resolve("analyticsService");
-                    yield analyticsService.checkConsent();
-                    const beautifiedCommandName = this.beautifyCommandName(commandName).replace(/\|/g, " ");
-                    const googleAnalyticsPageData = {
-                        googleAnalyticsDataType: "pageview",
-                        path: beautifiedCommandName,
-                        title: beautifiedCommandName,
-                    };
-                    yield analyticsService.trackInGoogleAnalytics(googleAnalyticsPageData);
-                    yield this.$optionsTracker.trackOptions(this.$options);
-                }
-                const shouldExecuteHooks = !this.$staticConfig.disableCommandHooks &&
-                    (command.enableHooks === undefined || command.enableHooks === true);
-                if (shouldExecuteHooks) {
-                    const hierarchicalCommandName = this.$injector.buildHierarchicalCommand(commandName, commandArguments);
-                    if (hierarchicalCommandName) {
-                        commandName = helpers.stringReplaceAll(hierarchicalCommandName.commandName, "|*", "-");
-                        commandName = helpers.stringReplaceAll(commandName, "|", "-");
-                    }
-                    yield this.$hooksService.executeBeforeHooks(commandName);
-                }
-                yield command.execute(commandArguments);
-                if (command.postCommandAction) {
-                    yield command.postCommandAction(commandArguments);
-                }
-                if (shouldExecuteHooks) {
-                    yield this.$hooksService.executeAfterHooks(commandName);
+    async executeCommandUnchecked(commandName, commandArguments) {
+        this.commands.push({ commandName, commandArguments });
+        const command = this.$injector.resolveCommand(commandName);
+        if (command) {
+            if (!this.$staticConfig.disableAnalytics &&
+                !command.disableAnalytics &&
+                !this.$options.disableAnalytics) {
+                const analyticsService = this.$injector.resolve("analyticsService");
+                await analyticsService.checkConsent();
+                const beautifiedCommandName = this.beautifyCommandName(commandName).replace(/\|/g, " ");
+                const googleAnalyticsPageData = {
+                    googleAnalyticsDataType: "pageview",
+                    path: beautifiedCommandName,
+                    title: beautifiedCommandName,
+                };
+                await analyticsService.trackInGoogleAnalytics(googleAnalyticsPageData);
+                await this.$optionsTracker.trackOptions(this.$options);
+            }
+            const shouldExecuteHooks = !this.$staticConfig.disableCommandHooks &&
+                (command.enableHooks === undefined || command.enableHooks === true);
+            if (shouldExecuteHooks) {
+                const hierarchicalCommandName = this.$injector.buildHierarchicalCommand(commandName, commandArguments);
+                if (hierarchicalCommandName) {
+                    commandName = helpers.stringReplaceAll(hierarchicalCommandName.commandName, "|*", "-");
+                    commandName = helpers.stringReplaceAll(commandName, "|", "-");
                 }
-                this.commands.pop();
-                return true;
+                await this.$hooksService.executeBeforeHooks(commandName);
+            }
+            await command.execute(commandArguments);
+            if (command.postCommandAction) {
+                await command.postCommandAction(commandArguments);
+            }
+            if (shouldExecuteHooks) {
+                await this.$hooksService.executeAfterHooks(commandName);
             }
             this.commands.pop();
-            return false;
-        });
+            return true;
+        }
+        this.commands.pop();
+        return false;
     }
     printHelpSuggestion(commandName) {
         const command = commandName
@@ -91,145 +80,133 @@ class CommandsService {
         this.$logger.printMarkdown(`__Run \`${commandHelp}\` for more information.__`);
         return;
     }
-    executeCommandAction(commandName, commandArguments, action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.$errors.beginCommand(() => action.apply(this, [commandName, commandArguments]), () => this.printHelpSuggestion(commandName));
-        });
+    async executeCommandAction(commandName, commandArguments, action) {
+        return this.$errors.beginCommand(() => action.apply(this, [commandName, commandArguments]), () => this.printHelpSuggestion(commandName));
     }
-    tryExecuteCommandAction(commandName, commandArguments) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const command = this.$injector.resolveCommand(commandName);
-            if (!command || !command.isHierarchicalCommand) {
-                const dashedOptions = command ? command.dashedOptions : null;
-                this.$options.validateOptions(dashedOptions);
-            }
-            return this.canExecuteCommand(commandName, commandArguments);
-        });
-    }
-    tryExecuteCommand(commandName, commandArguments) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const canExecuteResult = yield this.executeCommandAction(commandName, commandArguments, this.tryExecuteCommandAction);
-            const canExecute = typeof canExecuteResult === "object"
-                ? canExecuteResult.canExecute
-                : canExecuteResult;
-            if (canExecute) {
-                yield this.executeCommandAction(commandName, commandArguments, this.executeCommandUnchecked);
-            }
-            else {
-                const command = this.$injector.resolveCommand(commandName);
-                if (command) {
-                    let commandWithArgs = commandName;
-                    if (commandArguments && commandArguments.length) {
-                        commandWithArgs += ` ${commandArguments.join(" ")}`;
-                    }
-                    this.$logger.error(`Command '${commandWithArgs}' cannot be executed.`);
-                    yield this.printHelpSuggestion(commandName);
-                }
-            }
-        });
+    async tryExecuteCommandAction(commandName, commandArguments) {
+        const command = this.$injector.resolveCommand(commandName);
+        if (!command || !command.isHierarchicalCommand) {
+            const dashedOptions = command ? command.dashedOptions : null;
+            this.$options.validateOptions(dashedOptions);
+        }
+        return this.canExecuteCommand(commandName, commandArguments);
     }
-    canExecuteCommand(commandName, commandArguments, isDynamicCommand) {
-        return __awaiter(this, void 0, void 0, function* () {
+    async tryExecuteCommand(commandName, commandArguments) {
+        const canExecuteResult = await this.executeCommandAction(commandName, commandArguments, this.tryExecuteCommandAction);
+        const canExecute = typeof canExecuteResult === "object"
+            ? canExecuteResult.canExecute
+            : canExecuteResult;
+        if (canExecute) {
+            await this.executeCommandAction(commandName, commandArguments, this.executeCommandUnchecked);
+        }
+        else {
             const command = this.$injector.resolveCommand(commandName);
-            const beautifiedName = helpers.stringReplaceAll(commandName, "|", " ");
             if (command) {
-                if (command.isDisabled) {
-                    this.$errors.fail("This command is not applicable to your environment.");
-                }
-                if (command.canExecute) {
-                    return yield command.canExecute(commandArguments);
-                }
-                if (yield this.$injector.isValidHierarchicalCommand(commandName, commandArguments)) {
-                    return true;
+                let commandWithArgs = commandName;
+                if (commandArguments && commandArguments.length) {
+                    commandWithArgs += ` ${commandArguments.join(" ")}`;
                 }
-                if (yield this.validateCommandArguments(command, commandArguments)) {
-                    return true;
-                }
-                this.$errors.fail(`Unable to execute command '${beautifiedName}'.`);
-                return false;
+                this.$logger.error(`Command '${commandWithArgs}' cannot be executed.`);
+                await this.printHelpSuggestion(commandName);
             }
-            const commandInfo = {
-                inputStrings: [commandName, ...commandArguments],
-                commandDelimiter: "|",
-                defaultCommandDelimiter: "|*",
-            };
-            const extensionData = yield this.$extensibilityService.getExtensionNameWhereCommandIsRegistered(commandInfo);
-            if (extensionData) {
-                this.$logger.warn(extensionData.installationMessage);
+        }
+    }
+    async canExecuteCommand(commandName, commandArguments, isDynamicCommand) {
+        const command = this.$injector.resolveCommand(commandName);
+        const beautifiedName = helpers.stringReplaceAll(commandName, "|", " ");
+        if (command) {
+            if (command.isDisabled) {
+                this.$errors.fail("This command is not applicable to your environment.");
             }
-            else {
-                this.$logger.error("Unknown command '%s'.", beautifiedName);
-                yield this.printHelpSuggestion();
-                this.tryMatchCommand(commandName);
+            if (command.canExecute) {
+                return await command.canExecute(commandArguments);
             }
+            if (await this.$injector.isValidHierarchicalCommand(commandName, commandArguments)) {
+                return true;
+            }
+            if (await this.validateCommandArguments(command, commandArguments)) {
+                return true;
+            }
+            this.$errors.fail(`Unable to execute command '${beautifiedName}'.`);
             return false;
-        });
+        }
+        const commandInfo = {
+            inputStrings: [commandName, ...commandArguments],
+            commandDelimiter: "|",
+            defaultCommandDelimiter: "|*",
+        };
+        const extensionData = await this.$extensibilityService.getExtensionNameWhereCommandIsRegistered(commandInfo);
+        if (extensionData) {
+            this.$logger.warn(extensionData.installationMessage);
+        }
+        else {
+            this.$logger.error("Unknown command '%s'.", beautifiedName);
+            await this.printHelpSuggestion();
+            this.tryMatchCommand(commandName);
+        }
+        return false;
     }
-    validateMandatoryParams(commandArguments, mandatoryParams) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const commandArgsHelper = new CommandArgumentsValidationHelper(true, commandArguments);
-            if (mandatoryParams.length > 0) {
-                if (mandatoryParams.length > commandArguments.length) {
-                    const customErrorMessages = _.map(mandatoryParams, (mp) => mp.errorMessage);
-                    customErrorMessages.splice(0, 0, "You need to provide all the required parameters.");
-                    this.$errors.failWithHelp(customErrorMessages.join(os_1.EOL));
-                }
-                for (let mandatoryParamIndex = 0; mandatoryParamIndex < mandatoryParams.length; ++mandatoryParamIndex) {
-                    const mandatoryParam = mandatoryParams[mandatoryParamIndex];
-                    let argument = null;
-                    for (let remainingArgsIndex = 0; remainingArgsIndex < commandArgsHelper.remainingArguments.length; ++remainingArgsIndex) {
-                        const c = commandArgsHelper.remainingArguments[remainingArgsIndex];
-                        if (yield mandatoryParam.validate(c)) {
-                            argument = c;
-                            break;
-                        }
-                    }
-                    if (argument) {
-                        helpers.remove(commandArgsHelper.remainingArguments, (arg) => arg === argument);
-                    }
-                    else {
-                        this.$errors.failWithHelp("Missing mandatory parameter.");
+    async validateMandatoryParams(commandArguments, mandatoryParams) {
+        const commandArgsHelper = new CommandArgumentsValidationHelper(true, commandArguments);
+        if (mandatoryParams.length > 0) {
+            if (mandatoryParams.length > commandArguments.length) {
+                const customErrorMessages = _.map(mandatoryParams, (mp) => mp.errorMessage);
+                customErrorMessages.splice(0, 0, "You need to provide all the required parameters.");
+                this.$errors.failWithHelp(customErrorMessages.join(os_1.EOL));
+            }
+            for (let mandatoryParamIndex = 0; mandatoryParamIndex < mandatoryParams.length; ++mandatoryParamIndex) {
+                const mandatoryParam = mandatoryParams[mandatoryParamIndex];
+                let argument = null;
+                for (let remainingArgsIndex = 0; remainingArgsIndex < commandArgsHelper.remainingArguments.length; ++remainingArgsIndex) {
+                    const c = commandArgsHelper.remainingArguments[remainingArgsIndex];
+                    if (await mandatoryParam.validate(c)) {
+                        argument = c;
+                        break;
                     }
                 }
+                if (argument) {
+                    helpers.remove(commandArgsHelper.remainingArguments, (arg) => arg === argument);
+                }
+                else {
+                    this.$errors.failWithHelp("Missing mandatory parameter.");
+                }
             }
-            return commandArgsHelper;
-        });
+        }
+        return commandArgsHelper;
     }
-    validateCommandArguments(command, commandArguments) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const mandatoryParams = _.filter(command.allowedParameters, (param) => param.mandatory);
-            const commandArgsHelper = yield this.validateMandatoryParams(commandArguments, mandatoryParams);
-            if (!commandArgsHelper.isValid) {
-                return false;
-            }
-            if (!command.allowedParameters || command.allowedParameters.length === 0) {
-                if (commandArguments.length > 0) {
-                    this.$errors.failWithHelp("This command doesn't accept parameters.");
-                }
+    async validateCommandArguments(command, commandArguments) {
+        const mandatoryParams = _.filter(command.allowedParameters, (param) => param.mandatory);
+        const commandArgsHelper = await this.validateMandatoryParams(commandArguments, mandatoryParams);
+        if (!commandArgsHelper.isValid) {
+            return false;
+        }
+        if (!command.allowedParameters || command.allowedParameters.length === 0) {
+            if (commandArguments.length > 0) {
+                this.$errors.failWithHelp("This command doesn't accept parameters.");
             }
-            else {
-                const unverifiedAllowedParams = command.allowedParameters.filter((param) => !param.mandatory);
-                for (let remainingArgsIndex = 0; remainingArgsIndex < commandArgsHelper.remainingArguments.length; ++remainingArgsIndex) {
-                    const argument = commandArgsHelper.remainingArguments[remainingArgsIndex];
-                    let parameter = null;
-                    for (let unverifiedIndex = 0; unverifiedIndex < unverifiedAllowedParams.length; ++unverifiedIndex) {
-                        const c = unverifiedAllowedParams[unverifiedIndex];
-                        if (yield c.validate(argument)) {
-                            parameter = c;
-                            break;
-                        }
-                    }
-                    if (parameter) {
-                        const index = unverifiedAllowedParams.indexOf(parameter);
-                        unverifiedAllowedParams.splice(index, 1);
-                    }
-                    else {
-                        this.$errors.failWithHelp(`The parameter ${argument} is not valid for this command.`);
+        }
+        else {
+            const unverifiedAllowedParams = command.allowedParameters.filter((param) => !param.mandatory);
+            for (let remainingArgsIndex = 0; remainingArgsIndex < commandArgsHelper.remainingArguments.length; ++remainingArgsIndex) {
+                const argument = commandArgsHelper.remainingArguments[remainingArgsIndex];
+                let parameter = null;
+                for (let unverifiedIndex = 0; unverifiedIndex < unverifiedAllowedParams.length; ++unverifiedIndex) {
+                    const c = unverifiedAllowedParams[unverifiedIndex];
+                    if (await c.validate(argument)) {
+                        parameter = c;
+                        break;
                     }
                 }
+                if (parameter) {
+                    const index = unverifiedAllowedParams.indexOf(parameter);
+                    unverifiedAllowedParams.splice(index, 1);
+                }
+                else {
+                    this.$errors.failWithHelp(`The parameter ${argument} is not valid for this command.`);
+                }
             }
-            return true;
-        });
+        }
+        return true;
     }
     tryMatchCommand(commandName) {
         const allCommands = this.allCommands({ includeDevCommands: false });