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

package/lib/detached-processes/cleanup-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 });
 // NOTE: This file is used to clean up resources used by CLI, when the CLI is killed.
 // The instances here are not shared with the ones in main CLI process.
@@ -32,13 +23,13 @@ const commandsInfos = [];
 const filesToDelete = [];
 const jsCommands = [];
 const requests = [];
-const executeRequest = (request) => __awaiter(void 0, void 0, void 0, function* () {
+const executeRequest = async (request) => {
     const $httpClient = yok_1.injector.resolve("httpClient");
     try {
         fileLogService.logData({
             message: `Start executing request: ${request.method} ${request.url}`,
         });
-        const response = yield $httpClient.httpRequest({
+        const response = await $httpClient.httpRequest({
             url: request.url,
             method: request.method,
             headers: request.headers,
@@ -54,14 +45,14 @@ const executeRequest = (request) => __awaiter(void 0, void 0, void 0, function*
             message: `Unable to execute request: ${request.method} ${request.url}`,
         });
     }
-});
-const executeJSCleanup = (jsCommand) => __awaiter(void 0, void 0, void 0, function* () {
+};
+const executeJSCleanup = async (jsCommand) => {
     const $childProcess = yok_1.injector.resolve("childProcess");
     try {
         fileLogService.logData({
             message: `Start executing action for file: ${jsCommand.filePath} and data ${JSON.stringify(jsCommand.data)}`,
         });
-        yield $childProcess.trySpawnFromCloseEvent(process.execPath, [
+        await $childProcess.trySpawnFromCloseEvent(process.execPath, [
             path.join(__dirname, "cleanup-js-subprocess.js"),
             pathToBootstrap,
             logFile,
@@ -78,21 +69,21 @@ const executeJSCleanup = (jsCommand) => __awaiter(void 0, void 0, void 0, functi
             type: "Error" /* FileLogMessageType.Error */,
         });
     }
-});
-const executeCleanup = () => __awaiter(void 0, void 0, void 0, function* () {
+};
+const executeCleanup = async () => {
     const $childProcess = yok_1.injector.resolve("childProcess");
     for (const request of requests) {
-        yield executeRequest(request);
+        await executeRequest(request);
     }
     for (const jsCommand of jsCommands) {
-        yield executeJSCleanup(jsCommand);
+        await executeJSCleanup(jsCommand);
     }
     for (const commandInfo of commandsInfos) {
         try {
             fileLogService.logData({
                 message: `Start executing command: ${JSON.stringify(commandInfo)}`,
             });
-            yield $childProcess.trySpawnFromCloseEvent(commandInfo.command, commandInfo.args, commandInfo.options || {}, { throwError: true, timeout: commandInfo.timeout || 3000 });
+            await $childProcess.trySpawnFromCloseEvent(commandInfo.command, commandInfo.args, commandInfo.options || {}, { throwError: true, timeout: commandInfo.timeout || 3000 });
             fileLogService.logData({
                 message: `Successfully executed command: ${JSON.stringify(commandInfo)}`,
             });
@@ -120,7 +111,7 @@ const executeCleanup = () => __awaiter(void 0, void 0, void 0, function* () {
     }
     fileLogService.logData({ message: `cleanup-process finished` });
     process.exit();
-});
+};
 const addCleanupAction = (commandInfo) => {
     if (_.some(commandsInfos, (currentCommandInfo) => _.isEqual(currentCommandInfo, commandInfo))) {
         fileLogService.logData({
@@ -231,7 +222,7 @@ const removeJSFile = (jsCommand) => {
         });
     }
 };
-process.on("message", (cleanupProcessMessage) => __awaiter(void 0, void 0, void 0, function* () {
+process.on("message", async (cleanupProcessMessage) => {
     fileLogService.logData({
         message: `cleanup-process received message of type: ${JSON.stringify(cleanupProcessMessage)}`,
     });
@@ -269,15 +260,15 @@ process.on("message", (cleanupProcessMessage) => __awaiter(void 0, void 0, void
             });
             break;
     }
-}));
-process.on("disconnect", () => __awaiter(void 0, void 0, void 0, function* () {
+});
+process.on("disconnect", async () => {
     fileLogService.logData({
         message: "cleanup-process received process.disconnect event",
     });
-    yield executeCleanup();
+    await executeCleanup();
     yok_1.injector.dispose();
     process.exit();
-}));
+});
 fileLogService.logData({
     message: `cleanup-process will send ${"ProcessReadyToReceive" /* DetachedProcessMessages.ProcessReadyToReceive */} message`,
 });

package/lib/device-path-provider.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.DevicePathProvider = void 0;
 const helpers_1 = require("./common/helpers");
@@ -21,33 +12,31 @@ class DevicePathProvider {
         this.$iOSSimResolver = $iOSSimResolver;
         this.$errors = $errors;
     }
-    getDeviceProjectRootPath(device, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let projectRoot = "";
-            if (this.$mobileHelper.isApplePlatform(device.deviceInfo.platform)) {
-                projectRoot = device.isEmulator
-                    ? yield this.$iOSSimResolver.iOSSim.getApplicationPath(device.deviceInfo.identifier, options.appIdentifier)
-                    : constants_2.LiveSyncPaths.IOS_DEVICE_PROJECT_ROOT_PATH;
-                if (!projectRoot) {
-                    this.$errors.fail("Unable to get application path on device.");
-                }
-                if (!options.getDirname) {
-                    projectRoot = path.join(projectRoot, constants_1.APP_FOLDER_NAME);
-                }
+    async getDeviceProjectRootPath(device, options) {
+        let projectRoot = "";
+        if (this.$mobileHelper.isApplePlatform(device.deviceInfo.platform)) {
+            projectRoot = device.isEmulator
+                ? await this.$iOSSimResolver.iOSSim.getApplicationPath(device.deviceInfo.identifier, options.appIdentifier)
+                : constants_2.LiveSyncPaths.IOS_DEVICE_PROJECT_ROOT_PATH;
+            if (!projectRoot) {
+                this.$errors.fail("Unable to get application path on device.");
             }
-            else if (this.$mobileHelper.isAndroidPlatform(device.deviceInfo.platform)) {
-                projectRoot = `${constants_2.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${options.appIdentifier}`;
-                if (!options.getDirname) {
-                    const hashService = (device).fileSystem.getDeviceHashService(options.appIdentifier);
-                    const hashFile = yield hashService.doesShasumFileExistsOnDevice();
-                    const syncFolderName = options.watch || hashFile
-                        ? constants_2.LiveSyncPaths.SYNC_DIR_NAME
-                        : constants_2.LiveSyncPaths.FULLSYNC_DIR_NAME;
-                    projectRoot = path.join(projectRoot, syncFolderName);
-                }
+            if (!options.getDirname) {
+                projectRoot = path.join(projectRoot, constants_1.APP_FOLDER_NAME);
             }
-            return (0, helpers_1.fromWindowsRelativePathToUnix)(projectRoot);
-        });
+        }
+        else if (this.$mobileHelper.isAndroidPlatform(device.deviceInfo.platform)) {
+            projectRoot = `${constants_2.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${options.appIdentifier}`;
+            if (!options.getDirname) {
+                const hashService = (device).fileSystem.getDeviceHashService(options.appIdentifier);
+                const hashFile = await hashService.doesShasumFileExistsOnDevice();
+                const syncFolderName = options.watch || hashFile
+                    ? constants_2.LiveSyncPaths.SYNC_DIR_NAME
+                    : constants_2.LiveSyncPaths.FULLSYNC_DIR_NAME;
+                projectRoot = path.join(projectRoot, syncFolderName);
+            }
+        }
+        return (0, helpers_1.fromWindowsRelativePathToUnix)(projectRoot);
     }
     getDeviceSyncZipPath(device) {
         return this.$mobileHelper.isApplePlatform(device.deviceInfo.platform) &&

package/lib/device-sockets/ios/app-debug-socket-proxy-factory.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.AppDebugSocketProxyFactory = void 0;
 const events_1 = require("events");
@@ -31,181 +22,175 @@ class AppDebugSocketProxyFactory extends events_1.EventEmitter {
     getTCPSocketProxy(deviceIdentifier, appId) {
         return this.deviceTcpServers[`${deviceIdentifier}-${appId}`];
     }
-    addTCPSocketProxy(device, appId, projectName, projectDir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const cacheKey = `${device.deviceInfo.identifier}-${appId}`;
-            const existingServer = this.deviceTcpServers[cacheKey];
-            if (existingServer) {
-                this.$errors.fail(`TCP socket proxy is already running for device '${device.deviceInfo.identifier}' and app '${appId}'`);
-            }
-            this.$logger.info("\nSetting up proxy...\nPress Ctrl + C to terminate, or disconnect.\n");
-            const server = net.createServer({
-                allowHalfOpen: true,
+    async addTCPSocketProxy(device, appId, projectName, projectDir) {
+        const cacheKey = `${device.deviceInfo.identifier}-${appId}`;
+        const existingServer = this.deviceTcpServers[cacheKey];
+        if (existingServer) {
+            this.$errors.fail(`TCP socket proxy is already running for device '${device.deviceInfo.identifier}' and app '${appId}'`);
+        }
+        this.$logger.info("\nSetting up proxy...\nPress Ctrl + C to terminate, or disconnect.\n");
+        const server = net.createServer({
+            allowHalfOpen: true,
+        });
+        this.deviceTcpServers[cacheKey] = server;
+        server.on("connection", async (frontendSocket) => {
+            this.$logger.info("Frontend client connected.");
+            frontendSocket.on("end", () => {
+                this.$logger.info("Frontend socket closed!");
+                if (!this.$options.watch) {
+                    process.exit(0);
+                }
             });
-            this.deviceTcpServers[cacheKey] = server;
-            server.on("connection", (frontendSocket) => __awaiter(this, void 0, void 0, function* () {
-                this.$logger.info("Frontend client connected.");
-                frontendSocket.on("end", () => {
-                    this.$logger.info("Frontend socket closed!");
-                    if (!this.$options.watch) {
-                        process.exit(0);
-                    }
-                });
-                const appDebugSocket = yield device.getDebugSocket(appId, projectName, projectDir);
-                this.$logger.info("Backend socket created.");
-                appDebugSocket.on("end", () => {
-                    this.$logger.info("Backend socket closed!");
-                    if (!this.$options.watch) {
-                        process.exit(0);
-                    }
-                });
-                frontendSocket.on("close", () => __awaiter(this, void 0, void 0, function* () {
-                    this.$logger.info("Frontend socket closed");
-                    yield device.destroyDebugSocket(appId);
-                }));
-                appDebugSocket.on("close", () => {
-                    this.$logger.info("Backend socket closed");
-                    frontendSocket.destroy();
-                    server.close();
-                    delete this.deviceTcpServers[cacheKey];
-                });
-                appDebugSocket.pipe(frontendSocket);
-                frontendSocket.pipe(appDebugSocket);
-                frontendSocket.resume();
-            }));
-            const socketFileLocation = yield this.$tempService.path({
-                suffix: ".sock",
+            const appDebugSocket = await device.getDebugSocket(appId, projectName, projectDir);
+            this.$logger.info("Backend socket created.");
+            appDebugSocket.on("end", () => {
+                this.$logger.info("Backend socket closed!");
+                if (!this.$options.watch) {
+                    process.exit(0);
+                }
+            });
+            frontendSocket.on("close", async () => {
+                this.$logger.info("Frontend socket closed");
+                await device.destroyDebugSocket(appId);
+            });
+            appDebugSocket.on("close", () => {
+                this.$logger.info("Backend socket closed");
+                frontendSocket.destroy();
+                server.close();
+                delete this.deviceTcpServers[cacheKey];
             });
-            server.listen(socketFileLocation);
-            if (!this.$options.client) {
-                this.$logger.info("socket-file-location: " + socketFileLocation);
-            }
-            return server;
+            appDebugSocket.pipe(frontendSocket);
+            frontendSocket.pipe(appDebugSocket);
+            frontendSocket.resume();
         });
-    }
-    ensureWebSocketProxy(device, appId, projectName, projectDir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const existingWebProxy = this.deviceWebServers[`${device.deviceInfo.identifier}-${appId}`];
-            const result = existingWebProxy ||
-                (yield this.addWebSocketProxy(device, appId, projectName, projectDir));
-            // TODO: do not remove till VSCode waits for this message in order to reattach
-            this.$logger.info("Opened localhost " + result.options.port);
-            return result;
+        const socketFileLocation = await this.$tempService.path({
+            suffix: ".sock",
         });
+        server.listen(socketFileLocation);
+        if (!this.$options.client) {
+            this.$logger.info("socket-file-location: " + socketFileLocation);
+        }
+        return server;
     }
-    addWebSocketProxy(device, appId, projectName, projectDir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let clientConnectionLockRelease;
-            const cacheKey = `${device.deviceInfo.identifier}-${appId}`;
-            const existingServer = this.deviceWebServers[cacheKey];
-            if (existingServer) {
-                this.$errors.fail(`Web socket proxy is already running for device '${device.deviceInfo.identifier}' and app '${appId}'`);
-            }
-            // NOTE: We will try to provide command line options to select ports, at least on the localhost.
-            const localPort = yield this.$net.getAvailablePortInRange(41000);
-            this.$logger.info("\nSetting up debugger proxy...\nPress Ctrl + C to terminate, or disconnect.\n");
-            // NB: When the inspector frontend connects we might not have connected to the inspector backend yet.
-            // That's why we use the verifyClient callback of the websocket server to stall the upgrade request until we connect.
-            // We store the socket that connects us to the device in the upgrade request object itself and later on retrieve it
-            // in the connection callback.
-            let currentAppSocket = null;
-            let currentWebSocket = null;
-            const server = new ws.Server({
-                port: localPort,
-                verifyClient: (info, callback) => __awaiter(this, void 0, void 0, function* () {
-                    let acceptHandshake = true;
-                    clientConnectionLockRelease = null;
-                    try {
-                        clientConnectionLockRelease = yield this.$lockService.lock(`debug-connection-${device.deviceInfo.identifier}-${appId}.lock`);
-                        this.$logger.info("Frontend client connected.");
-                        let appDebugSocket;
-                        if (currentAppSocket) {
-                            currentAppSocket.removeAllListeners();
-                            currentAppSocket = null;
-                            if (currentWebSocket) {
-                                currentWebSocket.removeAllListeners();
-                                currentWebSocket.close();
-                                currentWebSocket = null;
-                            }
-                            yield device.destroyDebugSocket(appId);
-                        }
-                        appDebugSocket = yield device.getDebugSocket(appId, projectName, projectDir);
-                        currentAppSocket = appDebugSocket;
-                        this.$logger.info("Backend socket created.");
-                        info.req["__deviceSocket"] = appDebugSocket;
-                    }
-                    catch (err) {
-                        if (clientConnectionLockRelease) {
-                            clientConnectionLockRelease();
-                        }
-                        err.deviceIdentifier = device.deviceInfo.identifier;
-                        this.$logger.trace(err);
-                        this.emit(constants_1.CONNECTION_ERROR_EVENT_NAME, err);
-                        acceptHandshake = false;
-                        this.$logger.warn(`Cannot connect to device socket. The error message is '${err.message}'.`);
-                    }
-                    callback(acceptHandshake);
-                }),
-            });
-            this.deviceWebServers[cacheKey] = server;
-            server.on("connection", (webSocket, req) => {
-                currentWebSocket = webSocket;
-                const encoding = "utf16le";
-                const appDebugSocket = req["__deviceSocket"];
-                const packets = new ios_device_lib_1.MessageUnpackStream();
-                appDebugSocket.pipe(packets);
-                packets.on("data", (buffer) => {
-                    const message = buffer.toString(encoding);
-                    if (webSocket.readyState === webSocket.OPEN) {
-                        if (process.env.DEBUG_DEVTOOLS_SOCKETS) {
-                            console.log({
-                                msgFromRuntime: JSON.parse(message),
-                            });
+    async ensureWebSocketProxy(device, appId, projectName, projectDir) {
+        const existingWebProxy = this.deviceWebServers[`${device.deviceInfo.identifier}-${appId}`];
+        const result = existingWebProxy ||
+            (await this.addWebSocketProxy(device, appId, projectName, projectDir));
+        // TODO: do not remove till VSCode waits for this message in order to reattach
+        this.$logger.info("Opened localhost " + result.options.port);
+        return result;
+    }
+    async addWebSocketProxy(device, appId, projectName, projectDir) {
+        let clientConnectionLockRelease;
+        const cacheKey = `${device.deviceInfo.identifier}-${appId}`;
+        const existingServer = this.deviceWebServers[cacheKey];
+        if (existingServer) {
+            this.$errors.fail(`Web socket proxy is already running for device '${device.deviceInfo.identifier}' and app '${appId}'`);
+        }
+        // NOTE: We will try to provide command line options to select ports, at least on the localhost.
+        const localPort = await this.$net.getAvailablePortInRange(41000);
+        this.$logger.info("\nSetting up debugger proxy...\nPress Ctrl + C to terminate, or disconnect.\n");
+        // NB: When the inspector frontend connects we might not have connected to the inspector backend yet.
+        // That's why we use the verifyClient callback of the websocket server to stall the upgrade request until we connect.
+        // We store the socket that connects us to the device in the upgrade request object itself and later on retrieve it
+        // in the connection callback.
+        let currentAppSocket = null;
+        let currentWebSocket = null;
+        const server = new ws.Server({
+            port: localPort,
+            verifyClient: async (info, callback) => {
+                let acceptHandshake = true;
+                clientConnectionLockRelease = null;
+                try {
+                    clientConnectionLockRelease = await this.$lockService.lock(`debug-connection-${device.deviceInfo.identifier}-${appId}.lock`);
+                    this.$logger.info("Frontend client connected.");
+                    let appDebugSocket;
+                    if (currentAppSocket) {
+                        currentAppSocket.removeAllListeners();
+                        currentAppSocket = null;
+                        if (currentWebSocket) {
+                            currentWebSocket.removeAllListeners();
+                            currentWebSocket.close();
+                            currentWebSocket = null;
                         }
-                        webSocket.send(message);
+                        await device.destroyDebugSocket(appId);
                     }
-                    else {
-                        this.$logger.trace(`Received message ${message}, but unable to send it to webSocket as its state is: ${webSocket.readyState}`);
+                    appDebugSocket = await device.getDebugSocket(appId, projectName, projectDir);
+                    currentAppSocket = appDebugSocket;
+                    this.$logger.info("Backend socket created.");
+                    info.req["__deviceSocket"] = appDebugSocket;
+                }
+                catch (err) {
+                    if (clientConnectionLockRelease) {
+                        clientConnectionLockRelease();
                     }
-                });
-                webSocket.on("error", (err) => {
-                    this.$logger.trace("Error on debugger websocket", err);
-                });
-                appDebugSocket.on("error", (err) => {
-                    this.$logger.trace("Error on debugger deviceSocket", err);
-                });
-                webSocket.on("message", (message) => {
-                    const msg = message.toString();
+                    err.deviceIdentifier = device.deviceInfo.identifier;
+                    this.$logger.trace(err);
+                    this.emit(constants_1.CONNECTION_ERROR_EVENT_NAME, err);
+                    acceptHandshake = false;
+                    this.$logger.warn(`Cannot connect to device socket. The error message is '${err.message}'.`);
+                }
+                callback(acceptHandshake);
+            },
+        });
+        this.deviceWebServers[cacheKey] = server;
+        server.on("connection", (webSocket, req) => {
+            currentWebSocket = webSocket;
+            const encoding = "utf16le";
+            const appDebugSocket = req["__deviceSocket"];
+            const packets = new ios_device_lib_1.MessageUnpackStream();
+            appDebugSocket.pipe(packets);
+            packets.on("data", (buffer) => {
+                const message = buffer.toString(encoding);
+                if (webSocket.readyState === webSocket.OPEN) {
                     if (process.env.DEBUG_DEVTOOLS_SOCKETS) {
                         console.log({
-                            msgFromDevtools: JSON.parse(msg),
+                            msgFromRuntime: JSON.parse(message),
                         });
                     }
-                    const length = Buffer.byteLength(msg, encoding);
-                    const payload = Buffer.allocUnsafe(length + 4);
-                    payload.writeInt32BE(length, 0);
-                    payload.write(msg, 4, length, encoding);
-                    appDebugSocket.write(payload);
-                });
-                appDebugSocket.on("close", () => {
-                    currentAppSocket = null;
-                    this.$logger.trace("Backend socket closed!");
-                    webSocket.close();
-                });
-                webSocket.on("close", () => __awaiter(this, void 0, void 0, function* () {
-                    currentWebSocket = null;
-                    this.$logger.trace("Frontend socket closed!");
-                    appDebugSocket.unpipe(packets);
-                    packets.destroy();
-                    yield device.destroyDebugSocket(appId);
-                    if (!this.$options.watch) {
-                        process.exit(0);
-                    }
-                }));
-                clientConnectionLockRelease();
+                    webSocket.send(message);
+                }
+                else {
+                    this.$logger.trace(`Received message ${message}, but unable to send it to webSocket as its state is: ${webSocket.readyState}`);
+                }
+            });
+            webSocket.on("error", (err) => {
+                this.$logger.trace("Error on debugger websocket", err);
+            });
+            appDebugSocket.on("error", (err) => {
+                this.$logger.trace("Error on debugger deviceSocket", err);
+            });
+            webSocket.on("message", (message) => {
+                const msg = message.toString();
+                if (process.env.DEBUG_DEVTOOLS_SOCKETS) {
+                    console.log({
+                        msgFromDevtools: JSON.parse(msg),
+                    });
+                }
+                const length = Buffer.byteLength(msg, encoding);
+                const payload = Buffer.allocUnsafe(length + 4);
+                payload.writeInt32BE(length, 0);
+                payload.write(msg, 4, length, encoding);
+                appDebugSocket.write(payload);
+            });
+            appDebugSocket.on("close", () => {
+                currentAppSocket = null;
+                this.$logger.trace("Backend socket closed!");
+                webSocket.close();
+            });
+            webSocket.on("close", async () => {
+                currentWebSocket = null;
+                this.$logger.trace("Frontend socket closed!");
+                appDebugSocket.unpipe(packets);
+                packets.destroy();
+                await device.destroyDebugSocket(appId);
+                if (!this.$options.watch) {
+                    process.exit(0);
+                }
             });
-            return server;
+            clientConnectionLockRelease();
         });
+        return server;
     }
     removeAllProxies() {
         let deviceId;

package/lib/device-sockets/ios/notification.js

@@ -24,10 +24,10 @@ class IOSNotification extends events_1.EventEmitter {
         return `${appId}:NativeScript.Debug.${notification}`;
     }
 }
+exports.IOSNotification = IOSNotification;
 IOSNotification.REFRESH_REQUEST_NOTIFICATION_NAME = "RefreshRequest";
 IOSNotification.APP_REFRESH_STARTED_NOTIFICATION_NAME = "AppRefreshStarted";
 IOSNotification.ATTACH_REQUEST_NOTIFICATION_NAME = "AttachRequest";
 IOSNotification.READY_FOR_ATTACH_NOTIFICATION_NAME = "ReadyForAttach";
-exports.IOSNotification = IOSNotification;
 yok_1.injector.register("iOSNotification", IOSNotification);
 //# sourceMappingURL=notification.js.map

package/lib/device-sockets/ios/socket-request-executor.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.IOSSocketRequestExecutor = void 0;
 const constants = require("../../common/constants");
@@ -18,40 +9,34 @@ class IOSSocketRequestExecutor {
         this.$iOSNotification = $iOSNotification;
         this.$iOSNotificationService = $iOSNotificationService;
     }
-    executeAttachRequest(device, timeout, appId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const deviceId = device.deviceInfo.identifier;
-            const mainRequestName = this.$iOSNotification.getAttachRequest(appId, deviceId);
-            const readyRequestName = this.$iOSNotification.getReadyForAttach(appId);
-            yield this.executeRequest(mainRequestName, readyRequestName, appId, deviceId, timeout);
-        });
+    async executeAttachRequest(device, timeout, appId) {
+        const deviceId = device.deviceInfo.identifier;
+        const mainRequestName = this.$iOSNotification.getAttachRequest(appId, deviceId);
+        const readyRequestName = this.$iOSNotification.getReadyForAttach(appId);
+        await this.executeRequest(mainRequestName, readyRequestName, appId, deviceId, timeout);
     }
-    executeRefreshRequest(device, timeout, appId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const deviceId = device.deviceInfo.identifier;
-            const mainRequestName = this.$iOSNotification.getRefreshRequest(appId);
-            const refreshRequestStartedName = this.$iOSNotification.getAppRefreshStarted(appId);
-            const result = yield this.executeRequest(mainRequestName, refreshRequestStartedName, appId, deviceId, timeout);
-            return result;
-        });
+    async executeRefreshRequest(device, timeout, appId) {
+        const deviceId = device.deviceInfo.identifier;
+        const mainRequestName = this.$iOSNotification.getRefreshRequest(appId);
+        const refreshRequestStartedName = this.$iOSNotification.getAppRefreshStarted(appId);
+        const result = await this.executeRequest(mainRequestName, refreshRequestStartedName, appId, deviceId, timeout);
+        return result;
     }
-    executeRequest(mainRequestName, successfulyExecutedNotificationName, appId, deviceId, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let isSuccessful = false;
-            try {
-                // We should create this promise here because we need to send the ObserveNotification on the device
-                // before we send the PostNotification.
-                const socket = yield this.$iOSNotificationService.postNotification(deviceId, successfulyExecutedNotificationName, constants.IOS_OBSERVE_NOTIFICATION_COMMAND_TYPE);
-                const notificationPromise = this.$iOSNotificationService.awaitNotification(deviceId, +socket, timeout);
-                yield this.$iOSNotificationService.postNotification(deviceId, mainRequestName);
-                yield notificationPromise;
-                isSuccessful = true;
-            }
-            catch (e) {
-                this.$errors.fail(`The application ${appId} does not appear to be running on ${deviceId} or is not built with debugging enabled. Try starting the application manually.`);
-            }
-            return isSuccessful;
-        });
+    async executeRequest(mainRequestName, successfulyExecutedNotificationName, appId, deviceId, timeout) {
+        let isSuccessful = false;
+        try {
+            // We should create this promise here because we need to send the ObserveNotification on the device
+            // before we send the PostNotification.
+            const socket = await this.$iOSNotificationService.postNotification(deviceId, successfulyExecutedNotificationName, constants.IOS_OBSERVE_NOTIFICATION_COMMAND_TYPE);
+            const notificationPromise = this.$iOSNotificationService.awaitNotification(deviceId, +socket, timeout);
+            await this.$iOSNotificationService.postNotification(deviceId, mainRequestName);
+            await notificationPromise;
+            isSuccessful = true;
+        }
+        catch (e) {
+            this.$errors.fail(`The application ${appId} does not appear to be running on ${deviceId} or is not built with debugging enabled. Try starting the application manually.`);
+        }
+        return isSuccessful;
     }
 }
 exports.IOSSocketRequestExecutor = IOSSocketRequestExecutor;