nativescript 8.9.0-dev.2 → 8.9.0-dev.3

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

@@ -1,16 +1,5 @@
 "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");
@@ -22,7 +11,6 @@ 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,
@@ -32,13 +20,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 +42,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,
@@ -75,24 +63,24 @@ const executeJSCleanup = (jsCommand) => __awaiter(void 0, void 0, void 0, functi
     catch (err) {
         fileLogService.logData({
             message: `Unable to execute action for file ${jsCommand.filePath} with data ${JSON.stringify(jsCommand.data)}. Error is: ${err}.`,
-            type: "Error" /* FileLogMessageType.Error */,
+            type: "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)}`,
             });
@@ -100,7 +88,7 @@ const executeCleanup = () => __awaiter(void 0, void 0, void 0, function* () {
         catch (err) {
             fileLogService.logData({
                 message: `Unable to execute command: ${JSON.stringify(commandInfo)}. Error is: ${err}.`,
-                type: "Error" /* FileLogMessageType.Error */,
+                type: "Error",
             });
         }
     }
@@ -114,13 +102,13 @@ const executeCleanup = () => __awaiter(void 0, void 0, void 0, function* () {
         catch (err) {
             fileLogService.logData({
                 message: `Unable to delete files: ${JSON.stringify(filesToDelete)}. Error is: ${err}.`,
-                type: "Error" /* FileLogMessageType.Error */,
+                type: "Error",
             });
         }
     }
     fileLogService.logData({ message: `cleanup-process finished` });
     process.exit();
-});
+};
 const addCleanupAction = (commandInfo) => {
     if (_.some(commandsInfos, (currentCommandInfo) => _.isEqual(currentCommandInfo, commandInfo))) {
         fileLogService.logData({
@@ -231,55 +219,54 @@ 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)}`,
     });
     switch (cleanupProcessMessage.messageType) {
-        case "AddCleanCommand" /* CleanupProcessMessage.AddCleanCommand */:
+        case "AddCleanCommand":
             addCleanupAction(cleanupProcessMessage.commandInfo);
             break;
-        case "RemoveCleanCommand" /* CleanupProcessMessage.RemoveCleanCommand */:
+        case "RemoveCleanCommand":
             removeCleanupAction(cleanupProcessMessage.commandInfo);
             break;
-        case "AddRequest" /* CleanupProcessMessage.AddRequest */:
+        case "AddRequest":
             addRequest(cleanupProcessMessage.requestInfo);
             break;
-        case "RemoveRequest" /* CleanupProcessMessage.RemoveRequest */:
+        case "RemoveRequest":
             removeRequest(cleanupProcessMessage.requestInfo);
             break;
-        case "AddDeleteFileAction" /* CleanupProcessMessage.AddDeleteFileAction */:
+        case "AddDeleteFileAction":
             addDeleteAction(cleanupProcessMessage.filePath);
             break;
-        case "RemoveDeleteFileAction" /* CleanupProcessMessage.RemoveDeleteFileAction */:
+        case "RemoveDeleteFileAction":
             removeDeleteAction(cleanupProcessMessage.filePath);
             break;
-        case "AddJSFileToRequire" /* CleanupProcessMessage.AddJSFileToRequire */:
+        case "AddJSFileToRequire":
             const jsCleanupMessage = cleanupProcessMessage;
             addJSFile(jsCleanupMessage.jsCommand);
             break;
-        case "RemoveJSFileToRequire" /* CleanupProcessMessage.RemoveJSFileToRequire */:
+        case "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" /* FileLogMessageType.Error */,
+                type: "Error",
             });
             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`,
+    message: `cleanup-process will send ${"ProcessReadyToReceive"} message`,
 });
-process.send("ProcessReadyToReceive" /* DetachedProcessMessages.ProcessReadyToReceive */);
-//# sourceMappingURL=cleanup-process.js.map
+process.send("ProcessReadyToReceive");

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

@@ -11,11 +11,10 @@ class FileLogService {
     logData(fileLoggingMessage) {
         if (this.logFile && fileLoggingMessage && fileLoggingMessage.message) {
             fileLoggingMessage.type =
-                fileLoggingMessage.type || "Info" /* FileLogMessageType.Info */;
+                fileLoggingMessage.type || "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,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) &&
@@ -58,4 +47,3 @@ 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,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,169 @@ 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));
+        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;
                         }
-                        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;
@@ -221,4 +200,3 @@ class AppDebugSocketProxyFactory extends events_1.EventEmitter {
 }
 exports.AppDebugSocketProxyFactory = AppDebugSocketProxyFactory;
 yok_1.injector.register("appDebugSocketProxyFactory", AppDebugSocketProxyFactory);
-//# sourceMappingURL=app-debug-socket-proxy-factory.js.map