nx 22.7.0 → 22.7.1

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

@@ -155,7 +155,7 @@ class DaemonClient {
         (0, project_graph_1.preventRecursionInGraphConstruction)();
         let spinner;
         // If the graph takes a while to load, we want to show a spinner.
-        spinner = new delayed_spinner_1.DelayedSpinner('Calculating the project graph on the Nx Daemon').scheduleMessageUpdate('Calculating the project graph on the Nx Daemon is taking longer than expected. Re-run with NX_DAEMON=false to see more details.', { ciDelay: 60_000, delay: 30_000 });
+        spinner = new delayed_spinner_1.DelayedSpinner('Calculating the project graph on the Nx Daemon');
         this.currentSpinner = spinner;
         try {
             const response = await this.sendToDaemonViaQueue({

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

@@ -103,6 +103,8 @@ const DAEMON_ENV_PREFIX_EXCLUSIONS = [
     'ALACRITTY_',
     'KONSOLE_',
     'TMUX',
+    // Benchmarking / profiling tools
+    'HYPERFINE_', // hyperfine sets HYPERFINE_RANDOMIZED_ENVIRONMENT_OFFSET for each iteration
 ];
 function isExcludedEnvVar(key) {
     return (DAEMON_ENV_VARS_EXCLUSIONS.has(key) ||

package/dist/src/daemon/is-nx-version-mismatch.d.ts

@@ -1,2 +1 @@
-export declare function getInstalledNxVersion(): string | null;
 export declare function isNxVersionMismatch(): boolean;

package/dist/src/daemon/is-nx-version-mismatch.js

@@ -1,24 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getInstalledNxVersion = getInstalledNxVersion;
 exports.isNxVersionMismatch = isNxVersionMismatch;
-const fileutils_1 = require("../utils/fileutils");
 const versions_1 = require("../utils/versions");
-const workspace_root_1 = require("../utils/workspace-root");
-const installation_directory_1 = require("../utils/installation-directory");
-function getInstalledNxVersion() {
-    try {
-        const nxPackageJsonPath = require.resolve('nx/package.json', {
-            paths: (0, installation_directory_1.getNxRequirePaths)(workspace_root_1.workspaceRoot),
-        });
-        const { version } = (0, fileutils_1.readJsonFile)(nxPackageJsonPath);
-        return version;
-    }
-    catch {
-        // node modules are absent
-        return null;
-    }
-}
+const installed_nx_version_1 = require("../utils/installed-nx-version");
 function isNxVersionMismatch() {
-    return getInstalledNxVersion() !== versions_1.nxVersion;
+    return (0, installed_nx_version_1.getInstalledNxVersion)() !== versions_1.nxVersion;
 }

package/dist/src/daemon/server/server.js

@@ -18,6 +18,7 @@ const workspace_root_1 = require("../../utils/workspace-root");
 const get_plugins_1 = require("../../project-graph/plugins/get-plugins");
 const cache_1 = require("../cache");
 const is_nx_version_mismatch_1 = require("../is-nx-version-mismatch");
+const installed_nx_version_1 = require("../../utils/installed-nx-version");
 const logger_1 = require("../logger");
 const configure_ai_agents_1 = require("../message-types/configure-ai-agents");
 const daemon_message_1 = require("../message-types/daemon-message");
@@ -412,7 +413,7 @@ async function startServer() {
     logger_1.serverLogger.log(`New daemon starting from: ${__filename}`);
     logger_1.serverLogger.log(`New daemon __dirname: ${__dirname}`);
     logger_1.serverLogger.log(`New daemon nxVersion: ${versions_1.nxVersion}`);
-    logger_1.serverLogger.log(`New daemon getInstalledNxVersion(): ${(0, is_nx_version_mismatch_1.getInstalledNxVersion)()}`);
+    logger_1.serverLogger.log(`New daemon getInstalledNxVersion(): ${(0, installed_nx_version_1.getInstalledNxVersion)()}`);
     // Persist metadata about the background process so that it can be cleaned up later if needed
     await (0, cache_1.writeDaemonJsonProcessCache)({
         processId: process.pid,

package/dist/src/tasks-runner/run-command.js

@@ -11,9 +11,9 @@ const tslib_1 = require("tslib");
 const enquirer_1 = require("enquirer");
 const node_path_1 = require("node:path");
 const node_util_1 = require("node:util");
-const ora = require('ora');
 const nx_json_1 = require("../config/nx-json");
 const client_1 = require("../daemon/client/client");
+const spinner_1 = require("../utils/spinner");
 const create_task_hasher_1 = require("../hasher/create-task-hasher");
 const hash_task_1 = require("../hasher/hash-task");
 const native_1 = require("../native");
@@ -486,8 +486,7 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
     const applyChanges = nxJson.sync?.applyChanges === true ||
         (await promptForApplyingSyncGeneratorChanges());
     if (applyChanges) {
-        const spinner = ora('Syncing the workspace...');
-        spinner.start();
+        const spinner = spinner_1.globalSpinner.start('Syncing the workspace...');
         // Flush sync generator changes to disk
         const flushResult = await (0, sync_generators_1.flushSyncGeneratorChanges)(results);
         if ('generatorFailures' in flushResult) {

package/dist/src/tasks-runner/task-orchestrator.js

@@ -57,7 +57,12 @@ class TaskOrchestrator {
         // region internal state
         this.batchEnv = (0, task_env_1.getEnvVariablesForBatchProcess)(this.options.skipNxCache, this.options.captureStderr);
         this.reverseTaskDeps = (0, utils_1.calculateReverseDeps)(this.taskGraph);
-        this.initializingTaskIds = new Set(this.initiatingTasks.map((t) => t.id));
+        // `nx:noop` initiating tasks exit instantly via the fast-path in
+        // `spawnProcess`. If we treat the noop itself as the keep-alive anchor for
+        // its continuous dependencies, `cleanUpUnneededContinuousTasks` kills those
+        // children the moment the noop finishes. Expand through noops so the
+        // underlying real tasks become the anchors.
+        this.initializingTaskIds = (0, utils_1.expandInitiatingTasksThroughNoop)(this.initiatingTasks, this.taskGraph, this.projectGraph);
         this.processedTasks = new Map();
         this.completedTasks = new Map();
         this.waitingForTasks = [];

package/dist/src/tasks-runner/utils.d.ts

@@ -31,6 +31,17 @@ export declare function getOutputsForTargetAndConfiguration(target: Task['target
 export declare function interpolate(template: string, data: any): string;
 export declare function getTargetConfigurationForTask(task: Task, projectGraph: ProjectGraph): TargetConfiguration | undefined;
 export declare function getExecutorNameForTask(task: Task, projectGraph: ProjectGraph): string;
+/**
+ * Expand a set of initiating task IDs by walking through any `nx:noop` tasks
+ * and replacing them with their direct dependencies + continuous dependencies.
+ * Non-noop tasks are kept as-is; cycles are safe.
+ *
+ * An `nx:noop` executor returns immediately, so if it is the only thing
+ * anchoring a continuous child, the child gets killed by
+ * `cleanUpUnneededContinuousTasks` the moment the noop completes. Treating the
+ * noop's dependencies as the real anchors preserves the intended orchestration.
+ */
+export declare function expandInitiatingTasksThroughNoop(initiatingTasks: Task[], taskGraph: TaskGraph, projectGraph: ProjectGraph): Set<string>;
 export declare function getExecutorForTask(task: Task, projects: Record<string, ProjectConfiguration>): ExecutorConfig & {
     isNgCompat: boolean;
     isNxExecutor: boolean;

package/dist/src/tasks-runner/utils.js

@@ -14,6 +14,7 @@ exports.getOutputsForTargetAndConfiguration = getOutputsForTargetAndConfiguratio
 exports.interpolate = interpolate;
 exports.getTargetConfigurationForTask = getTargetConfigurationForTask;
 exports.getExecutorNameForTask = getExecutorNameForTask;
+exports.expandInitiatingTasksThroughNoop = expandInitiatingTasksThroughNoop;
 exports.getExecutorForTask = getExecutorForTask;
 exports.getCustomHasher = getCustomHasher;
 exports.removeTasksFromTaskGraph = removeTasksFromTaskGraph;
@@ -291,6 +292,42 @@ function getTargetConfigurationForTask(task, projectGraph) {
 function getExecutorNameForTask(task, projectGraph) {
     return getTargetConfigurationForTask(task, projectGraph)?.executor;
 }
+/**
+ * Expand a set of initiating task IDs by walking through any `nx:noop` tasks
+ * and replacing them with their direct dependencies + continuous dependencies.
+ * Non-noop tasks are kept as-is; cycles are safe.
+ *
+ * An `nx:noop` executor returns immediately, so if it is the only thing
+ * anchoring a continuous child, the child gets killed by
+ * `cleanUpUnneededContinuousTasks` the moment the noop completes. Treating the
+ * noop's dependencies as the real anchors preserves the intended orchestration.
+ */
+function expandInitiatingTasksThroughNoop(initiatingTasks, taskGraph, projectGraph) {
+    const expanded = new Set();
+    const visited = new Set();
+    const queue = initiatingTasks.map((t) => t.id);
+    while (queue.length > 0) {
+        const taskId = queue.shift();
+        if (visited.has(taskId))
+            continue;
+        visited.add(taskId);
+        const task = taskGraph.tasks[taskId];
+        if (!task)
+            continue;
+        if (getExecutorNameForTask(task, projectGraph) === 'nx:noop') {
+            for (const dep of taskGraph.dependencies[taskId] ?? []) {
+                queue.push(dep);
+            }
+            for (const dep of taskGraph.continuousDependencies[taskId] ?? []) {
+                queue.push(dep);
+            }
+        }
+        else {
+            expanded.add(taskId);
+        }
+    }
+    return expanded;
+}
 function getExecutorForTask(task, projects) {
     const executor = projects[task.target.project]?.targets?.[task.target.target]?.executor;
     const [nodeModule, executorName] = (0, executor_utils_1.parseExecutor)(executor);

package/dist/src/utils/installed-nx-version.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Resolve the workspace's installed `nx` version, or `null` if no installed
+ * `nx` can be located. Routed through a cache-shielded, self-reference-free
+ * `require.resolve` so the answer always reflects the workspace's
+ * `node_modules`/PnP store rather than whichever `nx` package happens to be
+ * loaded in the current process. See nrwl/nx#35444.
+ */
+export declare function getInstalledNxVersion(): string | null;

package/dist/src/utils/installed-nx-version.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInstalledNxVersion = getInstalledNxVersion;
+const tslib_1 = require("tslib");
+const node_module_1 = tslib_1.__importStar(require("node:module"));
+const fileutils_1 = require("./fileutils");
+const workspace_root_1 = require("./workspace-root");
+const installation_directory_1 = require("./installation-directory");
+/**
+ * Resolve the workspace's installed `nx` version, or `null` if no installed
+ * `nx` can be located. Routed through a cache-shielded, self-reference-free
+ * `require.resolve` so the answer always reflects the workspace's
+ * `node_modules`/PnP store rather than whichever `nx` package happens to be
+ * loaded in the current process. See nrwl/nx#35444.
+ */
+function getInstalledNxVersion() {
+    const nxPackageJsonPath = resolvePackageJsonWithoutCachePollution('nx', (0, installation_directory_1.getNxRequirePaths)(workspace_root_1.workspaceRoot));
+    if (!nxPackageJsonPath) {
+        return null;
+    }
+    try {
+        return (0, fileutils_1.readJsonFile)(nxPackageJsonPath).version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve `<packageName>/package.json` via Node's CJS resolver while
+ * neutralising both ways `require.resolve(req, { paths })` can lie about
+ * the `paths` argument:
+ *
+ *   1. Process-wide `Module._pathCache` — swapped out for the duration of
+ *      the call, so any cache entries written are discarded and any
+ *      previously-poisoned entries are not read. Without this, an
+ *      in-process load of a second `nx` package (e.g. the temp `nx@latest`
+ *      install used by the daemon's AI-agents and console-status checks)
+ *      can poison the cache key this call uses and make us read the temp
+ *      path instead of the workspace path.
+ *
+ *   2. Package self-reference — when a file inside package `nx` calls
+ *      `require.resolve('nx/...')`, Node returns that calling package's
+ *      own file regardless of `paths`. We avoid that by issuing the
+ *      resolve from a `createRequire` rooted at a synthetic path that is
+ *      outside any package, so the resolver has no "self" to reference
+ *      and must honour `paths`.
+ *
+ * Node's single-threaded synchronous execution means `require.resolve` does
+ * not yield, so no other code in the process can observe the swapped cache.
+ */
+function resolvePackageJsonWithoutCachePollution(packageName, requirePaths) {
+    // `_pathCache` is an internal Node API not exposed in @types/node.
+    const realCache = node_module_1.default._pathCache;
+    node_module_1.default._pathCache = Object.create(null);
+    try {
+        const detachedRequire = (0, node_module_1.createRequire)('/__nx_detached_resolver__/x.js');
+        return detachedRequire.resolve(`${packageName}/package.json`, {
+            paths: requirePaths,
+        });
+    }
+    catch {
+        return null;
+    }
+    finally {
+        node_module_1.default._pathCache = realCache;
+    }
+}

package/dist/src/utils/workspace-context.js

@@ -54,7 +54,7 @@ async function globWithWorkspaceContext(workspaceRoot, globs, exclude) {
     }
 }
 async function multiGlobWithWorkspaceContext(workspaceRoot, globs, exclude) {
-    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+    if (workspaceRoot === '/virtual' || (0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
         ensureContextAvailable(workspaceRoot);
         return workspaceContext.multiGlob(globs, exclude);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "22.7.0",
+  "version": "22.7.1",
   "private": false,
   "type": "commonjs",
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
@@ -171,16 +171,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "22.7.0",
-    "@nx/nx-darwin-x64": "22.7.0",
-    "@nx/nx-freebsd-x64": "22.7.0",
-    "@nx/nx-linux-arm-gnueabihf": "22.7.0",
-    "@nx/nx-linux-arm64-gnu": "22.7.0",
-    "@nx/nx-linux-arm64-musl": "22.7.0",
-    "@nx/nx-linux-x64-gnu": "22.7.0",
-    "@nx/nx-linux-x64-musl": "22.7.0",
-    "@nx/nx-win32-arm64-msvc": "22.7.0",
-    "@nx/nx-win32-x64-msvc": "22.7.0"
+    "@nx/nx-darwin-arm64": "22.7.1",
+    "@nx/nx-darwin-x64": "22.7.1",
+    "@nx/nx-freebsd-x64": "22.7.1",
+    "@nx/nx-linux-arm-gnueabihf": "22.7.1",
+    "@nx/nx-linux-arm64-gnu": "22.7.1",
+    "@nx/nx-linux-arm64-musl": "22.7.1",
+    "@nx/nx-linux-x64-gnu": "22.7.1",
+    "@nx/nx-linux-x64-musl": "22.7.1",
+    "@nx/nx-win32-arm64-msvc": "22.7.1",
+    "@nx/nx-win32-x64-msvc": "22.7.1"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",