@akylas/nativescript-cli 8.7.2

package/lib/common/bin/common-lib.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+"use strict";
+
+require("../common-lib");

package/lib/common/bootstrap.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const yok_1 = require("./yok");
+const _ = require("lodash");
+global._ = _;
+global.$injector = yok_1.injector;
+yok_1.injector.require("errors", "./errors");
+yok_1.injector.requirePublic("fs", "./file-system");
+yok_1.injector.require("hostInfo", "./host-info");
+yok_1.injector.require("osInfo", "./os-info");
+yok_1.injector.require("dispatcher", "./dispatchers");
+yok_1.injector.require("commandDispatcher", "./dispatchers");
+yok_1.injector.require("resources", "./resource-loader");
+yok_1.injector.require("stringParameter", "./command-params");
+yok_1.injector.require("stringParameterBuilder", "./command-params");
+yok_1.injector.require("commandsService", "./services/commands-service");
+yok_1.injector.require("messagesService", "./services/messages-service");
+yok_1.injector.require("cancellation", "./services/cancellation");
+yok_1.injector.require("hooksService", "./services/hooks-service");
+yok_1.injector.require("httpClient", "./http-client");
+yok_1.injector.require("childProcess", "./child-process");
+yok_1.injector.require("prompter", "./prompter");
+yok_1.injector.require("projectHelper", "./project-helper");
+yok_1.injector.require("pluginVariablesHelper", "./plugin-variables-helper");
+yok_1.injector.requireCommand(["help", "/?"], "./commands/help");
+yok_1.injector.requireCommand("usage-reporting", "./commands/analytics");
+yok_1.injector.requireCommand("error-reporting", "./commands/analytics");
+yok_1.injector.requireCommand("dev-post-install", "./commands/post-install");
+yok_1.injector.requireCommand("autocomplete|*default", "./commands/autocompletion");
+yok_1.injector.requireCommand("autocomplete|enable", "./commands/autocompletion");
+yok_1.injector.requireCommand("autocomplete|disable", "./commands/autocompletion");
+yok_1.injector.requireCommand("autocomplete|status", "./commands/autocompletion");
+yok_1.injector.requireCommand(["device|*list", "devices|*list"], "./commands/device/list-devices");
+yok_1.injector.requireCommand(["device|android", "devices|android"], "./commands/device/list-devices");
+yok_1.injector.requireCommand(["device|ios", "devices|ios"], "./commands/device/list-devices");
+yok_1.injector.requireCommand("device|log", "./commands/device/device-log-stream");
+yok_1.injector.requireCommand("device|run", "./commands/device/run-application");
+yok_1.injector.requireCommand("device|stop", "./commands/device/stop-application");
+yok_1.injector.requireCommand("device|list-applications", "./commands/device/list-applications");
+yok_1.injector.requireCommand("device|uninstall", "./commands/device/uninstall-application");
+yok_1.injector.requireCommand("device|list-files", "./commands/device/list-files");
+yok_1.injector.requireCommand("device|get-file", "./commands/device/get-file");
+yok_1.injector.requireCommand("device|put-file", "./commands/device/put-file");
+yok_1.injector.require("iosDeviceOperations", "./mobile/ios/device/ios-device-operations");
+yok_1.injector.require("deviceDiscovery", "./mobile/mobile-core/device-discovery");
+yok_1.injector.require("iOSDeviceDiscovery", "./mobile/mobile-core/ios-device-discovery");
+yok_1.injector.require("iOSSimulatorDiscovery", "./mobile/mobile-core/ios-simulator-discovery");
+yok_1.injector.require("androidDeviceDiscovery", "./mobile/mobile-core/android-device-discovery");
+yok_1.injector.require("androidEmulatorDiscovery", "./mobile/mobile-core/android-emulator-discovery");
+yok_1.injector.require("iOSDevice", "./mobile/ios/device/ios-device");
+yok_1.injector.require("iOSDeviceProductNameMapper", "./mobile/ios/ios-device-product-name-mapper");
+yok_1.injector.require("androidDevice", "./mobile/android/android-device");
+yok_1.injector.require("adb", "./mobile/android/android-debug-bridge");
+yok_1.injector.require("androidDebugBridgeResultHandler", "./mobile/android/android-debug-bridge-result-handler");
+yok_1.injector.require("androidVirtualDeviceService", "./mobile/android/android-virtual-device-service");
+yok_1.injector.require("androidIniFileParser", "./mobile/android/android-ini-file-parser");
+yok_1.injector.require("androidGenymotionService", "./mobile/android/genymotion/genymotion-service");
+yok_1.injector.require("virtualBoxService", "./mobile/android/genymotion/virtualbox-service");
+yok_1.injector.require("logcatHelper", "./mobile/android/logcat-helper");
+yok_1.injector.require("iOSSimResolver", "./mobile/ios/simulator/ios-sim-resolver");
+yok_1.injector.require("iOSSimulatorLogProvider", "./mobile/ios/simulator/ios-simulator-log-provider");
+yok_1.injector.require("localToDevicePathDataFactory", "./mobile/local-to-device-path-data-factory");
+yok_1.injector.requirePublic("devicesService", "./mobile/mobile-core/devices-service");
+yok_1.injector.requirePublic("androidProcessService", "./mobile/mobile-core/android-process-service");
+yok_1.injector.require("projectNameValidator", "./validators/project-name-validator");
+yok_1.injector.require("androidEmulatorServices", "./mobile/android/android-emulator-services");
+yok_1.injector.require("iOSEmulatorServices", "./mobile/ios/simulator/ios-emulator-services");
+yok_1.injector.require("wp8EmulatorServices", "./mobile/wp8/wp8-emulator-services");
+yok_1.injector.require("autoCompletionService", "./services/auto-completion-service");
+yok_1.injector.requirePublic("settingsService", "./services/settings-service");
+yok_1.injector.require("opener", "./opener");
+yok_1.injector.require("microTemplateService", "./services/micro-templating-service");
+yok_1.injector.require("mobileHelper", "./mobile/mobile-helper");
+yok_1.injector.require("emulatorHelper", "./mobile/emulator-helper");
+yok_1.injector.require("devicePlatformsConstants", "./mobile/device-platforms-constants");
+yok_1.injector.require("helpService", "./services/help-service");
+yok_1.injector.require("messageContractGenerator", "./services/message-contract-generator");
+yok_1.injector.require("proxyService", "./services/proxy-service");
+yok_1.injector.requireCommand("dev-preuninstall", "./commands/preuninstall");
+yok_1.injector.requireCommand("dev-generate-messages", "./commands/generate-messages");
+yok_1.injector.requireCommand("doctor|*all", "./commands/doctor");
+yok_1.injector.requireCommand("doctor|ios", "./commands/doctor");
+yok_1.injector.requireCommand("doctor|android", "./commands/doctor");
+yok_1.injector.requireCommand("proxy|*get", "./commands/proxy/proxy-get");
+yok_1.injector.requireCommand("proxy|set", "./commands/proxy/proxy-set");
+yok_1.injector.requireCommand("proxy|clear", "./commands/proxy/proxy-clear");
+yok_1.injector.require("utils", "./utils");
+yok_1.injector.require("plistParser", "./plist-parser");
+yok_1.injector.require("winreg", "./winreg");
+yok_1.injector.require("loggingLevels", "./mobile/logging-levels");
+yok_1.injector.require("logFilter", "./mobile/log-filter");
+yok_1.injector.require("androidLogFilter", "./mobile/android/android-log-filter");
+yok_1.injector.require("projectFilesManager", "./services/project-files-manager");
+yok_1.injector.require("xcodeSelectService", "./services/xcode-select-service");
+yok_1.injector.require("net", "./services/net-service");
+yok_1.injector.require("qr", "./services/qr");
+yok_1.injector.require(["lockfile", "lockService"], "./services/lock-service");

package/lib/common/child-process.js

@@ -0,0 +1,217 @@
+"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.ChildProcess = void 0;
+const child_process = require("child_process");
+const path_1 = require("path");
+const events_1 = require("events");
+const yok_1 = require("./yok");
+class ChildProcess extends events_1.EventEmitter {
+    constructor($logger, $errors) {
+        super();
+        this.$logger = $logger;
+        this.$errors = $errors;
+    }
+    exec(command, options, execOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const callback = (error, stdout, stderr) => {
+                    this.$logger.trace("Exec %s \n stdout: %s \n stderr: %s", command, stdout.toString(), stderr.toString());
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        const output = execOptions && execOptions.showStderr ? { stdout, stderr } : stdout;
+                        resolve(output);
+                    }
+                };
+                if (options) {
+                    child_process.exec(command, options, callback);
+                }
+                else {
+                    child_process.exec(command, callback);
+                }
+            });
+        });
+    }
+    execFile(command, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.trace("execFile: %s %s", command, this.getArgumentsAsQuotedString(args));
+            return new Promise((resolve, reject) => {
+                child_process.execFile(command, args, (error, stdout) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve(stdout);
+                    }
+                });
+            });
+        });
+    }
+    spawn(command, args, options) {
+        var _a;
+        if (command.charAt(0) === ".") {
+            const cwd = (_a = options === null || options === void 0 ? void 0 : options.cwd) !== null && _a !== void 0 ? _a : process.cwd();
+            command = (0, path_1.resolve)(cwd, command);
+        }
+        this.$logger.trace("spawn: %s %s", command, this.getArgumentsAsQuotedString(args));
+        return child_process.spawn(command, args, options);
+    }
+    fork(modulePath, args, options) {
+        this.$logger.trace("fork: %s %s", modulePath, this.getArgumentsAsQuotedString(args));
+        return child_process.fork(modulePath, args, options);
+    }
+    spawnFromEvent(command, args, event, options, spawnFromEventOptions) {
+        return new Promise((resolve, reject) => {
+            const childProcess = this.spawn(command, args, options);
+            let isResolved = false;
+            let capturedOut = "";
+            let capturedErr = "";
+            let killTimer = null;
+            if (spawnFromEventOptions && spawnFromEventOptions.timeout) {
+                this.$logger.trace(`Setting maximum time for execution of current child process to ${spawnFromEventOptions.timeout}`);
+                killTimer = setTimeout(() => {
+                    this.$logger.trace(`Sending SIGTERM to current child process as maximum time for execution ${spawnFromEventOptions.timeout} had passed.`);
+                    childProcess.kill("SIGTERM");
+                }, spawnFromEventOptions.timeout);
+            }
+            if (childProcess.stdout) {
+                childProcess.stdout.on("data", (data) => {
+                    if (spawnFromEventOptions &&
+                        spawnFromEventOptions.emitOptions &&
+                        spawnFromEventOptions.emitOptions.eventName) {
+                        this.emit(spawnFromEventOptions.emitOptions.eventName, {
+                            data,
+                            pipe: "stdout",
+                        });
+                    }
+                    capturedOut += data;
+                });
+            }
+            if (childProcess.stderr) {
+                childProcess.stderr.on("data", (data) => {
+                    if (spawnFromEventOptions &&
+                        spawnFromEventOptions.emitOptions &&
+                        spawnFromEventOptions.emitOptions.eventName) {
+                        this.emit(spawnFromEventOptions.emitOptions.eventName, {
+                            data,
+                            pipe: "stderr",
+                        });
+                    }
+                    capturedErr += data;
+                });
+            }
+            childProcess.on(event, (arg) => {
+                const exitCode = typeof arg === "number" ? arg : arg && arg.code;
+                const result = {
+                    stdout: capturedOut,
+                    stderr: capturedErr,
+                    exitCode: exitCode,
+                };
+                const clearKillTimer = () => {
+                    if (killTimer) {
+                        clearTimeout(killTimer);
+                    }
+                };
+                const resolveAction = () => {
+                    isResolved = true;
+                    resolve(result);
+                    clearKillTimer();
+                };
+                if (spawnFromEventOptions &&
+                    spawnFromEventOptions.throwError === false) {
+                    if (!isResolved) {
+                        this.$logger.trace("Result when throw error is false:");
+                        this.$logger.trace(result);
+                        resolveAction();
+                    }
+                }
+                else {
+                    if (exitCode === 0) {
+                        resolveAction();
+                    }
+                    else {
+                        let errorMessage = `Command ${command} failed with exit code ${exitCode}`;
+                        if (capturedErr) {
+                            errorMessage += ` Error output: \n ${capturedErr}`;
+                        }
+                        if (!isResolved) {
+                            isResolved = true;
+                            reject(new Error(errorMessage));
+                            clearKillTimer();
+                        }
+                    }
+                }
+            });
+            childProcess.once("error", (err) => {
+                if (!isResolved) {
+                    if (spawnFromEventOptions &&
+                        spawnFromEventOptions.throwError === false) {
+                        const result = {
+                            stdout: capturedOut,
+                            stderr: err.message,
+                            exitCode: err.code,
+                        };
+                        isResolved = true;
+                        resolve(result);
+                    }
+                    else {
+                        isResolved = true;
+                        reject(err);
+                    }
+                }
+            });
+        });
+    }
+    trySpawnFromCloseEvent(command, args, options, spawnFromEventOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const childProcessResult = yield this.spawnFromEvent(command, args, "close", options, spawnFromEventOptions);
+                return childProcessResult;
+            }
+            catch (err) {
+                this.$logger.trace(`Error from trySpawnFromCloseEvent method. More info: ${err}`);
+                return Promise.resolve({
+                    stderr: err && err.message ? err.message : err,
+                    stdout: null,
+                    exitCode: -1,
+                });
+            }
+        });
+    }
+    tryExecuteApplication(command, args, event, errorMessage, condition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const childProcess = yield this.tryExecuteApplicationCore(command, args, event, errorMessage);
+            if (condition && condition(childProcess)) {
+                this.$errors.fail(errorMessage);
+            }
+        });
+    }
+    tryExecuteApplicationCore(command, args, event, errorMessage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return this.spawnFromEvent(command, args, event, undefined, {
+                    throwError: false,
+                });
+            }
+            catch (e) {
+                const message = e.code === "ENOENT" ? errorMessage : e.message;
+                this.$errors.fail(message);
+            }
+        });
+    }
+    getArgumentsAsQuotedString(args) {
+        return (args && args.length && args.map((argument) => `"${argument}"`).join(" "));
+    }
+}
+exports.ChildProcess = ChildProcess;
+yok_1.injector.register("childProcess", ChildProcess);

package/lib/common/codeGeneration/code-entity.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Block = exports.Line = exports.CodeEntityType = void 0;
+const _ = require("lodash");
+const yok_1 = require("../yok");
+var CodeEntityType;
+(function (CodeEntityType) {
+    CodeEntityType[CodeEntityType["Line"] = 0] = "Line";
+    CodeEntityType[CodeEntityType["Block"] = 1] = "Block";
+})(CodeEntityType = exports.CodeEntityType || (exports.CodeEntityType = {}));
+class Line {
+    constructor(content) {
+        this.content = content;
+    }
+    get codeEntityType() {
+        return CodeEntityType.Line;
+    }
+    static create(content) {
+        return new Line(content);
+    }
+}
+exports.Line = Line;
+yok_1.injector.register("swaggerLine", Line);
+class Block {
+    constructor(opener) {
+        this.opener = opener;
+        this.codeEntities = [];
+    }
+    get codeEntityType() {
+        return CodeEntityType.Block;
+    }
+    addBlock(block) {
+        this.codeEntities.push(block);
+    }
+    addLine(line) {
+        this.codeEntities.push(line);
+    }
+    addBlocks(blocks) {
+        _.each(blocks, (block) => this.addBlock(block));
+    }
+    writeLine(content) {
+        const line = Line.create(content);
+        this.codeEntities.push(line);
+    }
+}
+exports.Block = Block;
+yok_1.injector.register("swaggerBlock", Block);

package/lib/common/codeGeneration/code-generation.d.ts

@@ -0,0 +1,47 @@
+import { IDictionary } from "../declarations";
+
+declare module CodeGeneration {
+	interface IModel {
+		id: string;
+		properties: IDictionary<IModelProperty>;
+	}
+
+	interface IModelProperty {
+		type: string;
+		items: IModelPropertyItems;
+		allowableValues: IModelPropertyValue;
+	}
+
+	interface IModelPropertyItems {
+		$ref: string;
+	}
+
+	interface IModelPropertyValue {
+		valueType: string;
+		values: string[];
+	}
+
+	interface ICodeEntity {
+		opener?: string;
+		codeEntityType: any;
+	}
+
+	interface ILine extends ICodeEntity {
+		content: string;
+	}
+
+	interface IBlock extends ICodeEntity {
+		opener: string;
+		codeEntities: ICodeEntity[];
+		writeLine(content: string): void;
+		addLine(line: ILine): void;
+		addBlock(block: IBlock): void;
+		addBlocks(blocks: IBlock[]): void;
+		endingCharacter?: string;
+	}
+
+	interface IService {
+		serviceInterface: IBlock;
+		serviceImplementation: IBlock;
+	}
+}

package/lib/common/codeGeneration/code-printer.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodePrinter = void 0;
+const _ = require("lodash");
+const os_1 = require("os");
+const code_entity_1 = require("./code-entity");
+const yok_1 = require("../yok");
+class CodePrinter {
+    composeBlock(block, indentSize) {
+        indentSize = indentSize === undefined ? 0 : indentSize;
+        let content = this.getIndentation(indentSize);
+        if (block.opener) {
+            content += block.opener;
+            content += CodePrinter.START_BLOCK_CHAR;
+            content += CodePrinter.NEW_LINE_CHAR;
+        }
+        _.each(block.codeEntities, (codeEntity) => {
+            if (codeEntity.codeEntityType === code_entity_1.CodeEntityType.Line) {
+                content += this.composeLine(codeEntity, indentSize + 1);
+            }
+            else if (codeEntity.codeEntityType === code_entity_1.CodeEntityType.Block) {
+                content += this.composeBlock(codeEntity, indentSize + 1);
+            }
+        });
+        if (block.opener) {
+            content += this.getIndentation(indentSize);
+            content += CodePrinter.END_BLOCK_CHAR;
+            content += block.endingCharacter || "";
+            content += CodePrinter.NEW_LINE_CHAR;
+        }
+        return content;
+    }
+    getIndentation(indentSize) {
+        return Array(indentSize).join(CodePrinter.INDENT_CHAR);
+    }
+    composeLine(line, indentSize) {
+        let content = this.getIndentation(indentSize);
+        content += line.content;
+        content += CodePrinter.NEW_LINE_CHAR;
+        return content;
+    }
+}
+CodePrinter.INDENT_CHAR = "\t";
+CodePrinter.NEW_LINE_CHAR = os_1.EOL;
+CodePrinter.START_BLOCK_CHAR = " {";
+CodePrinter.END_BLOCK_CHAR = "}";
+exports.CodePrinter = CodePrinter;
+yok_1.injector.register("swaggerCodePrinter", CodePrinter);

package/lib/common/command-params.js

@@ -0,0 +1,45 @@
+"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.StringParameterBuilder = exports.StringCommandParameter = void 0;
+const yok_1 = require("./yok");
+class StringCommandParameter {
+    constructor($injector) {
+        this.$injector = $injector;
+        this.mandatory = false;
+    }
+    validate(validationValue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!validationValue) {
+                if (this.errorMessage) {
+                    this.$injector.resolve("errors").fail(this.errorMessage);
+                }
+                return false;
+            }
+            return true;
+        });
+    }
+}
+exports.StringCommandParameter = StringCommandParameter;
+yok_1.injector.register("stringParameter", StringCommandParameter);
+class StringParameterBuilder {
+    constructor($injector) {
+        this.$injector = $injector;
+    }
+    createMandatoryParameter(errorMsg) {
+        const commandParameter = new StringCommandParameter(this.$injector);
+        commandParameter.mandatory = true;
+        commandParameter.errorMessage = errorMsg;
+        return commandParameter;
+    }
+}
+exports.StringParameterBuilder = StringParameterBuilder;
+yok_1.injector.register("stringParameterBuilder", StringParameterBuilder);

package/lib/common/commands/analytics.js

@@ -0,0 +1,81 @@
+"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.ErrorReportingCommand = exports.UsageReportingCommand = exports.AnalyticsCommandParameter = void 0;
+const yok_1 = require("../yok");
+class AnalyticsCommandParameter {
+    constructor($errors) {
+        this.$errors = $errors;
+        this.mandatory = false;
+    }
+    validate(validationValue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const val = validationValue || "";
+            switch (val.toLowerCase()) {
+                case "enable":
+                case "disable":
+                case "status":
+                case "":
+                    return true;
+                default:
+                    this.$errors.failWithHelp(`The value '${validationValue}' is not valid. Valid values are 'enable', 'disable' and 'status'.`);
+            }
+        });
+    }
+}
+exports.AnalyticsCommandParameter = AnalyticsCommandParameter;
+class AnalyticsCommand {
+    constructor($analyticsService, $logger, $errors, $options, settingName, humanReadableSettingName) {
+        this.$analyticsService = $analyticsService;
+        this.$logger = $logger;
+        this.$errors = $errors;
+        this.$options = $options;
+        this.settingName = settingName;
+        this.humanReadableSettingName = humanReadableSettingName;
+        this.allowedParameters = [new AnalyticsCommandParameter(this.$errors)];
+        this.disableAnalytics = true;
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const arg = args[0] || "";
+            switch (arg.toLowerCase()) {
+                case "enable":
+                    yield this.$analyticsService.setStatus(this.settingName, true);
+                    this.$logger.info(`${this.humanReadableSettingName} is now enabled.`);
+                    break;
+                case "disable":
+                    yield this.$analyticsService.setStatus(this.settingName, false);
+                    this.$logger.info(`${this.humanReadableSettingName} is now disabled.`);
+                    break;
+                case "status":
+                case "":
+                    this.$logger.info(yield this.$analyticsService.getStatusMessage(this.settingName, this.$options.json, this.humanReadableSettingName));
+                    break;
+            }
+        });
+    }
+}
+class UsageReportingCommand extends AnalyticsCommand {
+    constructor($analyticsService, $logger, $errors, $options, $staticConfig) {
+        super($analyticsService, $logger, $errors, $options, $staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME, "Usage reporting");
+        this.$analyticsService = $analyticsService;
+    }
+}
+exports.UsageReportingCommand = UsageReportingCommand;
+yok_1.injector.registerCommand("usage-reporting", UsageReportingCommand);
+class ErrorReportingCommand extends AnalyticsCommand {
+    constructor($analyticsService, $logger, $errors, $options, $staticConfig) {
+        super($analyticsService, $logger, $errors, $options, $staticConfig.ERROR_REPORT_SETTING_NAME, "Error reporting");
+        this.$analyticsService = $analyticsService;
+    }
+}
+exports.ErrorReportingCommand = ErrorReportingCommand;
+yok_1.injector.registerCommand("error-reporting", ErrorReportingCommand);