nativescript 8.9.0-dev.1 → 8.9.0-dev.2

package/lib/detached-processes/cleanup-process.js

@@ -1,5 +1,16 @@
 "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.
 const fs = require("fs");
 const path = require("path");
 const shelljs = require("shelljs");
@@ -11,6 +22,7 @@ if (!pathToBootstrap || !fs.existsSync(pathToBootstrap)) {
     throw new Error("Invalid path to bootstrap.");
 }
 const logFile = process.argv[3];
+// After requiring the bootstrap we can use $injector
 require(pathToBootstrap);
 const fileLogService = yok_1.injector.resolve(file_log_service_1.FileLogService, {
     logFile,
@@ -20,13 +32,13 @@ const commandsInfos = [];
 const filesToDelete = [];
 const jsCommands = [];
 const requests = [];
-const executeRequest = async (request) => {
+const executeRequest = (request) => __awaiter(void 0, void 0, void 0, function* () {
     const $httpClient = yok_1.injector.resolve("httpClient");
     try {
         fileLogService.logData({
             message: `Start executing request: ${request.method} ${request.url}`,
         });
-        const response = await $httpClient.httpRequest({
+        const response = yield $httpClient.httpRequest({
             url: request.url,
             method: request.method,
             headers: request.headers,
@@ -42,14 +54,14 @@ const executeRequest = async (request) => {
             message: `Unable to execute request: ${request.method} ${request.url}`,
         });
     }
-};
-const executeJSCleanup = async (jsCommand) => {
+});
+const executeJSCleanup = (jsCommand) => __awaiter(void 0, void 0, void 0, function* () {
     const $childProcess = yok_1.injector.resolve("childProcess");
     try {
         fileLogService.logData({
             message: `Start executing action for file: ${jsCommand.filePath} and data ${JSON.stringify(jsCommand.data)}`,
         });
-        await $childProcess.trySpawnFromCloseEvent(process.execPath, [
+        yield $childProcess.trySpawnFromCloseEvent(process.execPath, [
             path.join(__dirname, "cleanup-js-subprocess.js"),
             pathToBootstrap,
             logFile,
@@ -63,24 +75,24 @@ const executeJSCleanup = async (jsCommand) => {
     catch (err) {
         fileLogService.logData({
             message: `Unable to execute action for file ${jsCommand.filePath} with data ${JSON.stringify(jsCommand.data)}. Error is: ${err}.`,
-            type: "Error",
+            type: "Error" /* FileLogMessageType.Error */,
         });
     }
-};
-const executeCleanup = async () => {
+});
+const executeCleanup = () => __awaiter(void 0, void 0, void 0, function* () {
     const $childProcess = yok_1.injector.resolve("childProcess");
     for (const request of requests) {
-        await executeRequest(request);
+        yield executeRequest(request);
     }
     for (const jsCommand of jsCommands) {
-        await executeJSCleanup(jsCommand);
+        yield executeJSCleanup(jsCommand);
     }
     for (const commandInfo of commandsInfos) {
         try {
             fileLogService.logData({
                 message: `Start executing command: ${JSON.stringify(commandInfo)}`,
             });
-            await $childProcess.trySpawnFromCloseEvent(commandInfo.command, commandInfo.args, commandInfo.options || {}, { throwError: true, timeout: commandInfo.timeout || 3000 });
+            yield $childProcess.trySpawnFromCloseEvent(commandInfo.command, commandInfo.args, commandInfo.options || {}, { throwError: true, timeout: commandInfo.timeout || 3000 });
             fileLogService.logData({
                 message: `Successfully executed command: ${JSON.stringify(commandInfo)}`,
             });
@@ -88,7 +100,7 @@ const executeCleanup = async () => {
         catch (err) {
             fileLogService.logData({
                 message: `Unable to execute command: ${JSON.stringify(commandInfo)}. Error is: ${err}.`,
-                type: "Error",
+                type: "Error" /* FileLogMessageType.Error */,
             });
         }
     }
@@ -102,13 +114,13 @@ const executeCleanup = async () => {
         catch (err) {
             fileLogService.logData({
                 message: `Unable to delete files: ${JSON.stringify(filesToDelete)}. Error is: ${err}.`,
-                type: "Error",
+                type: "Error" /* FileLogMessageType.Error */,
             });
         }
     }
     fileLogService.logData({ message: `cleanup-process finished` });
     process.exit();
-};
+});
 const addCleanupAction = (commandInfo) => {
     if (_.some(commandsInfos, (currentCommandInfo) => _.isEqual(currentCommandInfo, commandInfo))) {
         fileLogService.logData({
@@ -219,54 +231,55 @@ const removeJSFile = (jsCommand) => {
         });
     }
 };
-process.on("message", async (cleanupProcessMessage) => {
+process.on("message", (cleanupProcessMessage) => __awaiter(void 0, void 0, void 0, function* () {
     fileLogService.logData({
         message: `cleanup-process received message of type: ${JSON.stringify(cleanupProcessMessage)}`,
     });
     switch (cleanupProcessMessage.messageType) {
-        case "AddCleanCommand":
+        case "AddCleanCommand" /* CleanupProcessMessage.AddCleanCommand */:
             addCleanupAction(cleanupProcessMessage.commandInfo);
             break;
-        case "RemoveCleanCommand":
+        case "RemoveCleanCommand" /* CleanupProcessMessage.RemoveCleanCommand */:
             removeCleanupAction(cleanupProcessMessage.commandInfo);
             break;
-        case "AddRequest":
+        case "AddRequest" /* CleanupProcessMessage.AddRequest */:
             addRequest(cleanupProcessMessage.requestInfo);
             break;
-        case "RemoveRequest":
+        case "RemoveRequest" /* CleanupProcessMessage.RemoveRequest */:
             removeRequest(cleanupProcessMessage.requestInfo);
             break;
-        case "AddDeleteFileAction":
+        case "AddDeleteFileAction" /* CleanupProcessMessage.AddDeleteFileAction */:
             addDeleteAction(cleanupProcessMessage.filePath);
             break;
-        case "RemoveDeleteFileAction":
+        case "RemoveDeleteFileAction" /* CleanupProcessMessage.RemoveDeleteFileAction */:
             removeDeleteAction(cleanupProcessMessage.filePath);
             break;
-        case "AddJSFileToRequire":
+        case "AddJSFileToRequire" /* CleanupProcessMessage.AddJSFileToRequire */:
             const jsCleanupMessage = cleanupProcessMessage;
             addJSFile(jsCleanupMessage.jsCommand);
             break;
-        case "RemoveJSFileToRequire":
+        case "RemoveJSFileToRequire" /* CleanupProcessMessage.RemoveJSFileToRequire */:
             const msgToRemove = cleanupProcessMessage;
             removeJSFile(msgToRemove.jsCommand);
             break;
         default:
             fileLogService.logData({
                 message: `Unable to handle message of type ${cleanupProcessMessage.messageType}. Full message is ${JSON.stringify(cleanupProcessMessage)}`,
-                type: "Error",
+                type: "Error" /* FileLogMessageType.Error */,
             });
             break;
     }
-});
-process.on("disconnect", async () => {
+}));
+process.on("disconnect", () => __awaiter(void 0, void 0, void 0, function* () {
     fileLogService.logData({
         message: "cleanup-process received process.disconnect event",
     });
-    await executeCleanup();
+    yield executeCleanup();
     yok_1.injector.dispose();
     process.exit();
-});
+}));
 fileLogService.logData({
-    message: `cleanup-process will send ${"ProcessReadyToReceive"} message`,
+    message: `cleanup-process will send ${"ProcessReadyToReceive" /* DetachedProcessMessages.ProcessReadyToReceive */} message`,
 });
-process.send("ProcessReadyToReceive");
+process.send("ProcessReadyToReceive" /* DetachedProcessMessages.ProcessReadyToReceive */);
+//# sourceMappingURL=cleanup-process.js.map

package/lib/detached-processes/file-log-service.js

@@ -11,10 +11,11 @@ class FileLogService {
     logData(fileLoggingMessage) {
         if (this.logFile && fileLoggingMessage && fileLoggingMessage.message) {
             fileLoggingMessage.type =
-                fileLoggingMessage.type || "Info";
+                fileLoggingMessage.type || "Info" /* FileLogMessageType.Info */;
             const formattedDate = (0, helpers_1.getFixedLengthDateString)();
             this.$fs.appendFile(this.logFile, `[${formattedDate}] [${fileLoggingMessage.type}] ${fileLoggingMessage.message}${os_1.EOL}`);
         }
     }
 }
 exports.FileLogService = FileLogService;
+//# sourceMappingURL=file-log-service.js.map

package/lib/device-path-provider.js

@@ -1,4 +1,13 @@
 "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");
@@ -12,31 +21,33 @@ class DevicePathProvider {
         this.$iOSSimResolver = $iOSSimResolver;
         this.$errors = $errors;
     }
-    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.");
+    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);
+                }
             }
-            if (!options.getDirname) {
-                projectRoot = path.join(projectRoot, constants_1.APP_FOLDER_NAME);
+            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);
+                }
             }
-        }
-        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);
+            return (0, helpers_1.fromWindowsRelativePathToUnix)(projectRoot);
+        });
     }
     getDeviceSyncZipPath(device) {
         return this.$mobileHelper.isApplePlatform(device.deviceInfo.platform) &&
@@ -47,3 +58,4 @@ class DevicePathProvider {
 }
 exports.DevicePathProvider = DevicePathProvider;
 yok_1.injector.register("devicePathProvider", DevicePathProvider);
+//# sourceMappingURL=device-path-provider.js.map

package/lib/device-sockets/ios/app-debug-socket-proxy-factory.js

@@ -1,4 +1,13 @@
 "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");
@@ -22,169 +31,181 @@ class AppDebugSocketProxyFactory extends events_1.EventEmitter {
     getTCPSocketProxy(deviceIdentifier, appId) {
         return this.deviceTcpServers[`${deviceIdentifier}-${appId}`];
     }
-    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);
-                }
-            });
-            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);
-                }
+    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,
             });
-            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];
+            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",
             });
-            appDebugSocket.pipe(frontendSocket);
-            frontendSocket.pipe(appDebugSocket);
-            frontendSocket.resume();
+            server.listen(socketFileLocation);
+            if (!this.$options.client) {
+                this.$logger.info("socket-file-location: " + socketFileLocation);
+            }
+            return server;
         });
-        const socketFileLocation = await this.$tempService.path({
-            suffix: ".sock",
-        });
-        server.listen(socketFileLocation);
-        if (!this.$options.client) {
-            this.$logger.info("socket-file-location: " + socketFileLocation);
-        }
-        return server;
     }
-    async ensureWebSocketProxy(device, appId, projectName, projectDir) {
-        const existingWebProxy = this.deviceWebServers[`${device.deviceInfo.identifier}-${appId}`];
-        const result = existingWebProxy ||
-            (await this.addWebSocketProxy(device, appId, projectName, projectDir));
-        this.$logger.info("Opened localhost " + result.options.port);
-        return result;
+    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;
+        });
     }
-    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}'`);
-        }
-        const localPort = await this.$net.getAvailablePortInRange(41000);
-        this.$logger.info("\nSetting up debugger proxy...\nPress Ctrl + C to terminate, or disconnect.\n");
-        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;
+    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),
+                            });
                         }
-                        await device.destroyDebugSocket(appId);
+                        webSocket.send(message);
                     }
-                    appDebugSocket = await device.getDebugSocket(appId, projectName, projectDir);
-                    currentAppSocket = appDebugSocket;
-                    this.$logger.info("Backend socket created.");
-                    info.req["__deviceSocket"] = appDebugSocket;
-                }
-                catch (err) {
-                    if (clientConnectionLockRelease) {
-                        clientConnectionLockRelease();
+                    else {
+                        this.$logger.trace(`Received message ${message}, but unable to send it to webSocket as its state is: ${webSocket.readyState}`);
                     }
-                    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) {
+                });
+                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({
-                            msgFromRuntime: JSON.parse(message),
+                            msgFromDevtools: JSON.parse(msg),
                         });
                     }
-                    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);
-                }
+                    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();
             });
-            clientConnectionLockRelease();
+            return server;
         });
-        return server;
     }
     removeAllProxies() {
         let deviceId;
@@ -200,3 +221,4 @@ class AppDebugSocketProxyFactory extends events_1.EventEmitter {
 }
 exports.AppDebugSocketProxyFactory = AppDebugSocketProxyFactory;
 yok_1.injector.register("appDebugSocketProxyFactory", AppDebugSocketProxyFactory);
+//# sourceMappingURL=app-debug-socket-proxy-factory.js.map

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

@@ -6,6 +6,8 @@ const constants_1 = require("../../common/constants");
 const yok_1 = require("../../common/yok");
 class IOSNotification extends events_1.EventEmitter {
     getAttachRequest(appId, deviceId) {
+        // It could be too early to emit this event, but we rely that if you construct attach request,
+        // you will execute it immediately.
         this.emit(constants_1.ATTACH_REQUEST_EVENT_NAME, { deviceId, appId });
         return this.formatNotification(IOSNotification.ATTACH_REQUEST_NOTIFICATION_NAME, appId);
     }
@@ -22,9 +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