nx 23.3.0 → 24.0.0-beta.1

package/dist/src/daemon/client/client.d.ts

@@ -23,6 +23,11 @@ export type ChangedFile = {
     path: string;
     type: 'create' | 'update' | 'delete';
 };
+export declare enum DaemonStatus {
+    CONNECTING = 0,
+    DISCONNECTED = 1,
+    CONNECTED = 2
+}
 /**
  * The daemon's workspace watcher died. Nothing it serves will see file changes
  * again, so a watching client has to restart rather than keep waiting.
@@ -43,6 +48,8 @@ export declare class DaemonClient {
     private _daemonStatus;
     private _waitForDaemonReady;
     private _daemonReady;
+    private _daemonReadyFailed;
+    private _pluginWorkerConnectionLost;
     private fileWatcherMessenger;
     private fileWatcherReconnecting;
     private fileWatcherFramingFailures;
@@ -54,6 +61,8 @@ export declare class DaemonClient {
     private projectGraphListenerCallbacks;
     enabled(): boolean;
     reset(): void;
+    private createReadyPromise;
+    private failDaemonReady;
     private getSocketPath;
     requestShutdown(): Promise<void>;
     getProjectGraphAndSourceMaps(): Promise<{

package/dist/src/daemon/client/client.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.daemonClient = exports.DaemonClient = exports.WatcherFailedError = void 0;
+exports.daemonClient = exports.DaemonClient = exports.WatcherFailedError = exports.DaemonStatus = void 0;
 exports.isDaemonEnabled = isDaemonEnabled;
 exports.daemonPermissionException = daemonPermissionException;
 exports.daemonProcessException = daemonProcessException;
@@ -55,7 +55,7 @@ var DaemonStatus;
     DaemonStatus[DaemonStatus["CONNECTING"] = 0] = "CONNECTING";
     DaemonStatus[DaemonStatus["DISCONNECTED"] = 1] = "DISCONNECTED";
     DaemonStatus[DaemonStatus["CONNECTED"] = 2] = "CONNECTED";
-})(DaemonStatus || (DaemonStatus = {}));
+})(DaemonStatus || (exports.DaemonStatus = DaemonStatus = {}));
 const WAIT_FOR_SERVER_CONFIG = {
     delayMs: 10,
     maxAttempts: 6000, // 6000 * 10ms = 60 seconds
@@ -95,6 +95,9 @@ class DaemonClient {
         this._daemonStatus = DaemonStatus.DISCONNECTED;
         this._waitForDaemonReady = null;
         this._daemonReady = null;
+        this._daemonReadyFailed = null;
+        // Terminal once set — see `handleConnectionError`.
+        this._pluginWorkerConnectionLost = null;
         this.fileWatcherReconnecting = false;
         this.fileWatcherFramingFailures = 0;
         this.fileWatcherCallbacks = new Map();
@@ -166,7 +169,26 @@ class DaemonClient {
         this.projectGraphListenerMessenger?.close();
         this.projectGraphListenerMessenger = undefined;
         this._daemonStatus = DaemonStatus.DISCONNECTED;
-        this._waitForDaemonReady = new Promise((resolve) => (this._daemonReady = resolve));
+        this._pluginWorkerConnectionLost = null;
+        this._waitForDaemonReady = this.createReadyPromise();
+    }
+    createReadyPromise() {
+        const promise = new Promise((resolve, reject) => {
+            this._daemonReady = resolve;
+            this._daemonReadyFailed = reject;
+        });
+        // Callers don't always await — swallow the unhandled-rejection warning
+        // so a rejected ready promise that no one observes doesn't crash the
+        // process. Real awaiters still see the rejection.
+        promise.catch(() => { });
+        return promise;
+    }
+    // Move out of CONNECTING and surface an error to every caller parked on
+    // `_waitForDaemonReady`. Without this, a failure while CONNECTING leaves
+    // concurrent callers waiting on a promise that will never settle.
+    failDaemonReady(err) {
+        this._daemonStatus = DaemonStatus.DISCONNECTED;
+        this._daemonReadyFailed?.(err);
     }
     getSocketPath() {
         const daemonProcessJson = (0, cache_1.readDaemonProcessJsonCache)();
@@ -821,33 +843,50 @@ class DaemonClient {
         return (await this.probeServer()).available;
     }
     async startDaemonIfNecessary() {
+        if (this._pluginWorkerConnectionLost) {
+            throw this._pluginWorkerConnectionLost;
+        }
         if (this._daemonStatus == DaemonStatus.CONNECTED) {
             return;
         }
         // Ensure daemon is running and socket path is available
         if (this._daemonStatus == DaemonStatus.DISCONNECTED) {
+            // Create a fresh ready promise for any concurrent caller that hits
+            // the CONNECTING branch below before this attempt resolves.
+            this._waitForDaemonReady = this.createReadyPromise();
             this._daemonStatus = DaemonStatus.CONNECTING;
             let daemonPid = null;
-            let probe;
             try {
-                probe = await this.probeServer();
-            }
-            catch (err) {
-                // Version mismatch - treat as server not available, start new one
-                if (err instanceof daemon_socket_messenger_1.VersionMismatchError) {
-                    probe = { available: false };
+                let probe;
+                try {
+                    probe = await this.probeServer();
+                }
+                catch (err) {
+                    // Version mismatch - treat as server not available, start new one
+                    if (err instanceof daemon_socket_messenger_1.VersionMismatchError) {
+                        probe = { available: false };
+                    }
+                    else {
+                        throw err;
+                    }
                 }
-                else {
-                    throw err;
+                if (!probe.available) {
+                    // Carried as a value so no other caller's probe can substitute for it.
+                    daemonPid = await this.startInBackground(probe.refusal);
                 }
+                this.setUpConnection();
+                this._daemonStatus = DaemonStatus.CONNECTED;
+                this._daemonReady();
             }
-            if (!probe.available) {
-                // Carried as a value so no other caller's probe can substitute for it.
-                daemonPid = await this.startInBackground(probe.refusal);
+            catch (err) {
+                // Reset to DISCONNECTED and reject the ready promise so every
+                // concurrent caller parked on the CONNECTING branch gets the
+                // error instead of hanging forever.
+                this.failDaemonReady(err);
+                throw err;
             }
-            this.setUpConnection();
-            this._daemonStatus = DaemonStatus.CONNECTED;
-            this._daemonReady();
+            // Outside the try: the connection is established by now, and a throw
+            // from here must not undo it.
             daemonPid ??= (0, cache_1.getDaemonProcessIdSync)();
             // Fire-and-forget - don't block daemon connection by waiting for metrics registration
             this.registerDaemonProcessWithMetricsService(daemonPid);
@@ -927,27 +966,33 @@ class DaemonClient {
     }
     async handleConnectionError(error) {
         logger_1.clientLogger.log(`[Reconnect] Connection error detected: ${error.message}`);
+        // A plugin worker cannot bring a daemon back — `startInBackground` throws
+        // in one — and it is usually hosted by the daemon that just died, so the
+        // 60s reconnect poll almost always ends in the same failure. Make the loss
+        // terminal instead: the in-flight message and every later one fail fast
+        // with a clear error. The cost is that a CLI-hosted worker no longer
+        // survives a daemon restart, and that command fails.
+        if (global.NX_PLUGIN_WORKER) {
+            const pluginWorkerError = daemonProcessException(`Plugin worker lost its daemon connection and cannot reconnect: ${error.message}`);
+            this._pluginWorkerConnectionLost = pluginWorkerError;
+            if (this.currentReject) {
+                this.currentReject(pluginWorkerError);
+            }
+            this.failDaemonReady(pluginWorkerError);
+            return;
+        }
         // Create a new ready promise for new requests to wait on
-        this._waitForDaemonReady = new Promise((resolve) => (this._daemonReady = resolve));
+        this._waitForDaemonReady = this.createReadyPromise();
         // Set status to CONNECTING so new requests will wait for reconnection
         this._daemonStatus = DaemonStatus.CONNECTING;
-        let serverAvailable;
         try {
-            ({ available: serverAvailable } = await this.waitForServerToBeAvailable({
+            const { available } = 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;
+            });
+            if (!available) {
+                // Out of reconnect attempts, so the error that started this stands.
+                throw error;
             }
-            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();
@@ -962,11 +1007,18 @@ class DaemonClient {
                 this.sendMessageToDaemon(msg).then(res, rej);
             }
         }
-        else {
-            // Failed to reconnect after all attempts, reject the pending request
-            if (this.currentReject) {
-                this.currentReject(error);
+        catch (err) {
+            this.failDaemonReady(err);
+            // A new daemon on a different version and an exhausted reconnect are
+            // both answers for the in-flight caller; anything else is unexpected
+            // and propagates.
+            if (err instanceof daemon_socket_messenger_1.VersionMismatchError || err === error) {
+                if (this.currentReject) {
+                    this.currentReject(err);
+                }
+                return;
             }
+            throw err;
         }
     }
     establishConnection() {

package/dist/src/daemon/server/shutdown-utils.js

@@ -11,7 +11,6 @@ const workspace_root_1 = require("../../utils/workspace-root");
 const logger_1 = require("../logger");
 const socket_utils_1 = require("../socket-utils");
 const cache_1 = require("../cache");
-const workspace_context_1 = require("../../utils/workspace-context");
 const error_types_1 = require("../../project-graph/error-types");
 const get_plugins_1 = require("../../project-graph/plugins/get-plugins");
 const consume_messages_from_socket_1 = require("../../utils/consume-messages-from-socket");
@@ -78,8 +77,6 @@ async function performShutdown(server, reason, sockets) {
                 socket.destroy();
             }
         });
-        (0, workspace_context_1.stopWatchingWorkspaceContext)();
-        logger_1.serverLogger.watcherLog(`Stopping the watch for ${workspace_root_1.workspaceRoot}`);
         (0, cache_1.deleteDaemonJsonProcessCache)();
         (0, get_plugins_1.cleanupPlugins)();
         // Clean up shared latest Nx installation

package/dist/src/daemon/socket-utils.d.ts

@@ -1,15 +1,20 @@
 import type { Socket } from 'net';
 export declare const isWindows: boolean;
 /**
- * For IPC with the daemon server we use unix sockets or windows named pipes, depending on the user's operating system.
+ * For IPC with the daemon server we use unix sockets or windows named pipes,
+ * depending on the user's operating system.
  *
- * See https://nodejs.org/dist/latest-v14.x/docs/api/net.html#net_identifying_paths_for_ipc_connections for a full breakdown
- * of OS differences between Unix domain sockets and named pipes.
+ * The paths themselves — the directory, the file name, the named-pipe form, and
+ * the length budget — are all decided in `native/utils/socket_path.rs`, so that
+ * Nx and Nx Console cannot disagree about where a socket lives.
+ *
+ * See https://nodejs.org/dist/latest-v14.x/docs/api/net.html#net_identifying_paths_for_ipc_connections
+ * for a full breakdown of OS differences between Unix domain sockets and named
+ * pipes.
  */
 export declare const getFullOsSocketPath: () => string;
 export declare const getForkedProcessOsSocketPath: (id: string) => string;
 export declare const getPluginOsSocketPath: (id: string) => string;
-export declare function getPluginSocketFileName(id: string): string;
 export declare function killSocketOrPath(): void;
 export declare function serializeResult(error: Error | null, serializedProjectGraph: string | null, serializedSourceMaps: string | null): string | null;
 /**

package/dist/src/daemon/socket-utils.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPluginOsSocketPath = exports.getForkedProcessOsSocketPath = exports.getFullOsSocketPath = exports.isWindows = void 0;
-exports.getPluginSocketFileName = getPluginSocketFileName;
 exports.killSocketOrPath = killSocketOrPath;
 exports.serializeResult = serializeResult;
 exports.serializeWithFallback = serializeWithFallback;
@@ -9,7 +8,6 @@ exports.serialize = serialize;
 exports.sendMessage = sendMessage;
 const fs_1 = require("fs");
 const os_1 = require("os");
-const path_1 = require("path");
 const tmp_dir_1 = require("./tmp-dir");
 const serializable_error_1 = require("../utils/serializable-error");
 const is_v8_serializer_enabled_1 = require("./is-v8-serializer-enabled");
@@ -17,58 +15,23 @@ const v8_1 = require("v8");
 const consume_messages_from_socket_1 = require("../utils/consume-messages-from-socket");
 exports.isWindows = (0, os_1.platform)() === 'win32';
 /**
- * For IPC with the daemon server we use unix sockets or windows named pipes, depending on the user's operating system.
+ * For IPC with the daemon server we use unix sockets or windows named pipes,
+ * depending on the user's operating system.
  *
- * See https://nodejs.org/dist/latest-v14.x/docs/api/net.html#net_identifying_paths_for_ipc_connections for a full breakdown
- * of OS differences between Unix domain sockets and named pipes.
+ * The paths themselves — the directory, the file name, the named-pipe form, and
+ * the length budget — are all decided in `native/utils/socket_path.rs`, so that
+ * Nx and Nx Console cannot disagree about where a socket lives.
+ *
+ * See https://nodejs.org/dist/latest-v14.x/docs/api/net.html#net_identifying_paths_for_ipc_connections
+ * for a full breakdown of OS differences between Unix domain sockets and named
+ * pipes.
  */
-const getFullOsSocketPath = () => {
-    const path = (0, path_1.resolve)((0, tmp_dir_1.getDaemonSocketDir)());
-    assertValidSocketPath(path);
-    return exports.isWindows ? '\\\\.\\pipe\\nx\\' + path : path;
-};
+const getFullOsSocketPath = () => (0, tmp_dir_1.getDaemonSocketPath)();
 exports.getFullOsSocketPath = getFullOsSocketPath;
-const getForkedProcessOsSocketPath = (id) => {
-    let path = (0, path_1.resolve)((0, path_1.join)((0, tmp_dir_1.getSocketDir)(), 'fp' + id + '.sock'));
-    assertValidSocketPath(path);
-    return exports.isWindows ? '\\\\.\\pipe\\nx\\' + path : path;
-};
+const getForkedProcessOsSocketPath = (id) => (0, tmp_dir_1.getForkedProcessSocketPath)(id);
 exports.getForkedProcessOsSocketPath = getForkedProcessOsSocketPath;
-const getPluginOsSocketPath = (id) => {
-    let path = (0, path_1.resolve)((0, path_1.join)((0, tmp_dir_1.getPluginSocketDir)(), getPluginSocketFileName(id)));
-    assertValidSocketPath(path);
-    return exports.isWindows ? '\\\\.\\pipe\\nx\\' + path : path;
-};
+const getPluginOsSocketPath = (id) => (0, tmp_dir_1.getPluginSocketPath)(id);
 exports.getPluginOsSocketPath = getPluginOsSocketPath;
-function getPluginSocketFileName(id) {
-    return `p${id}.sock`;
-}
-function assertValidSocketPath(path) {
-    if (path.length > 95) {
-        const fallbackCause = (0, tmp_dir_1.getSocketDirFallbackCause)();
-        const refusedConfiguredSocketDir = (0, tmp_dir_1.getRefusedConfiguredSocketDir)();
-        throw new Error([
-            'Attempted to open socket that exceeds the maximum socket length.',
-            ...(fallbackCause === undefined
-                ? []
-                : [
-                    `Nx fell back to ${(0, path_1.dirname)(path)} because the default socket directory could not be used.`,
-                    'Run the command with --verbose to see why the default directory was rejected.',
-                ]),
-            '',
-            ...(refusedConfiguredSocketDir === undefined
-                ? [
-                    `Set NX_SOCKET_DIR to a shorter path (e.g. ${exports.isWindows ? '%TMP%/nx-tmp' : '/tmp/nx-tmp'}) to avoid this issue.`,
-                ]
-                : [
-                    // Saying "set a shorter path" here would be advice they already
-                    // followed: they set one, and it was refused for another reason.
-                    `The directory set in NX_SOCKET_DIR (${refusedConfiguredSocketDir}) could not be used — see the warning above — so Nx fell back to a longer path.`,
-                    'Point NX_SOCKET_DIR at a short directory your user owns.',
-                ]),
-        ].join('\n'), fallbackCause === undefined ? undefined : { cause: fallbackCause });
-    }
-}
 function killSocketOrPath() {
     try {
         (0, fs_1.unlinkSync)((0, exports.getFullOsSocketPath)());

package/dist/src/daemon/tmp-dir.d.ts

@@ -24,7 +24,6 @@ export declare class InvalidSocketDirConfigured extends Error {
 }
 export declare const DAEMON_DIR_FOR_CURRENT_WORKSPACE: string;
 export declare const DAEMON_OUTPUT_LOG_FILE: string;
-export declare const getDaemonSocketDir: () => string;
 export declare function writeDaemonLogs(error?: string): string;
 export declare function markDaemonAsDisabled(reason: string): void;
 /**
@@ -38,25 +37,31 @@ export declare function markDaemonAsDisabled(reason: string): void;
  */
 export declare function disableDaemonForThisProcess(reason: string): void;
 export declare function isDaemonDisabled(): boolean;
-export declare function getSocketDir(): string;
-/**
- * Plugin worker sockets get their own workspace-scoped directory rather than
- * sitting in the shared system temp dir, which cannot be locked down.
- */
-export declare function getPluginSocketDir(): string;
 /**
  * Exported for tests: both fallback warnings fire once per process, so a suite
  * that stages either fallback more than once has to clear the latches between
  * cases.
  */
 export declare function resetSocketDirWarningsForTesting(): void;
-export declare function getSocketDirFallbackCause(): unknown;
+/** The daemon's own socket. */
+export declare function getDaemonSocketPath(): string;
+/** A forked task process's socket, in the daemon's per-run directory. */
+export declare function getForkedProcessSocketPath(id: string): string;
+/**
+ * Plugin worker sockets get their own workspace-scoped directory rather than
+ * sitting in the shared system temp dir, which cannot be locked down.
+ */
+export declare function getPluginSocketPath(id: string): string;
 /**
- * The NX_SOCKET_DIR that was refused, if that is why we are in the fallback.
- * Reflects the most recent resolution only — both accessors are cleared at the
- * top of every `createOwnerOnlySocketDir` call, and the daemon and plugin socket
- * paths each drive one. Read it immediately after the call that produced the
- * path, which is what `assertValidSocketPath` does.
+ * Where the Nx Console socket lives, for whoever binds or connects to it.
+ *
+ * Nx Console is the server here and Nx the client, so the extension listens
+ * where this says and Nx dials it.
+ *
+ * @param workspaceRootOverride the workspace to resolve for, when the caller is
+ * not itself running inside it (Nx Console runs in the editor's extension host)
+ * @param env the environment to read `NX_SOCKET_DIR` from, for callers that
+ * load a workspace `.env` into a copy rather than into `process.env`
  */
-export declare function getRefusedConfiguredSocketDir(): string | undefined;
+export declare function getNxConsoleSocketPath(workspaceRootOverride?: string, env?: Record<string, string>): string;
 export declare function removeSocketDir(): void;