nx 22.3.3 → 22.4.0-beta.1

package/src/daemon/client/client.js

@@ -16,6 +16,7 @@ const nx_json_1 = require("../../config/nx-json");
 const configuration_1 = require("../../config/configuration");
 const promised_based_queue_1 = require("../../utils/promised-based-queue");
 const daemon_socket_messenger_1 = require("./daemon-socket-messenger");
+const logger_1 = require("../logger");
 const cache_1 = require("../cache");
 const is_nx_version_mismatch_1 = require("../is-nx-version-mismatch");
 const error_types_1 = require("../../project-graph/error-types");
@@ -49,6 +50,10 @@ var DaemonStatus;
     DaemonStatus[DaemonStatus["DISCONNECTED"] = 1] = "DISCONNECTED";
     DaemonStatus[DaemonStatus["CONNECTED"] = 2] = "CONNECTED";
 })(DaemonStatus || (DaemonStatus = {}));
+const WAIT_FOR_SERVER_CONFIG = {
+    delayMs: 10,
+    maxAttempts: 6000, // 6000 * 10ms = 60 seconds
+};
 class DaemonClient {
     constructor() {
         this._daemonStatus = DaemonStatus.DISCONNECTED;
@@ -56,6 +61,11 @@ class DaemonClient {
         this._daemonReady = null;
         this._out = null;
         this._err = null;
+        this.fileWatcherReconnecting = false;
+        this.fileWatcherCallbacks = new Map();
+        this.fileWatcherConfigs = new Map();
+        this.projectGraphListenerReconnecting = false;
+        this.projectGraphListenerCallbacks = new Map();
         try {
             this.nxJson = (0, configuration_1.readNxJson)();
         }
@@ -117,6 +127,11 @@ class DaemonClient {
         this._err?.close();
         this._out = null;
         this._err = null;
+        // Clean up file watcher and project graph listener connections
+        this.fileWatcherMessenger?.close();
+        this.fileWatcherMessenger = undefined;
+        this.projectGraphListenerMessenger?.close();
+        this.projectGraphListenerMessenger = undefined;
         this._daemonStatus = DaemonStatus.DISCONNECTED;
         this._waitForDaemonReady = new Promise((resolve) => (this._daemonReady = resolve));
     }
@@ -129,6 +144,11 @@ class DaemonClient {
             throw daemonProcessException('Unable to connect to daemon: no socket path available');
         }
     }
+    parseMessage(message) {
+        return (0, consume_messages_from_socket_1.isJsonMessage)(message)
+            ? JSON.parse(message)
+            : (0, node_v8_1.deserialize)(Buffer.from(message, 'binary'));
+    }
     async requestShutdown() {
         return this.sendToDaemonViaQueue({ type: 'REQUEST_SHUTDOWN' });
     }
@@ -161,7 +181,7 @@ class DaemonClient {
     async getAllFileData() {
         return await this.sendToDaemonViaQueue({ type: 'REQUEST_FILE_DATA' });
     }
-    hashTasks(runnerOptions, tasks, taskGraph, env) {
+    hashTasks(runnerOptions, tasks, taskGraph, env, cwd) {
         return this.sendToDaemonViaQueue({
             type: 'HASH_TASKS',
             runnerOptions,
@@ -170,6 +190,7 @@ class DaemonClient {
                 : env,
             tasks,
             taskGraph,
+            cwd,
         });
     }
     async registerFileWatcher(config, callback) {
@@ -184,55 +205,310 @@ class DaemonClient {
                 throw e;
             }
         }
-        let messenger;
+        // Generate unique ID for this callback
+        const callbackId = Math.random().toString(36).substring(2, 11);
+        // Store callback and config for reconnection
+        this.fileWatcherCallbacks.set(callbackId, callback);
+        this.fileWatcherConfigs.set(callbackId, config);
         await this.queue.sendToQueue(async () => {
+            // If we already have a connection, just register the new config
+            if (this.fileWatcherMessenger) {
+                this.fileWatcherMessenger.sendMessage({
+                    type: 'REGISTER_FILE_WATCHER',
+                    config,
+                });
+                return;
+            }
             await this.startDaemonIfNecessary();
             const socketPath = this.getSocketPath();
-            messenger = new daemon_socket_messenger_1.DaemonSocketMessenger((0, net_1.connect)(socketPath)).listen((message) => {
+            this.fileWatcherMessenger = new daemon_socket_messenger_1.DaemonSocketMessenger((0, net_1.connect)(socketPath)).listen((message) => {
                 try {
-                    const parsedMessage = (0, consume_messages_from_socket_1.isJsonMessage)(message)
-                        ? JSON.parse(message)
-                        : (0, node_v8_1.deserialize)(Buffer.from(message, 'binary'));
-                    callback(null, parsedMessage);
+                    const parsedMessage = this.parseMessage(message);
+                    // Notify all callbacks
+                    for (const cb of this.fileWatcherCallbacks.values()) {
+                        cb(null, parsedMessage);
+                    }
                 }
                 catch (e) {
-                    callback(e, null);
+                    for (const cb of this.fileWatcherCallbacks.values()) {
+                        cb(e, null);
+                    }
                 }
             }, () => {
-                callback('closed', null);
-            }, (err) => callback(err, null));
-            return messenger.sendMessage({ type: 'REGISTER_FILE_WATCHER', config });
+                // Connection closed - trigger reconnection
+                logger_1.clientLogger.log(`[FileWatcher] Socket closed, triggering reconnection`);
+                this.fileWatcherMessenger = undefined;
+                for (const cb of this.fileWatcherCallbacks.values()) {
+                    cb('reconnecting', null);
+                }
+                this.reconnectFileWatcher();
+            }, (err) => {
+                if (err instanceof daemon_socket_messenger_1.VersionMismatchError) {
+                    for (const cb of this.fileWatcherCallbacks.values()) {
+                        cb('closed', null);
+                    }
+                    process.exit(1);
+                }
+                for (const cb of this.fileWatcherCallbacks.values()) {
+                    cb(err, null);
+                }
+            });
+            this.fileWatcherMessenger.sendMessage({
+                type: 'REGISTER_FILE_WATCHER',
+                config,
+            });
         });
+        // Return unregister function
         return () => {
-            messenger?.close();
+            this.fileWatcherCallbacks.delete(callbackId);
+            this.fileWatcherConfigs.delete(callbackId);
+            // If no more callbacks, close the connection
+            if (this.fileWatcherCallbacks.size === 0) {
+                this.fileWatcherMessenger?.close();
+                this.fileWatcherMessenger = undefined;
+            }
         };
     }
+    async reconnectFileWatcher() {
+        // Guard against concurrent reconnection attempts
+        if (this.fileWatcherReconnecting) {
+            return;
+        }
+        if (this.fileWatcherCallbacks.size === 0) {
+            return; // No callbacks to reconnect
+        }
+        this.fileWatcherReconnecting = true;
+        logger_1.clientLogger.log(`[FileWatcher] Starting reconnection for ${this.fileWatcherCallbacks.size} callbacks`);
+        // Wait for daemon server to be available before trying to reconnect
+        let serverAvailable;
+        try {
+            serverAvailable = await this.waitForServerToBeAvailable({
+                ignoreVersionMismatch: false,
+            });
+        }
+        catch (err) {
+            // Version mismatch - pass error to callbacks so they can handle it
+            logger_1.clientLogger.log(`[FileWatcher] Error during reconnection: ${err.message}`);
+            this.fileWatcherReconnecting = false;
+            for (const cb of this.fileWatcherCallbacks.values()) {
+                cb(err, null);
+            }
+            return;
+        }
+        if (!serverAvailable) {
+            // Failed to reconnect after all attempts - notify as closed
+            logger_1.clientLogger.log(`[FileWatcher] Failed to reconnect - server unavailable`);
+            this.fileWatcherReconnecting = false;
+            for (const cb of this.fileWatcherCallbacks.values()) {
+                cb('closed', null);
+            }
+            return;
+        }
+        try {
+            // Try to reconnect
+            const socketPath = this.getSocketPath();
+            this.fileWatcherMessenger = new daemon_socket_messenger_1.DaemonSocketMessenger((0, net_1.connect)(socketPath)).listen((message) => {
+                try {
+                    const parsedMessage = this.parseMessage(message);
+                    for (const cb of this.fileWatcherCallbacks.values()) {
+                        cb(null, parsedMessage);
+                    }
+                }
+                catch (e) {
+                    for (const cb of this.fileWatcherCallbacks.values()) {
+                        cb(e, null);
+                    }
+                }
+            }, () => {
+                // Connection closed - trigger reconnection again
+                this.fileWatcherMessenger = undefined;
+                // Reset reconnection flag before triggering reconnection
+                this.fileWatcherReconnecting = false;
+                for (const cb of this.fileWatcherCallbacks.values()) {
+                    cb('reconnecting', null);
+                }
+                this.reconnectFileWatcher();
+            }, (err) => {
+                if (err instanceof daemon_socket_messenger_1.VersionMismatchError) {
+                    for (const cb of this.fileWatcherCallbacks.values()) {
+                        cb('closed', null);
+                    }
+                    process.exit(1);
+                }
+                // Other errors during reconnection - let retry loop handle
+            });
+            // Re-register all stored configs
+            for (const cfg of this.fileWatcherConfigs.values()) {
+                this.fileWatcherMessenger.sendMessage({
+                    type: 'REGISTER_FILE_WATCHER',
+                    config: cfg,
+                });
+            }
+            // Successfully reconnected - notify callbacks
+            logger_1.clientLogger.log(`[FileWatcher] Reconnected successfully`);
+            for (const cb of this.fileWatcherCallbacks.values()) {
+                cb('reconnected', null);
+            }
+            this.fileWatcherReconnecting = false;
+        }
+        catch (e) {
+            // Failed to reconnect - notify as closed
+            logger_1.clientLogger.log(`[FileWatcher] Reconnection failed: ${e.message}`);
+            this.fileWatcherReconnecting = false;
+            for (const cb of this.fileWatcherCallbacks.values()) {
+                cb('closed', null);
+            }
+        }
+    }
     async registerProjectGraphRecomputationListener(callback) {
-        let messenger;
+        // Generate unique ID for this callback
+        const callbackId = Math.random().toString(36).substring(2, 11);
+        // Store callback
+        this.projectGraphListenerCallbacks.set(callbackId, callback);
         await this.queue.sendToQueue(async () => {
+            // If we already have a connection, just send the registration
+            if (this.projectGraphListenerMessenger) {
+                this.projectGraphListenerMessenger.sendMessage({
+                    type: register_project_graph_listener_1.REGISTER_PROJECT_GRAPH_LISTENER,
+                });
+                return;
+            }
             await this.startDaemonIfNecessary();
             const socketPath = this.getSocketPath();
-            messenger = new daemon_socket_messenger_1.DaemonSocketMessenger((0, net_1.connect)(socketPath)).listen((message) => {
+            this.projectGraphListenerMessenger = new daemon_socket_messenger_1.DaemonSocketMessenger((0, net_1.connect)(socketPath)).listen((message) => {
                 try {
-                    const parsedMessage = (0, consume_messages_from_socket_1.isJsonMessage)(message)
-                        ? JSON.parse(message)
-                        : (0, node_v8_1.deserialize)(Buffer.from(message, 'binary'));
-                    callback(null, parsedMessage);
+                    const parsedMessage = this.parseMessage(message);
+                    // Notify all callbacks
+                    for (const cb of this.projectGraphListenerCallbacks.values()) {
+                        cb(null, parsedMessage);
+                    }
                 }
                 catch (e) {
-                    callback(e, null);
+                    for (const cb of this.projectGraphListenerCallbacks.values()) {
+                        cb(e, null);
+                    }
                 }
             }, () => {
-                callback('closed', null);
-            }, (err) => callback(err, null));
-            return messenger.sendMessage({
+                // Connection closed - trigger reconnection
+                logger_1.clientLogger.log(`[ProjectGraphListener] Socket closed, triggering reconnection`);
+                this.projectGraphListenerMessenger = undefined;
+                for (const cb of this.projectGraphListenerCallbacks.values()) {
+                    cb('reconnecting', null);
+                }
+                this.reconnectProjectGraphListener();
+            }, (err) => {
+                if (err instanceof daemon_socket_messenger_1.VersionMismatchError) {
+                    for (const cb of this.projectGraphListenerCallbacks.values()) {
+                        cb('closed', null);
+                    }
+                    process.exit(1);
+                }
+                for (const cb of this.projectGraphListenerCallbacks.values()) {
+                    cb(err, null);
+                }
+            });
+            this.projectGraphListenerMessenger.sendMessage({
                 type: register_project_graph_listener_1.REGISTER_PROJECT_GRAPH_LISTENER,
             });
         });
+        // Return unregister function
         return () => {
-            messenger?.close();
+            this.projectGraphListenerCallbacks.delete(callbackId);
+            // If no more callbacks, close the connection
+            if (this.projectGraphListenerCallbacks.size === 0) {
+                this.projectGraphListenerMessenger?.close();
+                this.projectGraphListenerMessenger = undefined;
+            }
         };
     }
+    async reconnectProjectGraphListener() {
+        // Guard against concurrent reconnection attempts
+        if (this.projectGraphListenerReconnecting) {
+            return;
+        }
+        if (this.projectGraphListenerCallbacks.size === 0) {
+            return; // No callbacks to reconnect
+        }
+        this.projectGraphListenerReconnecting = true;
+        logger_1.clientLogger.log(`[ProjectGraphListener] Starting reconnection for ${this.projectGraphListenerCallbacks.size} callbacks`);
+        // Wait for daemon server to be available before trying to reconnect
+        let serverAvailable;
+        try {
+            serverAvailable = await this.waitForServerToBeAvailable({
+                ignoreVersionMismatch: false,
+            });
+        }
+        catch (err) {
+            // Version mismatch - pass error to callbacks so they can handle it
+            logger_1.clientLogger.log(`[ProjectGraphListener] Error during reconnection: ${err.message}`);
+            this.projectGraphListenerReconnecting = false;
+            for (const cb of this.projectGraphListenerCallbacks.values()) {
+                cb(err, null);
+            }
+            return;
+        }
+        if (!serverAvailable) {
+            // Failed to reconnect after all attempts - notify as closed
+            logger_1.clientLogger.log(`[ProjectGraphListener] Failed to reconnect - server unavailable`);
+            this.projectGraphListenerReconnecting = false;
+            for (const cb of this.projectGraphListenerCallbacks.values()) {
+                cb('closed', null);
+            }
+            return;
+        }
+        try {
+            const socketPath = this.getSocketPath();
+            // Try to reconnect
+            this.projectGraphListenerMessenger = new daemon_socket_messenger_1.DaemonSocketMessenger((0, net_1.connect)(socketPath)).listen((message) => {
+                try {
+                    const parsedMessage = this.parseMessage(message);
+                    for (const cb of this.projectGraphListenerCallbacks.values()) {
+                        cb(null, parsedMessage);
+                    }
+                }
+                catch (e) {
+                    for (const cb of this.projectGraphListenerCallbacks.values()) {
+                        cb(e, null);
+                    }
+                }
+            }, () => {
+                // Connection closed - trigger reconnection again
+                this.projectGraphListenerMessenger = undefined;
+                // Reset reconnection flag before triggering reconnection
+                this.projectGraphListenerReconnecting = false;
+                for (const cb of this.projectGraphListenerCallbacks.values()) {
+                    cb('reconnecting', null);
+                }
+                this.reconnectProjectGraphListener();
+            }, (err) => {
+                if (err instanceof daemon_socket_messenger_1.VersionMismatchError) {
+                    for (const cb of this.projectGraphListenerCallbacks.values()) {
+                        cb('closed', null);
+                    }
+                    process.exit(1);
+                }
+                // Other errors during reconnection - let retry loop handle
+            });
+            // Re-register
+            this.projectGraphListenerMessenger.sendMessage({
+                type: register_project_graph_listener_1.REGISTER_PROJECT_GRAPH_LISTENER,
+            });
+            // Successfully reconnected - notify callbacks
+            logger_1.clientLogger.log(`[ProjectGraphListener] Reconnected successfully`);
+            for (const cb of this.projectGraphListenerCallbacks.values()) {
+                cb('reconnected', null);
+            }
+            this.projectGraphListenerReconnecting = false;
+        }
+        catch (e) {
+            // Failed to reconnect - notify as closed
+            logger_1.clientLogger.log(`[ProjectGraphListener] Reconnection failed: ${e.message}`);
+            this.projectGraphListenerReconnecting = false;
+            for (const cb of this.projectGraphListenerCallbacks.values()) {
+                cb('closed', null);
+            }
+        }
+    }
     processInBackground(requirePath, data) {
         return this.sendToDaemonViaQueue({
             type: 'PROCESS_IN_BACKGROUND',
@@ -389,7 +665,7 @@ class DaemonClient {
         return this.sendToDaemonViaQueue(message);
     }
     async isServerAvailable() {
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
             try {
                 const socketPath = this.getSocketPath();
                 if (!socketPath) {
@@ -405,6 +681,9 @@ class DaemonClient {
                 });
             }
             catch (err) {
+                if (err instanceof daemon_socket_messenger_1.VersionMismatchError) {
+                    reject(err); // Let version mismatch bubble up
+                }
                 resolve(false);
             }
         });
@@ -417,7 +696,20 @@ class DaemonClient {
         if (this._daemonStatus == DaemonStatus.DISCONNECTED) {
             this._daemonStatus = DaemonStatus.CONNECTING;
             let daemonPid = null;
-            if (!(await this.isServerAvailable())) {
+            let serverAvailable;
+            try {
+                serverAvailable = await this.isServerAvailable();
+            }
+            catch (err) {
+                // Version mismatch - treat as server not available, start new one
+                if (err instanceof daemon_socket_messenger_1.VersionMismatchError) {
+                    serverAvailable = false;
+                }
+                else {
+                    throw err;
+                }
+            }
+            if (!serverAvailable) {
                 daemonPid = await this.startInBackground();
             }
             this.setUpConnection();
@@ -444,16 +736,9 @@ class DaemonClient {
                 this.reset();
             }
             else {
-                output_1.output.error({
-                    title: 'Daemon process terminated and closed the connection',
-                    bodyLines: [
-                        'Please rerun the command, which will restart the daemon.',
-                        `If you get this error again, check for any errors in the daemon process logs found in: ${tmp_dir_1.DAEMON_OUTPUT_LOG_FILE}`,
-                    ],
-                });
+                // Connection closed while we had pending work - try to reconnect
                 this._daemonStatus = DaemonStatus.DISCONNECTED;
-                this.currentReject?.(daemonProcessException('Daemon process terminated and closed the connection'));
-                process.exit(1);
+                this.handleConnectionError(daemonProcessException('Daemon process terminated and closed the connection'));
             }
         }, (err) => {
             if (!err.message) {
@@ -472,9 +757,90 @@ class DaemonClient {
             else {
                 error = daemonProcessException(err.toString());
             }
-            return this.currentReject(error);
+            this.currentReject(error);
         });
     }
+    async handleConnectionError(error) {
+        logger_1.clientLogger.log(`[Reconnect] Connection error detected: ${error.message}`);
+        // Create a new ready promise for new requests to wait on
+        this._waitForDaemonReady = new Promise((resolve) => (this._daemonReady = resolve));
+        // Set status to CONNECTING so new requests will wait for reconnection
+        this._daemonStatus = DaemonStatus.CONNECTING;
+        let serverAvailable;
+        try {
+            serverAvailable = await this.waitForServerToBeAvailable({
+                ignoreVersionMismatch: false,
+            });
+        }
+        catch (err) {
+            if (err instanceof daemon_socket_messenger_1.VersionMismatchError) {
+                // New daemon has different version - reject with error so caller can handle
+                if (this.currentReject) {
+                    this.currentReject(err);
+                }
+                return;
+            }
+            throw err;
+        }
+        if (serverAvailable) {
+            logger_1.clientLogger.log(`[Reconnect] Reconnection successful, re-establishing connection`);
+            // Server is back up, establish connection and signal ready
+            this.establishConnection();
+            // Resend the pending message if one exists
+            if (this.currentMessage && this.currentResolve && this.currentReject) {
+                // Decrement the queue counter that was incremented when the error occurred
+                this.queue.decrementQueueCounter();
+                // Retry the message through the normal queue
+                const msg = this.currentMessage;
+                const res = this.currentResolve;
+                const rej = this.currentReject;
+                this.sendToDaemonViaQueue(msg).then(res, rej);
+            }
+        }
+        else {
+            // Failed to reconnect after all attempts, reject the pending request
+            if (this.currentReject) {
+                this.currentReject(error);
+            }
+        }
+    }
+    establishConnection() {
+        this._daemonStatus = DaemonStatus.DISCONNECTED;
+        this.setUpConnection();
+        this._daemonStatus = DaemonStatus.CONNECTED;
+        this._daemonReady();
+    }
+    /**
+     * Wait for daemon server to be available.
+     * Used for reconnection - throws VersionMismatchError if daemon version differs.
+     */
+    async waitForServerToBeAvailable(options) {
+        let attempts = 0;
+        logger_1.clientLogger.log(`[Client] Waiting for server (max: ${WAIT_FOR_SERVER_CONFIG.maxAttempts} attempts, ${WAIT_FOR_SERVER_CONFIG.delayMs}ms interval)`);
+        while (attempts < WAIT_FOR_SERVER_CONFIG.maxAttempts) {
+            await new Promise((resolve) => setTimeout(resolve, WAIT_FOR_SERVER_CONFIG.delayMs));
+            attempts++;
+            try {
+                if (await this.isServerAvailable()) {
+                    logger_1.clientLogger.log(`[Client] Server available after ${attempts} attempts`);
+                    return true;
+                }
+            }
+            catch (err) {
+                if (err instanceof daemon_socket_messenger_1.VersionMismatchError) {
+                    if (!options.ignoreVersionMismatch) {
+                        throw err;
+                    }
+                    // Keep waiting - old cache file may exist
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        logger_1.clientLogger.log(`[Client] Server not available after ${WAIT_FOR_SERVER_CONFIG.maxAttempts} attempts`);
+        return false;
+    }
     async sendMessageToDaemon(message, force) {
         await this.startDaemonIfNecessary();
         // An open promise isn't enough to keep the event loop
@@ -503,29 +869,6 @@ class DaemonClient {
             // don't error, this is a secondary concern that should not break task execution
         }
     }
-    retryMessageAfterNewDaemonStarts() {
-        const [msg, res, rej] = [
-            this.currentMessage,
-            this.currentResolve,
-            this.currentReject,
-        ];
-        // If we get to this point the daemon is about to close, and we don't
-        // want to halt on our daemon terminated unexpectedly condition,
-        // so we decrement the promise queue to make it look empty.
-        this.queue.decrementQueueCounter();
-        if (msg) {
-            setTimeout(() => {
-                // We wait a bit to allow the server to finish shutting down before
-                // retrying the message, which will start a new daemon. Part of
-                // the process of starting up the daemon clears this.currentMessage etc
-                // so we need to store them before waiting.
-                this.sendToDaemonViaQueue(msg).then(res, rej);
-            }, 50);
-        }
-        else {
-            throw new Error('Daemon client attempted to retry a message without a current message');
-        }
-    }
     handleMessage(serializedResult) {
         try {
             perf_hooks_1.performance.mark('result-parse-start-' + this.currentMessage.type);
@@ -535,14 +878,7 @@ class DaemonClient {
             perf_hooks_1.performance.mark('result-parse-end-' + this.currentMessage.type);
             perf_hooks_1.performance.measure('deserialize daemon response - ' + this.currentMessage.type, 'result-parse-start-' + this.currentMessage.type, 'result-parse-end-' + this.currentMessage.type);
             if (parsedResult.error) {
-                if ('message' in parsedResult.error &&
-                    (parsedResult.error.message === 'NX_VERSION_CHANGED' ||
-                        parsedResult.error.message === 'LOCK_FILES_CHANGED')) {
-                    this.retryMessageAfterNewDaemonStarts();
-                }
-                else {
-                    this.currentReject(parsedResult.error);
-                }
+                this.currentReject(parsedResult.error);
             }
             else {
                 perf_hooks_1.performance.measure(`${this.currentMessage.type} round trip`, 'sendMessageToDaemon-start', 'result-parse-end-' + this.currentMessage.type);
@@ -573,6 +909,7 @@ class DaemonClient {
         }
         this._out = await (0, promises_1.open)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE, 'a');
         this._err = await (0, promises_1.open)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE, 'a');
+        logger_1.clientLogger.log(`[Client] Starting new daemon server in background`);
         const backgroundProcess = (0, child_process_1.spawn)(process.execPath, [(0, path_1.join)(__dirname, `../server/start.js`)], {
             cwd: workspace_root_1.workspaceRoot,
             stdio: ['ignore', this._out.fd, this._err.fd],
@@ -588,23 +925,16 @@ class DaemonClient {
         /**
          * Ensure the server is actually available to connect to via IPC before resolving
          */
-        let attempts = 0;
-        return new Promise((resolve, reject) => {
-            const id = setInterval(async () => {
-                if (await this.isServerAvailable()) {
-                    clearInterval(id);
-                    resolve(backgroundProcess.pid);
-                }
-                else if (attempts > 6000) {
-                    // daemon fails to start, the process probably exited
-                    // we print the logs and exit the client
-                    reject(daemonProcessException('Failed to start or connect to the Nx Daemon process.'));
-                }
-                else {
-                    attempts++;
-                }
-            }, 10);
+        const serverAvailable = await this.waitForServerToBeAvailable({
+            ignoreVersionMismatch: true,
         });
+        if (serverAvailable) {
+            logger_1.clientLogger.log(`[Client] Daemon server started, pid=${backgroundProcess.pid}`);
+            return backgroundProcess.pid;
+        }
+        else {
+            throw daemonProcessException('Failed to start or connect to the Nx Daemon process.');
+        }
     }
     async stop() {
         try {

package/src/daemon/client/daemon-socket-messenger.d.ts

@@ -3,11 +3,14 @@ export interface Message extends Record<string, any> {
     type: string;
     data?: any;
 }
+export declare class VersionMismatchError extends Error {
+    constructor();
+}
 export declare class DaemonSocketMessenger {
     private socket;
     constructor(socket: Socket);
-    sendMessage(messageToDaemon: Message, force?: 'v8' | 'json'): Promise<void>;
-    listen(onData: (message: string) => void, onClose?: () => void, onError?: (err: Error) => void): this;
+    sendMessage(messageToDaemon: Message, force?: 'v8' | 'json'): void;
+    listen(onData: (message: string) => void, onClose?: () => void, onError?: (err: Error) => void): DaemonSocketMessenger;
     close(): void;
 }
 //# sourceMappingURL=daemon-socket-messenger.d.ts.map

package/src/daemon/client/daemon-socket-messenger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"daemon-socket-messenger.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/daemon/client/daemon-socket-messenger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,CAAC;AAQ7B,MAAM,WAAW,OAAQ,SAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED,qBAAa,qBAAqB;IACpB,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAE5B,WAAW,CAAC,eAAe,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,IAAI,GAAG,MAAM;IAkBjE,MAAM,CACJ,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EACjC,OAAO,GAAE,MAAM,IAAe,EAC9B,OAAO,GAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAkB;IAe7C,KAAK;CAGN"}
+{"version":3,"file":"daemon-socket-messenger.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/daemon/client/daemon-socket-messenger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,CAAC;AAS7B,MAAM,WAAW,OAAQ,SAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED,qBAAa,oBAAqB,SAAQ,KAAK;;CAM9C;AAED,qBAAa,qBAAqB;IACpB,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAElC,WAAW,CAAC,eAAe,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,IAAI,GAAG,MAAM;IAuB3D,MAAM,CACJ,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EACjC,OAAO,GAAE,MAAM,IAAe,EAC9B,OAAO,GAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAe,GACvC,qBAAqB;IAwBxB,KAAK;CAKN"}