@akylas/nativescript-cli 8.7.2

package/lib/common/commands/doctor.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoctorAndroidCommand = exports.DoctorIosCommand = exports.DoctorCommand = void 0;
+const yok_1 = require("../yok");
+class DoctorCommand {
+    constructor($doctorService, $projectHelper) {
+        this.$doctorService = $doctorService;
+        this.$projectHelper = $projectHelper;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return this.$doctorService.printWarnings({
+            trackResult: false,
+            projectDir: this.$projectHelper.projectDir,
+            forceCheck: true,
+        });
+    }
+}
+exports.DoctorCommand = DoctorCommand;
+yok_1.injector.registerCommand("doctor|*all", DoctorCommand);
+class DoctorIosCommand {
+    constructor($doctorService, $projectHelper) {
+        this.$doctorService = $doctorService;
+        this.$projectHelper = $projectHelper;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return this.$doctorService.printWarnings({
+            trackResult: false,
+            projectDir: this.$projectHelper.projectDir,
+            forceCheck: true,
+            platform: "ios",
+        });
+    }
+}
+exports.DoctorIosCommand = DoctorIosCommand;
+yok_1.injector.registerCommand("doctor|ios", DoctorIosCommand);
+class DoctorAndroidCommand {
+    constructor($doctorService, $projectHelper) {
+        this.$doctorService = $doctorService;
+        this.$projectHelper = $projectHelper;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return this.$doctorService.printWarnings({
+            trackResult: false,
+            projectDir: this.$projectHelper.projectDir,
+            forceCheck: true,
+            platform: "android",
+        });
+    }
+}
+exports.DoctorAndroidCommand = DoctorAndroidCommand;
+yok_1.injector.registerCommand("doctor|android", DoctorAndroidCommand);

package/lib/common/commands/generate-messages.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.GenerateMessages = void 0;
+const path = require("path");
+const yok_1 = require("../yok");
+class GenerateMessages {
+    constructor($fs, $messageContractGenerator, $options) {
+        this.$fs = $fs;
+        this.$messageContractGenerator = $messageContractGenerator;
+        this.$options = $options;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.$messageContractGenerator.generate();
+            const innerMessagesDirectory = path.join(__dirname, "../messages");
+            const outerMessagesDirectory = path.join(__dirname, "../..");
+            let interfaceFilePath;
+            let implementationFilePath;
+            if (this.$options.default) {
+                interfaceFilePath = path.join(innerMessagesDirectory, GenerateMessages.MESSAGES_DEFINITIONS_FILE_NAME);
+                implementationFilePath = path.join(innerMessagesDirectory, GenerateMessages.MESSAGES_IMPLEMENTATION_FILE_NAME);
+            }
+            else {
+                interfaceFilePath = path.join(outerMessagesDirectory, GenerateMessages.MESSAGES_DEFINITIONS_FILE_NAME);
+                implementationFilePath = path.join(outerMessagesDirectory, GenerateMessages.MESSAGES_IMPLEMENTATION_FILE_NAME);
+            }
+            this.$fs.writeFile(interfaceFilePath, result.interfaceFile);
+            this.$fs.writeFile(implementationFilePath, result.implementationFile);
+        });
+    }
+}
+GenerateMessages.MESSAGES_DEFINITIONS_FILE_NAME = "messages.interface.d.ts";
+GenerateMessages.MESSAGES_IMPLEMENTATION_FILE_NAME = "messages.ts";
+exports.GenerateMessages = GenerateMessages;
+yok_1.injector.registerCommand("dev-generate-messages", GenerateMessages);

package/lib/common/commands/help.js

@@ -0,0 +1,51 @@
+"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.HelpCommand = void 0;
+const _ = require("lodash");
+const yok_1 = require("../yok");
+class HelpCommand {
+    constructor($injector, $helpService, $options) {
+        this.$injector = $injector;
+        this.$helpService = $helpService;
+        this.$options = $options;
+        this.enableHooks = false;
+        this.allowedParameters = [];
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let commandName = (args[0] || "").toLowerCase();
+            let commandArguments = _.tail(args);
+            const hierarchicalCommand = this.$injector.buildHierarchicalCommand(args[0], commandArguments);
+            if (hierarchicalCommand) {
+                commandName = hierarchicalCommand.commandName;
+                commandArguments = hierarchicalCommand.remainingArguments;
+            }
+            const commandData = {
+                commandName,
+                commandArguments,
+            };
+            if (this.$options.help) {
+                yield this.$helpService.showCommandLineHelp(commandData);
+            }
+            else {
+                yield this.$helpService.openHelpForCommandInBrowser(commandData);
+            }
+        });
+    }
+}
+exports.HelpCommand = HelpCommand;
+yok_1.injector.registerCommand(["help", "/?"], HelpCommand);

package/lib/common/commands/package-manager-get.js

@@ -0,0 +1,32 @@
+"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.PackageManagerGetCommand = void 0;
+const yok_1 = require("../yok");
+class PackageManagerGetCommand {
+    constructor($errors, $logger, $userSettingsService) {
+        this.$errors = $errors;
+        this.$logger = $logger;
+        this.$userSettingsService = $userSettingsService;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (args && args.length) {
+                this.$errors.failWithHelp(`The arguments '${args.join(" ")}' are not valid for the 'package-manager get' command.`);
+            }
+            const result = yield this.$userSettingsService.getSettingValue("packageManager");
+            this.$logger.printMarkdown(`Your current package manager is \`${result || "npm"}\`.`);
+        });
+    }
+}
+exports.PackageManagerGetCommand = PackageManagerGetCommand;
+yok_1.injector.registerCommand("package-manager|*get", PackageManagerGetCommand);

package/lib/common/commands/package-manager-set.js

@@ -0,0 +1,37 @@
+"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.PackageManagerCommand = void 0;
+const constants_1 = require("../../constants");
+const yok_1 = require("../yok");
+class PackageManagerCommand {
+    constructor($userSettingsService, $errors, $logger, $stringParameter) {
+        this.$userSettingsService = $userSettingsService;
+        this.$errors = $errors;
+        this.$logger = $logger;
+        this.$stringParameter = $stringParameter;
+        this.allowedParameters = [this.$stringParameter];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const packageManagerName = args[0];
+            const supportedPackageManagers = Object.keys(constants_1.PackageManagers);
+            if (supportedPackageManagers.indexOf(packageManagerName) === -1) {
+                this.$errors.fail(`${packageManagerName} is not a valid package manager. Supported values are: ${supportedPackageManagers.join(", ")}.`);
+            }
+            yield this.$userSettingsService.saveSetting("packageManager", packageManagerName);
+            this.$logger.printMarkdown(`Please ensure you have the directory containing \`${packageManagerName}\` executable available in your PATH.`);
+            this.$logger.printMarkdown(`You've successfully set \`${packageManagerName}\` as your package manager.`);
+        });
+    }
+}
+exports.PackageManagerCommand = PackageManagerCommand;
+yok_1.injector.registerCommand("package-manager|set", PackageManagerCommand);

package/lib/common/commands/post-install.js

@@ -0,0 +1,27 @@
+"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.PostInstallCommand = void 0;
+const yok_1 = require("../yok");
+class PostInstallCommand {
+    constructor($errors) {
+        this.$errors = $errors;
+        this.disableAnalytics = true;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$errors.fail("This command is deprecated. Use `ns dev-post-install-cli` instead");
+        });
+    }
+}
+exports.PostInstallCommand = PostInstallCommand;
+yok_1.injector.registerCommand("dev-post-install", PostInstallCommand);

package/lib/common/commands/preuninstall.js

@@ -0,0 +1,61 @@
+"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.PreUninstallCommand = void 0;
+const path = require("path");
+const helpers_1 = require("../helpers");
+const constants_1 = require("../../constants");
+const yok_1 = require("../yok");
+class PreUninstallCommand {
+    constructor($analyticsService, $extensibilityService, $fs, $packageInstallationManager, $settingsService) {
+        this.$analyticsService = $analyticsService;
+        this.$extensibilityService = $extensibilityService;
+        this.$fs = $fs;
+        this.$packageInstallationManager = $packageInstallationManager;
+        this.$settingsService = $settingsService;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isIntentionalUninstall = (0, helpers_1.doesCurrentNpmCommandMatch)([
+                /^uninstall$/,
+                /^remove$/,
+                /^rm$/,
+                /^r$/,
+                /^un$/,
+                /^unlink$/,
+            ]);
+            yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                action: "Uninstall CLI",
+                additionalData: `isIntentionalUninstall${constants_1.AnalyticsEventLabelDelimiter}${isIntentionalUninstall}${constants_1.AnalyticsEventLabelDelimiter}isInteractive${constants_1.AnalyticsEventLabelDelimiter}${!!(0, helpers_1.isInteractive)()}`,
+            });
+            if (isIntentionalUninstall) {
+                yield this.handleIntentionalUninstall();
+            }
+            this.$fs.deleteFile(path.join(this.$settingsService.getProfileDir(), "KillSwitches", "cli"));
+            yield this.$analyticsService.finishTracking();
+        });
+    }
+    handleIntentionalUninstall() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$extensibilityService.removeAllExtensions();
+            this.$packageInstallationManager.clearInspectorCache();
+            yield this.handleFeedbackForm();
+        });
+    }
+    handleFeedbackForm() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve();
+        });
+    }
+}
+exports.PreUninstallCommand = PreUninstallCommand;
+yok_1.injector.registerCommand("dev-preuninstall", PreUninstallCommand);

package/lib/common/commands/proxy/proxy-base.js

@@ -0,0 +1,34 @@
+"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.ProxyCommandBase = void 0;
+class ProxyCommandBase {
+    constructor($analyticsService, $logger, $proxyService, commandName) {
+        this.$analyticsService = $analyticsService;
+        this.$logger = $logger;
+        this.$proxyService = $proxyService;
+        this.commandName = commandName;
+        this.disableAnalytics = true;
+        this.allowedParameters = [];
+    }
+    tryTrackUsage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.$logger.trace(this.commandName);
+            }
+            catch (ex) {
+                this.$logger.trace("Error in trying to track proxy command usage:");
+                this.$logger.trace(ex);
+            }
+        });
+    }
+}
+exports.ProxyCommandBase = ProxyCommandBase;

package/lib/common/commands/proxy/proxy-clear.js

@@ -0,0 +1,32 @@
+"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.ProxyClearCommand = void 0;
+const proxy_base_1 = require("./proxy-base");
+const yok_1 = require("../../yok");
+const proxyClearCommandName = "proxy|clear";
+class ProxyClearCommand extends proxy_base_1.ProxyCommandBase {
+    constructor($analyticsService, $logger, $proxyService) {
+        super($analyticsService, $logger, $proxyService, proxyClearCommandName);
+        this.$analyticsService = $analyticsService;
+        this.$logger = $logger;
+        this.$proxyService = $proxyService;
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$proxyService.clearCache();
+            this.$logger.info("Successfully cleared proxy.");
+            yield this.tryTrackUsage();
+        });
+    }
+}
+exports.ProxyClearCommand = ProxyClearCommand;
+yok_1.injector.registerCommand(proxyClearCommandName, ProxyClearCommand);

package/lib/common/commands/proxy/proxy-get.js

@@ -0,0 +1,31 @@
+"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.ProxyGetCommand = void 0;
+const proxy_base_1 = require("./proxy-base");
+const yok_1 = require("../../yok");
+const proxyGetCommandName = "proxy|*get";
+class ProxyGetCommand extends proxy_base_1.ProxyCommandBase {
+    constructor($analyticsService, $logger, $proxyService) {
+        super($analyticsService, $logger, $proxyService, proxyGetCommandName);
+        this.$analyticsService = $analyticsService;
+        this.$logger = $logger;
+        this.$proxyService = $proxyService;
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.info(yield this.$proxyService.getInfo());
+            yield this.tryTrackUsage();
+        });
+    }
+}
+exports.ProxyGetCommand = ProxyGetCommand;
+yok_1.injector.registerCommand(proxyGetCommandName, ProxyGetCommand);

package/lib/common/commands/proxy/proxy-set.js

@@ -0,0 +1,150 @@
+"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.ProxySetCommand = void 0;
+const commandParams = require("../../command-params");
+const helpers_1 = require("../../helpers");
+const proxy_base_1 = require("./proxy-base");
+const constants_1 = require("../../constants");
+const url_1 = require("url");
+const os_1 = require("os");
+const yok_1 = require("../../yok");
+const { getCredentialsFromAuth } = require("proxy-lib/lib/utils");
+const proxySetCommandName = "proxy|set";
+class ProxySetCommand extends proxy_base_1.ProxyCommandBase {
+    constructor($errors, $injector, $prompter, $hostInfo, $staticConfig, $analyticsService, $logger, $options, $proxyService) {
+        super($analyticsService, $logger, $proxyService, proxySetCommandName);
+        this.$errors = $errors;
+        this.$injector = $injector;
+        this.$prompter = $prompter;
+        this.$hostInfo = $hostInfo;
+        this.$staticConfig = $staticConfig;
+        this.$analyticsService = $analyticsService;
+        this.$logger = $logger;
+        this.$options = $options;
+        this.$proxyService = $proxyService;
+        this.allowedParameters = [
+            new commandParams.StringCommandParameter(this.$injector),
+            new commandParams.StringCommandParameter(this.$injector),
+            new commandParams.StringCommandParameter(this.$injector),
+        ];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let urlString = args[0];
+            let username = args[1];
+            let password = args[2];
+            const noUrl = !urlString;
+            if (noUrl) {
+                if (!(0, helpers_1.isInteractive)()) {
+                    this.$errors.failWithHelp("Console is not interactive - you need to supply all command parameters.");
+                }
+                else {
+                    urlString = yield this.$prompter.getString("Url", {
+                        allowEmpty: false,
+                    });
+                }
+            }
+            let urlObj = (0, url_1.parse)(urlString);
+            if ((!urlObj.protocol || !urlObj.hostname) && !(0, helpers_1.isInteractive)()) {
+                this.$errors.fail("The url you have entered is invalid please enter a valid url containing a valid protocol and hostname.");
+            }
+            while (!urlObj.protocol || !urlObj.hostname) {
+                this.$logger.warn("The url you have entered is invalid please enter a valid url containing a valid protocol and hostname.");
+                urlString = yield this.$prompter.getString("Url", { allowEmpty: false });
+                urlObj = (0, url_1.parse)(urlString);
+            }
+            let port = (urlObj.port && +urlObj.port) || constants_1.HttpProtocolToPort[urlObj.protocol];
+            const noPort = !port || !this.isValidPort(port);
+            const authCredentials = getCredentialsFromAuth(urlObj.auth || "");
+            if ((username &&
+                authCredentials.username &&
+                username !== authCredentials.username) ||
+                (password &&
+                    authCredentials.password &&
+                    password !== authCredentials.password)) {
+                this.$errors.fail("The credentials you have provided in the url address mismatch those passed as command line arguments.");
+            }
+            username = username || authCredentials.username;
+            password = password || authCredentials.password;
+            if (!(0, helpers_1.isInteractive)()) {
+                if (noPort) {
+                    this.$errors.fail(`The port you have specified (${port || "none"}) is not valid.`);
+                }
+                else if (this.isPasswordRequired(username, password)) {
+                    this.$errors.failWithHelp("Console is not interactive - you need to supply all command parameters.");
+                }
+            }
+            if (noPort) {
+                if (port) {
+                    this.$logger.warn(this.getInvalidPortMessage(port));
+                }
+                port = yield this.getPortFromUserInput();
+            }
+            if (!username) {
+                this.$logger.info("In case your proxy requires authentication, please specify username and password. If authentication is not required, just leave it empty.");
+                username = yield this.$prompter.getString("Username", {
+                    defaultAction: () => "",
+                });
+            }
+            if (this.isPasswordRequired(username, password)) {
+                password = yield this.$prompter.getPassword("Password");
+            }
+            const settings = {
+                proxyUrl: urlString,
+                username,
+                password,
+                rejectUnauthorized: !this.$options.insecure,
+            };
+            if (!this.$hostInfo.isWindows) {
+                this.$logger.warn(`Note that storing credentials is not supported on ${(0, os_1.platform)()} yet.`);
+            }
+            const clientName = this.$staticConfig.CLIENT_NAME.toLowerCase();
+            const messageNote = (clientName === "tns"
+                ? "Note that 'npm' and 'Gradle' need to be configured separately to work with a proxy."
+                : "Note that `npm` needs to be configured separately to work with a proxy.") +
+                os_1.EOL;
+            this.$logger.warn(`${messageNote}Run '${clientName} proxy set --help' for more information.`);
+            yield this.$proxyService.setCache(settings);
+            this.$logger.info(`Successfully setup proxy.${os_1.EOL}`);
+            this.$logger.info(yield this.$proxyService.getInfo());
+            yield this.tryTrackUsage();
+        });
+    }
+    isPasswordRequired(username, password) {
+        return !!(username && !password);
+    }
+    isValidPort(port) {
+        return !isNaN(port) && port > 0 && port < 65536;
+    }
+    getPortFromUserInput() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schemaName = "port";
+            const schema = {
+                message: "Port",
+                type: "text",
+                name: schemaName,
+                validate: (value) => {
+                    return !value || !this.isValidPort(value)
+                        ? this.getInvalidPortMessage(value)
+                        : true;
+                },
+            };
+            const prompterResult = yield this.$prompter.get([schema]);
+            return parseInt(prompterResult[schemaName]);
+        });
+    }
+    getInvalidPortMessage(port) {
+        return `Specified port ${port} is not valid. Please enter a value between 1 and 65535.`;
+    }
+}
+exports.ProxySetCommand = ProxySetCommand;
+yok_1.injector.registerCommand(proxySetCommandName, ProxySetCommand);

package/lib/common/common-lib.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const yok_1 = require("./yok");
+require("./appbuilder/proton-bootstrap");
+module.exports = yok_1.injector.publicApi;