@akylas/nativescript-cli 8.7.2

package/lib/common/commands/autocompletion.js

@@ -0,0 +1,110 @@
+"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.AutoCompleteStatusCommand = exports.EnableAutoCompleteCommand = exports.DisableAutoCompleteCommand = exports.AutoCompleteCommand = void 0;
+const helpers = require("../helpers");
+const yok_1 = require("../yok");
+class AutoCompleteCommand {
+    constructor($autoCompletionService, $logger, $prompter) {
+        this.$autoCompletionService = $autoCompletionService;
+        this.$logger = $logger;
+        this.$prompter = $prompter;
+        this.disableAnalytics = true;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (helpers.isInteractive()) {
+                if (this.$autoCompletionService.isAutoCompletionEnabled()) {
+                    if (this.$autoCompletionService.isObsoleteAutoCompletionEnabled()) {
+                        yield this.$autoCompletionService.enableAutoCompletion();
+                    }
+                    else {
+                        this.$logger.info("Autocompletion is already enabled");
+                    }
+                }
+                else {
+                    this.$logger.info("If you are using bash or zsh, you can enable command-line completion.");
+                    const message = "Do you want to enable it now?";
+                    const autoCompetionStatus = yield this.$prompter.confirm(message, () => true);
+                    if (autoCompetionStatus) {
+                        yield this.$autoCompletionService.enableAutoCompletion();
+                    }
+                    else {
+                        this.$autoCompletionService.disableAutoCompletion();
+                    }
+                }
+            }
+        });
+    }
+}
+exports.AutoCompleteCommand = AutoCompleteCommand;
+yok_1.injector.registerCommand("autocomplete|*default", AutoCompleteCommand);
+class DisableAutoCompleteCommand {
+    constructor($autoCompletionService, $logger) {
+        this.$autoCompletionService = $autoCompletionService;
+        this.$logger = $logger;
+        this.disableAnalytics = true;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.$autoCompletionService.isAutoCompletionEnabled()) {
+                this.$autoCompletionService.disableAutoCompletion();
+            }
+            else {
+                this.$logger.info("Autocompletion is already disabled.");
+            }
+        });
+    }
+}
+exports.DisableAutoCompleteCommand = DisableAutoCompleteCommand;
+yok_1.injector.registerCommand("autocomplete|disable", DisableAutoCompleteCommand);
+class EnableAutoCompleteCommand {
+    constructor($autoCompletionService, $logger) {
+        this.$autoCompletionService = $autoCompletionService;
+        this.$logger = $logger;
+        this.disableAnalytics = true;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.$autoCompletionService.isAutoCompletionEnabled()) {
+                this.$logger.info("Autocompletion is already enabled.");
+            }
+            else {
+                yield this.$autoCompletionService.enableAutoCompletion();
+            }
+        });
+    }
+}
+exports.EnableAutoCompleteCommand = EnableAutoCompleteCommand;
+yok_1.injector.registerCommand("autocomplete|enable", EnableAutoCompleteCommand);
+class AutoCompleteStatusCommand {
+    constructor($autoCompletionService, $logger) {
+        this.$autoCompletionService = $autoCompletionService;
+        this.$logger = $logger;
+        this.disableAnalytics = true;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.$autoCompletionService.isAutoCompletionEnabled()) {
+                this.$logger.info("Autocompletion is enabled.");
+            }
+            else {
+                this.$logger.info("Autocompletion is disabled.");
+            }
+        });
+    }
+}
+exports.AutoCompleteStatusCommand = AutoCompleteStatusCommand;
+yok_1.injector.registerCommand("autocomplete|status", AutoCompleteStatusCommand);

package/lib/common/commands/device/device-log-stream.js

@@ -0,0 +1,44 @@
+"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.OpenDeviceLogStreamCommand = void 0;
+const yok_1 = require("../../yok");
+class OpenDeviceLogStreamCommand {
+    constructor($devicesService, $errors, $commandsService, $options, $deviceLogProvider, $loggingLevels, $iOSSimulatorLogProvider, $cleanupService) {
+        this.$devicesService = $devicesService;
+        this.$errors = $errors;
+        this.$commandsService = $commandsService;
+        this.$options = $options;
+        this.$deviceLogProvider = $deviceLogProvider;
+        this.$loggingLevels = $loggingLevels;
+        this.allowedParameters = [];
+        $iOSSimulatorLogProvider.setShouldDispose(false);
+        $cleanupService.setShouldDispose(false);
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$deviceLogProvider.setLogLevel(this.$loggingLevels.full);
+            yield this.$devicesService.initialize({
+                deviceId: this.$options.device,
+                skipInferPlatform: true,
+            });
+            if (this.$devicesService.deviceCount > 1) {
+                yield this.$commandsService.tryExecuteCommand("device", []);
+                this.$errors.failWithHelp(OpenDeviceLogStreamCommand.NOT_SPECIFIED_DEVICE_ERROR_MESSAGE);
+            }
+            const action = (device) => device.openDeviceLogStream();
+            yield this.$devicesService.execute(action);
+        });
+    }
+}
+OpenDeviceLogStreamCommand.NOT_SPECIFIED_DEVICE_ERROR_MESSAGE = "More than one device found. Specify device explicitly.";
+exports.OpenDeviceLogStreamCommand = OpenDeviceLogStreamCommand;
+yok_1.injector.registerCommand(["device|log", "devices|log"], OpenDeviceLogStreamCommand);

package/lib/common/commands/device/get-file.js

@@ -0,0 +1,54 @@
+"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.GetFileCommand = void 0;
+const yok_1 = require("../../yok");
+class GetFileCommand {
+    constructor($devicesService, $stringParameter, $projectData, $errors, $options) {
+        this.$devicesService = $devicesService;
+        this.$stringParameter = $stringParameter;
+        this.$projectData = $projectData;
+        this.$errors = $errors;
+        this.$options = $options;
+        this.allowedParameters = [
+            this.$stringParameter,
+            this.$stringParameter,
+        ];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$devicesService.initialize({
+                deviceId: this.$options.device,
+                skipInferPlatform: true,
+            });
+            let appIdentifier = args[1];
+            if (!appIdentifier) {
+                try {
+                    this.$projectData.initializeProjectData();
+                }
+                catch (err) {
+                }
+                if (!this.$projectData.projectIdentifiers) {
+                    this.$errors.fail("Please enter application identifier or execute this command in project.");
+                }
+            }
+            const action = (device) => __awaiter(this, void 0, void 0, function* () {
+                appIdentifier =
+                    appIdentifier ||
+                        this.$projectData.projectIdentifiers[device.deviceInfo.platform.toLowerCase()];
+                yield device.fileSystem.getFile(args[0], appIdentifier, this.$options.file);
+            });
+            yield this.$devicesService.execute(action);
+        });
+    }
+}
+exports.GetFileCommand = GetFileCommand;
+yok_1.injector.registerCommand(["device|get-file", "devices|get-file"], GetFileCommand);

package/lib/common/commands/device/list-applications.js

@@ -0,0 +1,42 @@
+"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.ListApplicationsCommand = void 0;
+const os_1 = require("os");
+const util = require("util");
+const _ = require("lodash");
+const yok_1 = require("../../yok");
+class ListApplicationsCommand {
+    constructor($devicesService, $logger, $options) {
+        this.$devicesService = $devicesService;
+        this.$logger = $logger;
+        this.$options = $options;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$devicesService.initialize({
+                deviceId: this.$options.device,
+                skipInferPlatform: true,
+            });
+            const output = [];
+            const action = (device) => __awaiter(this, void 0, void 0, function* () {
+                const applications = yield device.applicationManager.getInstalledApplications();
+                output.push(util.format("%s=====Installed applications on device with UDID '%s' are:", os_1.EOL, device.deviceInfo.identifier));
+                _.each(applications, (applicationId) => output.push(applicationId));
+            });
+            yield this.$devicesService.execute(action);
+            this.$logger.info(output.join(os_1.EOL));
+        });
+    }
+}
+exports.ListApplicationsCommand = ListApplicationsCommand;
+yok_1.injector.registerCommand(["device|list-applications", "devices|list-applications"], ListApplicationsCommand);

package/lib/common/commands/device/list-devices.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.ListDevicesCommand = void 0;
+const helpers_1 = require("../../helpers");
+const constants_1 = require("../../../constants");
+const yok_1 = require("../../yok");
+const color_1 = require("../../../color");
+class ListDevicesCommand {
+    constructor($devicesService, $errors, $emulatorHelper, $logger, $stringParameter, $mobileHelper, $options) {
+        this.$devicesService = $devicesService;
+        this.$errors = $errors;
+        this.$emulatorHelper = $emulatorHelper;
+        this.$logger = $logger;
+        this.$stringParameter = $stringParameter;
+        this.$mobileHelper = $mobileHelper;
+        this.$options = $options;
+        this.allowedParameters = [this.$stringParameter];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = {
+                devices: [],
+            };
+            if (this.$options.availableDevices) {
+                const platform = this.$mobileHelper.normalizePlatformName(args[0]);
+                if (!platform && args[0]) {
+                    this.$errors.fail(`${args[0]} is not a valid device platform. The valid platforms are ${(0, helpers_1.formatListOfNames)(this.$mobileHelper.platformNames)}`);
+                }
+                const availableEmulatorsOutput = yield this.$devicesService.getEmulatorImages({ platform });
+                const emulators = this.$emulatorHelper.getEmulatorsFromAvailableEmulatorsOutput(availableEmulatorsOutput);
+                devices.available = emulators;
+                if (!this.$options.json) {
+                    this.$logger.info(color_1.color.bold("\n Available emulators"));
+                    this.printEmulators(emulators);
+                }
+            }
+            let index = 1;
+            yield this.$devicesService.initialize({
+                platform: args[0],
+                deviceId: null,
+                skipInferPlatform: true,
+                skipDeviceDetectionInterval: true,
+                skipEmulatorStart: true,
+                fullDiscovery: true,
+            });
+            if (!this.$options.json) {
+                this.$logger.info(color_1.color.bold("\n Connected devices & emulators"));
+            }
+            const table = (0, helpers_1.createTable)([
+                "#",
+                "Device Name",
+                "Platform",
+                "Device Identifier",
+                "Type",
+                "Status",
+                "Connection Type",
+            ], []);
+            let action;
+            if (this.$options.json) {
+                action = (device) => __awaiter(this, void 0, void 0, function* () {
+                    devices.devices.push(device.deviceInfo);
+                });
+            }
+            else {
+                action = (device) => __awaiter(this, void 0, void 0, function* () {
+                    table.push([
+                        (index++).toString(),
+                        device.deviceInfo.displayName || "",
+                        device.deviceInfo.platform || "",
+                        device.deviceInfo.identifier || "",
+                        device.deviceInfo.type || "",
+                        device.deviceInfo.status || "",
+                        device.deviceInfo.connectionTypes
+                            .map((type) => constants_1.DeviceConnectionType[type])
+                            .join(", "),
+                    ]);
+                });
+            }
+            yield this.$devicesService.execute(action, undefined, {
+                allowNoDevices: true,
+            });
+            if (this.$options.json) {
+                return this.$logger.info(JSON.stringify(devices, null, 2));
+            }
+            if (table.length) {
+                this.$logger.info(table.toString());
+            }
+        });
+    }
+    printEmulators(emulators) {
+        const table = (0, helpers_1.createTable)([
+            "Device Name",
+            "Platform",
+            "Version",
+            "Device Identifier",
+            "Image Identifier",
+        ], []);
+        for (const info of emulators) {
+            table.push([
+                info.displayName,
+                info.platform,
+                info.version,
+                info.identifier || "",
+                info.imageIdentifier || "",
+            ]);
+        }
+        this.$logger.info(table.toString());
+    }
+}
+exports.ListDevicesCommand = ListDevicesCommand;
+yok_1.injector.registerCommand(["device|*list", "devices|*list"], ListDevicesCommand);
+class ListAndroidDevicesCommand {
+    constructor($injector, $devicePlatformsConstants) {
+        this.$injector = $injector;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const listDevicesCommand = this.$injector.resolve(ListDevicesCommand);
+            const platform = this.$devicePlatformsConstants.Android;
+            yield listDevicesCommand.execute([platform]);
+        });
+    }
+}
+yok_1.injector.registerCommand(["device|android", "devices|android"], ListAndroidDevicesCommand);
+class ListiOSDevicesCommand {
+    constructor($injector, $devicePlatformsConstants) {
+        this.$injector = $injector;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const listDevicesCommand = this.$injector.resolve(ListDevicesCommand);
+            const platform = this.$devicePlatformsConstants.iOS;
+            yield listDevicesCommand.execute([platform]);
+        });
+    }
+}
+yok_1.injector.registerCommand(["device|ios", "devices|ios"], ListiOSDevicesCommand);

package/lib/common/commands/device/list-files.js

@@ -0,0 +1,55 @@
+"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.ListFilesCommand = void 0;
+const yok_1 = require("../../yok");
+class ListFilesCommand {
+    constructor($devicesService, $stringParameter, $options, $projectData, $errors) {
+        this.$devicesService = $devicesService;
+        this.$stringParameter = $stringParameter;
+        this.$options = $options;
+        this.$projectData = $projectData;
+        this.$errors = $errors;
+        this.allowedParameters = [
+            this.$stringParameter,
+            this.$stringParameter,
+        ];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$devicesService.initialize({
+                deviceId: this.$options.device,
+                skipInferPlatform: true,
+            });
+            const pathToList = args[0];
+            let appIdentifier = args[1];
+            if (!appIdentifier) {
+                try {
+                    this.$projectData.initializeProjectData();
+                }
+                catch (err) {
+                }
+                if (!this.$projectData.projectIdentifiers) {
+                    this.$errors.fail("Please enter application identifier or execute this command in project.");
+                }
+            }
+            const action = (device) => __awaiter(this, void 0, void 0, function* () {
+                appIdentifier =
+                    appIdentifier ||
+                        this.$projectData.projectIdentifiers[device.deviceInfo.platform.toLowerCase()];
+                yield device.fileSystem.listFiles(pathToList, appIdentifier);
+            });
+            yield this.$devicesService.execute(action);
+        });
+    }
+}
+exports.ListFilesCommand = ListFilesCommand;
+yok_1.injector.registerCommand(["device|list-files", "devices|list-files"], ListFilesCommand);

package/lib/common/commands/device/put-file.js

@@ -0,0 +1,55 @@
+"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.PutFileCommand = void 0;
+const yok_1 = require("../../yok");
+class PutFileCommand {
+    constructor($devicesService, $stringParameter, $options, $projectData, $errors) {
+        this.$devicesService = $devicesService;
+        this.$stringParameter = $stringParameter;
+        this.$options = $options;
+        this.$projectData = $projectData;
+        this.$errors = $errors;
+        this.allowedParameters = [
+            this.$stringParameter,
+            this.$stringParameter,
+            this.$stringParameter,
+        ];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$devicesService.initialize({
+                deviceId: this.$options.device,
+                skipInferPlatform: true,
+            });
+            let appIdentifier = args[2];
+            if (!appIdentifier) {
+                try {
+                    this.$projectData.initializeProjectData();
+                }
+                catch (err) {
+                }
+                if (!this.$projectData.projectIdentifiers) {
+                    this.$errors.fail("Please enter application identifier or execute this command in project.");
+                }
+            }
+            const action = (device) => __awaiter(this, void 0, void 0, function* () {
+                appIdentifier =
+                    appIdentifier ||
+                        this.$projectData.projectIdentifiers[device.deviceInfo.platform.toLowerCase()];
+                yield device.fileSystem.putFile(args[0], args[1], appIdentifier);
+            });
+            yield this.$devicesService.execute(action);
+        });
+    }
+}
+exports.PutFileCommand = PutFileCommand;
+yok_1.injector.registerCommand(["device|put-file", "devices|put-file"], PutFileCommand);

package/lib/common/commands/device/run-application.js

@@ -0,0 +1,46 @@
+"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.RunApplicationOnDeviceCommand = void 0;
+const yok_1 = require("../../yok");
+class RunApplicationOnDeviceCommand {
+    constructor($devicesService, $errors, $stringParameter, $staticConfig, $options) {
+        this.$devicesService = $devicesService;
+        this.$errors = $errors;
+        this.$stringParameter = $stringParameter;
+        this.$staticConfig = $staticConfig;
+        this.$options = $options;
+        this.allowedParameters = [
+            this.$stringParameter,
+            this.$stringParameter,
+        ];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$devicesService.initialize({
+                deviceId: this.$options.device,
+                skipInferPlatform: true,
+            });
+            if (this.$devicesService.deviceCount > 1) {
+                this.$errors.failWithHelp("More than one device found. Specify device explicitly with --device option. To discover device ID, use $%s device command.", this.$staticConfig.CLIENT_NAME.toLowerCase());
+            }
+            yield this.$devicesService.execute((device) => __awaiter(this, void 0, void 0, function* () {
+                return yield device.applicationManager.startApplication({
+                    appId: args[0],
+                    projectName: args[1],
+                    projectDir: null,
+                });
+            }));
+        });
+    }
+}
+exports.RunApplicationOnDeviceCommand = RunApplicationOnDeviceCommand;
+yok_1.injector.registerCommand(["device|run", "devices|run"], RunApplicationOnDeviceCommand);

package/lib/common/commands/device/stop-application.js

@@ -0,0 +1,42 @@
+"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.StopApplicationOnDeviceCommand = void 0;
+const yok_1 = require("../../yok");
+class StopApplicationOnDeviceCommand {
+    constructor($devicesService, $stringParameter, $options) {
+        this.$devicesService = $devicesService;
+        this.$stringParameter = $stringParameter;
+        this.$options = $options;
+        this.allowedParameters = [
+            this.$stringParameter,
+            this.$stringParameter,
+            this.$stringParameter,
+        ];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$devicesService.initialize({
+                deviceId: this.$options.device,
+                skipInferPlatform: true,
+                platform: args[1],
+            });
+            const action = (device) => device.applicationManager.stopApplication({
+                appId: args[0],
+                projectName: args[2],
+                projectDir: null,
+            });
+            yield this.$devicesService.execute(action);
+        });
+    }
+}
+exports.StopApplicationOnDeviceCommand = StopApplicationOnDeviceCommand;
+yok_1.injector.registerCommand(["device|stop", "devices|stop"], StopApplicationOnDeviceCommand);

package/lib/common/commands/device/uninstall-application.js

@@ -0,0 +1,33 @@
+"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.UninstallApplicationCommand = void 0;
+const yok_1 = require("../../yok");
+class UninstallApplicationCommand {
+    constructor($devicesService, $stringParameter, $options) {
+        this.$devicesService = $devicesService;
+        this.$stringParameter = $stringParameter;
+        this.$options = $options;
+        this.allowedParameters = [this.$stringParameter];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$devicesService.initialize({
+                deviceId: this.$options.device,
+                skipInferPlatform: true,
+            });
+            const action = (device) => device.applicationManager.uninstallApplication(args[0]);
+            yield this.$devicesService.execute(action);
+        });
+    }
+}
+exports.UninstallApplicationCommand = UninstallApplicationCommand;
+yok_1.injector.registerCommand(["device|uninstall", "devices|uninstall"], UninstallApplicationCommand);