nativescript 8.9.0-dev.2 → 8.9.0-dev.4

package/lib/common/child-process.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.ChildProcess = void 0;
 const child_process = require("child_process");
@@ -20,40 +11,36 @@ class ChildProcess extends events_1.EventEmitter {
         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);
+    async exec(command, options, execOptions) {
+        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 {
-                    child_process.exec(command, callback);
+                    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);
-                    }
-                });
+    async execFile(command, args) {
+        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);
+                }
             });
         });
     }
@@ -174,42 +161,36 @@ class ChildProcess extends events_1.EventEmitter {
             });
         });
     }
-    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,
-                });
-            }
-        });
+    async trySpawnFromCloseEvent(command, args, options, spawnFromEventOptions) {
+        try {
+            const childProcessResult = await 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);
-            }
-        });
+    async tryExecuteApplication(command, args, event, errorMessage, condition) {
+        const childProcess = await 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);
-            }
-        });
+    async tryExecuteApplicationCore(command, args, event, errorMessage) {
+        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(" "));

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

@@ -7,7 +7,7 @@ var CodeEntityType;
 (function (CodeEntityType) {
     CodeEntityType[CodeEntityType["Line"] = 0] = "Line";
     CodeEntityType[CodeEntityType["Block"] = 1] = "Block";
-})(CodeEntityType = exports.CodeEntityType || (exports.CodeEntityType = {}));
+})(CodeEntityType || (exports.CodeEntityType = CodeEntityType = {}));
 class Line {
     constructor(content) {
         this.content = content;

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

@@ -40,10 +40,10 @@ class CodePrinter {
         return content;
     }
 }
+exports.CodePrinter = CodePrinter;
 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);
 //# sourceMappingURL=code-printer.js.map

package/lib/common/command-params.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.StringParameterBuilder = exports.StringCommandParameter = void 0;
 const yok_1 = require("./yok");
@@ -16,16 +7,14 @@ class StringCommandParameter {
         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;
+    async validate(validationValue) {
+        if (!validationValue) {
+            if (this.errorMessage) {
+                this.$injector.resolve("errors").fail(this.errorMessage);
             }
-            return true;
-        });
+            return false;
+        }
+        return true;
     }
 }
 exports.StringCommandParameter = StringCommandParameter;

package/lib/common/commands/analytics.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.ErrorReportingCommand = exports.UsageReportingCommand = exports.AnalyticsCommandParameter = void 0;
 const yok_1 = require("../yok");
@@ -16,19 +7,17 @@ class AnalyticsCommandParameter {
         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'.`);
-            }
-        });
+    async validate(validationValue) {
+        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;
@@ -43,26 +32,24 @@ class AnalyticsCommand {
         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);
-                    // TODO(Analytics): await this.$analyticsService.track(this.settingName, "enabled");
-                    this.$logger.info(`${this.humanReadableSettingName} is now enabled.`);
-                    break;
-                case "disable":
-                    // TODO(Analytics): await this.$analyticsService.track(this.settingName, "disabled");
-                    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;
-            }
-        });
+    async execute(args) {
+        const arg = args[0] || "";
+        switch (arg.toLowerCase()) {
+            case "enable":
+                await this.$analyticsService.setStatus(this.settingName, true);
+                // TODO(Analytics): await this.$analyticsService.track(this.settingName, "enabled");
+                this.$logger.info(`${this.humanReadableSettingName} is now enabled.`);
+                break;
+            case "disable":
+                // TODO(Analytics): await this.$analyticsService.track(this.settingName, "disabled");
+                await this.$analyticsService.setStatus(this.settingName, false);
+                this.$logger.info(`${this.humanReadableSettingName} is now disabled.`);
+                break;
+            case "status":
+            case "":
+                this.$logger.info(await this.$analyticsService.getStatusMessage(this.settingName, this.$options.json, this.humanReadableSettingName));
+                break;
+        }
     }
 }
 class UsageReportingCommand extends AnalyticsCommand {

package/lib/common/commands/autocompletion.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.AutoCompleteStatusCommand = exports.EnableAutoCompleteCommand = exports.DisableAutoCompleteCommand = exports.AutoCompleteCommand = void 0;
 const helpers = require("../helpers");
@@ -20,32 +11,30 @@ class AutoCompleteCommand {
         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()) {
-                        // obsolete autocompletion is enabled, update it to the new one:
-                        yield this.$autoCompletionService.enableAutoCompletion();
-                    }
-                    else {
-                        this.$logger.info("Autocompletion is already enabled");
-                    }
+    async execute(args) {
+        if (helpers.isInteractive()) {
+            if (this.$autoCompletionService.isAutoCompletionEnabled()) {
+                if (this.$autoCompletionService.isObsoleteAutoCompletionEnabled()) {
+                    // obsolete autocompletion is enabled, update it to the new one:
+                    await this.$autoCompletionService.enableAutoCompletion();
                 }
                 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 {
-                        // make sure we've removed all autocompletion code from all shell profiles
-                        this.$autoCompletionService.disableAutoCompletion();
-                    }
+                    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 = await this.$prompter.confirm(message, () => true);
+                if (autoCompetionStatus) {
+                    await this.$autoCompletionService.enableAutoCompletion();
+                }
+                else {
+                    // make sure we've removed all autocompletion code from all shell profiles
+                    this.$autoCompletionService.disableAutoCompletion();
+                }
+            }
+        }
     }
 }
 exports.AutoCompleteCommand = AutoCompleteCommand;
@@ -57,15 +46,13 @@ class DisableAutoCompleteCommand {
         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.");
-            }
-        });
+    async execute(args) {
+        if (this.$autoCompletionService.isAutoCompletionEnabled()) {
+            this.$autoCompletionService.disableAutoCompletion();
+        }
+        else {
+            this.$logger.info("Autocompletion is already disabled.");
+        }
     }
 }
 exports.DisableAutoCompleteCommand = DisableAutoCompleteCommand;
@@ -77,15 +64,13 @@ class EnableAutoCompleteCommand {
         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();
-            }
-        });
+    async execute(args) {
+        if (this.$autoCompletionService.isAutoCompletionEnabled()) {
+            this.$logger.info("Autocompletion is already enabled.");
+        }
+        else {
+            await this.$autoCompletionService.enableAutoCompletion();
+        }
     }
 }
 exports.EnableAutoCompleteCommand = EnableAutoCompleteCommand;
@@ -97,15 +82,13 @@ class AutoCompleteStatusCommand {
         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.");
-            }
-        });
+    async execute(args) {
+        if (this.$autoCompletionService.isAutoCompletionEnabled()) {
+            this.$logger.info("Autocompletion is enabled.");
+        }
+        else {
+            this.$logger.info("Autocompletion is disabled.");
+        }
     }
 }
 exports.AutoCompleteStatusCommand = AutoCompleteStatusCommand;

package/lib/common/commands/device/device-log-stream.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.OpenDeviceLogStreamCommand = void 0;
 const yok_1 = require("../../yok");
@@ -23,23 +14,21 @@ class OpenDeviceLogStreamCommand {
         $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);
+    async execute(args) {
+        this.$deviceLogProvider.setLogLevel(this.$loggingLevels.full);
+        await this.$devicesService.initialize({
+            deviceId: this.$options.device,
+            skipInferPlatform: true,
         });
+        if (this.$devicesService.deviceCount > 1) {
+            await this.$commandsService.tryExecuteCommand("device", []);
+            this.$errors.failWithHelp(OpenDeviceLogStreamCommand.NOT_SPECIFIED_DEVICE_ERROR_MESSAGE);
+        }
+        const action = (device) => device.openDeviceLogStream();
+        await this.$devicesService.execute(action);
     }
 }
-OpenDeviceLogStreamCommand.NOT_SPECIFIED_DEVICE_ERROR_MESSAGE = "More than one device found. Specify device explicitly.";
 exports.OpenDeviceLogStreamCommand = OpenDeviceLogStreamCommand;
+OpenDeviceLogStreamCommand.NOT_SPECIFIED_DEVICE_ERROR_MESSAGE = "More than one device found. Specify device explicitly.";
 yok_1.injector.registerCommand(["device|log", "devices|log"], OpenDeviceLogStreamCommand);
 //# sourceMappingURL=device-log-stream.js.map

package/lib/common/commands/device/get-file.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.GetFileCommand = void 0;
 const yok_1 = require("../../yok");
@@ -23,32 +14,30 @@ class GetFileCommand {
             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) {
-                    // ignore the error
-                }
-                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);
+    async execute(args) {
+        await this.$devicesService.initialize({
+            deviceId: this.$options.device,
+            skipInferPlatform: true,
         });
+        let appIdentifier = args[1];
+        if (!appIdentifier) {
+            try {
+                this.$projectData.initializeProjectData();
+            }
+            catch (err) {
+                // ignore the error
+            }
+            if (!this.$projectData.projectIdentifiers) {
+                this.$errors.fail("Please enter application identifier or execute this command in project.");
+            }
+        }
+        const action = async (device) => {
+            appIdentifier =
+                appIdentifier ||
+                    this.$projectData.projectIdentifiers[device.deviceInfo.platform.toLowerCase()];
+            await device.fileSystem.getFile(args[0], appIdentifier, this.$options.file);
+        };
+        await this.$devicesService.execute(action);
     }
 }
 exports.GetFileCommand = GetFileCommand;

package/lib/common/commands/device/list-applications.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.ListApplicationsCommand = void 0;
 const os_1 = require("os");
@@ -21,21 +12,19 @@ class ListApplicationsCommand {
         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));
+    async execute(args) {
+        await this.$devicesService.initialize({
+            deviceId: this.$options.device,
+            skipInferPlatform: true,
         });
+        const output = [];
+        const action = async (device) => {
+            const applications = await 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));
+        };
+        await this.$devicesService.execute(action);
+        this.$logger.info(output.join(os_1.EOL));
     }
 }
 exports.ListApplicationsCommand = ListApplicationsCommand;