nx 22.7.0-beta.12 → 22.7.0-beta.13

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

@@ -6,64 +6,67 @@ exports.startServer = startServer;
 const fs_1 = require("fs");
 const net_1 = require("net");
 const path_1 = require("path");
-require("../../utils/perf-logging");
+const v8_1 = require("v8");
+const analytics_1 = require("../../analytics");
 const file_hasher_1 = require("../../hasher/file-hasher");
 const native_1 = require("../../native");
 const consume_messages_from_socket_1 = require("../../utils/consume-messages-from-socket");
+require("../../utils/perf-logging");
 const versions_1 = require("../../utils/versions");
 const workspace_context_1 = require("../../utils/workspace-context");
 const workspace_root_1 = require("../../utils/workspace-root");
+const get_plugins_1 = require("../../project-graph/plugins/get-plugins");
 const cache_1 = require("../cache");
-const analytics_1 = require("../../analytics");
 const is_nx_version_mismatch_1 = require("../is-nx-version-mismatch");
+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");
+const flush_sync_generator_changes_to_disk_1 = require("../message-types/flush-sync-generator-changes-to-disk");
+const force_shutdown_1 = require("../message-types/force-shutdown");
+const get_context_file_data_1 = require("../message-types/get-context-file-data");
+const get_files_in_directory_1 = require("../message-types/get-files-in-directory");
+const get_nx_workspace_files_1 = require("../message-types/get-nx-workspace-files");
+const get_registered_sync_generators_1 = require("../message-types/get-registered-sync-generators");
+const get_sync_generator_changes_1 = require("../message-types/get-sync-generator-changes");
+const glob_1 = require("../message-types/glob");
+const hash_glob_1 = require("../message-types/hash-glob");
+const nx_console_1 = require("../message-types/nx-console");
+const register_project_graph_listener_1 = require("../message-types/register-project-graph-listener");
+const run_tasks_execution_hooks_1 = require("../message-types/run-tasks-execution-hooks");
+const task_history_1 = require("../message-types/task-history");
+const update_workspace_context_1 = require("../message-types/update-workspace-context");
 const socket_utils_1 = require("../socket-utils");
+const file_change_events_1 = require("./file-watching/file-change-events");
 const file_watcher_sockets_1 = require("./file-watching/file-watcher-sockets");
-const project_graph_listener_sockets_1 = require("./project-graph-listener-sockets");
+const handle_configure_ai_agents_1 = require("./handle-configure-ai-agents");
+const handle_context_file_data_1 = require("./handle-context-file-data");
+const handle_flush_sync_generator_changes_to_disk_1 = require("./handle-flush-sync-generator-changes-to-disk");
+const handle_force_shutdown_1 = require("./handle-force-shutdown");
+const handle_get_files_in_directory_1 = require("./handle-get-files-in-directory");
+const handle_get_registered_sync_generators_1 = require("./handle-get-registered-sync-generators");
+const handle_get_sync_generator_changes_1 = require("./handle-get-sync-generator-changes");
+const handle_glob_1 = require("./handle-glob");
+const handle_hash_glob_1 = require("./handle-hash-glob");
 const handle_hash_tasks_1 = require("./handle-hash-tasks");
+const handle_nx_console_1 = require("./handle-nx-console");
+const handle_nx_workspace_files_1 = require("./handle-nx-workspace-files");
 const handle_outputs_tracking_1 = require("./handle-outputs-tracking");
 const handle_process_in_background_1 = require("./handle-process-in-background");
 const handle_request_project_graph_1 = require("./handle-request-project-graph");
 const handle_request_shutdown_1 = require("./handle-request-shutdown");
-const logger_1 = require("../logger");
+const handle_task_history_1 = require("./handle-task-history");
+const handle_tasks_execution_hooks_1 = require("./handle-tasks-execution-hooks");
+const handle_update_workspace_context_1 = require("./handle-update-workspace-context");
 const outputs_tracking_1 = require("./outputs-tracking");
 const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+const project_graph_listener_sockets_1 = require("./project-graph-listener-sockets");
 const shutdown_utils_1 = require("./shutdown-utils");
-const watcher_1 = require("./watcher");
-const handle_glob_1 = require("./handle-glob");
-const glob_1 = require("../message-types/glob");
-const get_nx_workspace_files_1 = require("../message-types/get-nx-workspace-files");
-const handle_nx_workspace_files_1 = require("./handle-nx-workspace-files");
-const get_context_file_data_1 = require("../message-types/get-context-file-data");
-const handle_context_file_data_1 = require("./handle-context-file-data");
-const get_files_in_directory_1 = require("../message-types/get-files-in-directory");
-const handle_get_files_in_directory_1 = require("./handle-get-files-in-directory");
-const hash_glob_1 = require("../message-types/hash-glob");
-const handle_hash_glob_1 = require("./handle-hash-glob");
-const task_history_1 = require("../message-types/task-history");
-const handle_task_history_1 = require("./handle-task-history");
-const force_shutdown_1 = require("../message-types/force-shutdown");
-const handle_force_shutdown_1 = require("./handle-force-shutdown");
-const get_sync_generator_changes_1 = require("../message-types/get-sync-generator-changes");
-const handle_get_sync_generator_changes_1 = require("./handle-get-sync-generator-changes");
 const sync_generators_1 = require("./sync-generators");
-const file_change_events_1 = require("./file-watching/file-change-events");
-const get_registered_sync_generators_1 = require("../message-types/get-registered-sync-generators");
-const handle_get_registered_sync_generators_1 = require("./handle-get-registered-sync-generators");
-const update_workspace_context_1 = require("../message-types/update-workspace-context");
-const handle_update_workspace_context_1 = require("./handle-update-workspace-context");
-const flush_sync_generator_changes_to_disk_1 = require("../message-types/flush-sync-generator-changes-to-disk");
-const handle_flush_sync_generator_changes_to_disk_1 = require("./handle-flush-sync-generator-changes-to-disk");
-const run_tasks_execution_hooks_1 = require("../message-types/run-tasks-execution-hooks");
-const handle_tasks_execution_hooks_1 = require("./handle-tasks-execution-hooks");
-const register_project_graph_listener_1 = require("../message-types/register-project-graph-listener");
-const nx_console_1 = require("../message-types/nx-console");
-const handle_nx_console_1 = require("./handle-nx-console");
-const configure_ai_agents_1 = require("../message-types/configure-ai-agents");
-const handle_configure_ai_agents_1 = require("./handle-configure-ai-agents");
-const v8_1 = require("v8");
+const watcher_1 = require("./watcher");
 let workspaceWatcherError;
 let outputsWatcherError;
 global.NX_DAEMON = true;
+process.env.NX_DAEMON_PROCESS = 'true';
 let numberOfOpenConnections = 0;
 exports.openSockets = new Set();
 const server = (0, net_1.createServer)(async (socket) => {
@@ -112,6 +115,21 @@ async function handleMessage(socket, data) {
         await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Invalid payload from the client`, new Error(`Unsupported payload sent to daemon server: ${unparsedPayload}`));
     }
     logger_1.serverLogger.log(`Received ${mode} message of type ${payload.type}`);
+    if ((0, daemon_message_1.isDaemonMessage)(payload) && payload.env) {
+        let shouldRecomputeGraph = false;
+        for (const key in payload.env) {
+            if (process.env[key] !== payload.env[key]) {
+                logger_1.serverLogger.log(`Refreshing env var ${key} from client connection.`);
+                process.env[key] = payload.env[key];
+                shouldRecomputeGraph = true;
+            }
+        }
+        if (shouldRecomputeGraph) {
+            logger_1.serverLogger.log('Graph recompute necessary due to env variable refresh');
+            forwardEnvToPluginWorkers(payload.env);
+            (0, project_graph_incremental_recomputation_1.invalidateGraphCache)();
+        }
+    }
     if (payload.type === 'PING') {
         await handleResult(socket, 'PING', () => Promise.resolve({ response: true, description: 'ping' }), mode);
     }
@@ -124,11 +142,11 @@ async function handleMessage(socket, data) {
     else if (payload.type === 'PROCESS_IN_BACKGROUND') {
         await handleResult(socket, 'PROCESS_IN_BACKGROUND', () => (0, handle_process_in_background_1.handleProcessInBackground)(payload), mode);
     }
-    else if (payload.type === 'RECORD_OUTPUTS_HASH') {
-        await handleResult(socket, 'RECORD_OUTPUTS_HASH', () => (0, handle_outputs_tracking_1.handleRecordOutputsHash)(payload), mode);
+    else if (payload.type === 'RECORD_OUTPUTS_HASH_BATCH') {
+        await handleResult(socket, 'RECORD_OUTPUTS_HASH_BATCH', () => (0, handle_outputs_tracking_1.handleRecordOutputsHashBatch)(payload), mode);
     }
-    else if (payload.type === 'OUTPUTS_HASHES_MATCH') {
-        await handleResult(socket, 'OUTPUTS_HASHES_MATCH', () => (0, handle_outputs_tracking_1.handleOutputsHashesMatch)(payload), mode);
+    else if (payload.type === 'OUTPUTS_HASHES_MATCH_BATCH') {
+        await handleResult(socket, 'OUTPUTS_HASHES_MATCH_BATCH', () => (0, handle_outputs_tracking_1.handleOutputsHashesMatchBatch)(payload), mode);
     }
     else if (payload.type === 'REQUEST_SHUTDOWN') {
         await handleResult(socket, 'REQUEST_SHUTDOWN', () => (0, handle_request_shutdown_1.handleRequestShutdown)(server, numberOfOpenConnections), mode);
@@ -477,6 +495,19 @@ async function startServer() {
         }
     });
 }
+function forwardEnvToPluginWorkers(env) {
+    (0, get_plugins_1.getPlugins)()
+        .then((plugins) => {
+        for (const plugin of plugins) {
+            plugin.setWorkerEnv?.(env)?.catch((e) => {
+                logger_1.serverLogger.log(`Failed to forward env to plugin worker "${plugin.name}": ${e.message}`);
+            });
+        }
+    })
+        .catch(() => {
+        // Plugins may not be loaded yet — env will be picked up on next load
+    });
+}
 function serializeUnserializedResult(response, mode) {
     if (mode === 'json') {
         return JSON.stringify(response);

package/dist/src/executors/run-commands/running-tasks.js

@@ -12,7 +12,6 @@ const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
 const task_env_1 = require("../../tasks-runner/task-env");
 const task_io_service_1 = require("../../tasks-runner/task-io-service");
 const exit_codes_1 = require("../../utils/exit-codes");
-const run_commands_impl_1 = require("./run-commands.impl");
 class ParallelRunningTasks {
     constructor(options, context, taskId) {
         this.exitCallbacks = [];
@@ -244,8 +243,8 @@ class RunningNodeProcess {
         if (streamOutput) {
             process.stdout.write(header);
         }
-        this.childProcess = (0, child_process_1.exec)(commandConfig.command, {
-            maxBuffer: run_commands_impl_1.LARGE_BUFFER,
+        this.childProcess = (0, child_process_1.spawn)(commandConfig.command, [], {
+            shell: true,
             env,
             cwd,
             windowsHide: true,

package/dist/src/executors/run-script/run-script.impl.js

@@ -7,7 +7,6 @@ const path = tslib_1.__importStar(require("path"));
 const tree_kill_1 = tslib_1.__importDefault(require("tree-kill"));
 const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
 const package_manager_1 = require("../../utils/package-manager");
-const LARGE_BUFFER = 1024 * 1000000;
 async function default_1(options, context) {
     const pm = (0, package_manager_1.getPackageManagerCommand)();
     try {
@@ -35,17 +34,26 @@ async function default_1(options, context) {
 }
 function nodeProcess(command, cwd, env) {
     return new Promise((res, rej) => {
-        let cp = (0, child_process_1.exec)(command, { cwd, env, maxBuffer: LARGE_BUFFER, windowsHide: true }, (error) => {
-            if (error) {
-                rej(error);
-            }
-            else {
-                res();
-            }
+        let cp = (0, child_process_1.spawn)(command, [], {
+            shell: true,
+            cwd,
+            env,
+            windowsHide: true,
         });
         // Forward stdout/stderr to parent process
         cp.stdout.pipe(process.stdout);
         cp.stderr.pipe(process.stderr);
+        cp.on('error', (error) => {
+            rej(error);
+        });
+        cp.on('exit', (code) => {
+            if (code === 0) {
+                res();
+            }
+            else {
+                rej(new Error(`Command "${command}" exited with non-zero status code`));
+            }
+        });
         const exitHandler = (signal) => {
             if (cp && cp.pid && !cp.killed) {
                 (0, tree_kill_1.default)(cp.pid, signal, (error) => {

package/dist/src/hasher/hash-task.d.ts

@@ -6,4 +6,12 @@ import { TaskHasher } from './task-hasher';
 export declare function getTaskDetails(): TaskDetails | null;
 export declare function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, tasksDetails: TaskDetails | null): Promise<void>;
 export declare function hashTask(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, task: Task, env: NodeJS.ProcessEnv, taskDetails: TaskDetails | null): Promise<void>;
-export declare function hashTasks(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, taskDetails: TaskDetails | null, tasksToHashOverride?: Task[]): Promise<void>;
+/**
+ * Batch-hash `tasks`. `perTaskEnvs` must contain an entry keyed by
+ * `task.id` for every task — the per-task env is what each task's
+ * custom hasher sees and what the built-in hasher reads
+ * `HashInstruction::Environment` inputs against. Callers that
+ * genuinely want to hash against a single shared env should build
+ * `{ [task.id]: env }` for every task.
+ */
+export declare function hashTasks(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, taskDetails: TaskDetails | null, tasksToHashOverride?: Task[]): Promise<void>;

package/dist/src/hasher/hash-task.js

@@ -8,6 +8,7 @@ const nx_json_1 = require("../config/nx-json");
 const native_1 = require("../native");
 const project_graph_1 = require("../project-graph/project-graph");
 const task_io_service_1 = require("../tasks-runner/task-io-service");
+const task_env_1 = require("../tasks-runner/task-env");
 const utils_1 = require("../tasks-runner/utils");
 const db_connection_1 = require("../utils/db-connection");
 const task_hasher_1 = require("./task-hasher");
@@ -24,9 +25,10 @@ function getTaskDetails() {
 }
 async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson, tasksDetails) {
     performance.mark('hashMultipleTasks:start');
+    const projects = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects;
     const tasks = Object.values(taskGraph.tasks);
     const tasksWithHashers = await Promise.all(tasks.map(async (task) => {
-        const customHasher = (0, utils_1.getCustomHasher)(task, projectGraph);
+        const customHasher = (0, utils_1.getCustomHasher)(task, projects);
         return { task, customHasher };
     }));
     const tasksToHash = tasksWithHashers
@@ -39,7 +41,11 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
             (0, task_hasher_1.getInputs)(task, projectGraph, nxJson).depsOutputs.length > 0);
     })
         .map((t) => t.task);
-    const hashes = await hasher.hashTasks(tasksToHash, taskGraph, process.env);
+    const perTaskEnvs = {};
+    for (const task of tasksToHash) {
+        perTaskEnvs[task.id] = (0, task_env_1.getTaskSpecificEnv)(task, projectGraph);
+    }
+    const hashes = await hasher.hashTasks(tasksToHash, taskGraph, perTaskEnvs);
     const ioService = (0, task_io_service_1.getTaskIOService)();
     const hasInputSubscribers = ioService.hasTaskInputSubscribers();
     for (let i = 0; i < tasksToHash.length; i++) {
@@ -63,8 +69,8 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
 }
 async function hashTask(hasher, projectGraph, taskGraph, task, env, taskDetails) {
     performance.mark('hashSingleTask:start');
-    const customHasher = (0, utils_1.getCustomHasher)(task, projectGraph);
     const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+    const customHasher = (0, utils_1.getCustomHasher)(task, projectsConfigurations.projects);
     const { value, details, inputs } = await (customHasher
         ? customHasher(task, {
             hasher,
@@ -96,7 +102,15 @@ async function hashTask(hasher, projectGraph, taskGraph, task, env, taskDetails)
     performance.mark('hashSingleTask:end');
     performance.measure('hashSingleTask', 'hashSingleTask:start', 'hashSingleTask:end');
 }
-async function hashTasks(hasher, projectGraph, taskGraph, env, taskDetails, tasksToHashOverride) {
+/**
+ * Batch-hash `tasks`. `perTaskEnvs` must contain an entry keyed by
+ * `task.id` for every task — the per-task env is what each task's
+ * custom hasher sees and what the built-in hasher reads
+ * `HashInstruction::Environment` inputs against. Callers that
+ * genuinely want to hash against a single shared env should build
+ * `{ [task.id]: env }` for every task.
+ */
+async function hashTasks(hasher, projectGraph, taskGraph, perTaskEnvs, taskDetails, tasksToHashOverride) {
     performance.mark('hashMultipleTasks:start');
     const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
     const nxJson = (0, nx_json_1.readNxJson)();
@@ -105,7 +119,7 @@ async function hashTasks(hasher, projectGraph, taskGraph, env, taskDetails, task
     const tasksWithCustomHashers = [];
     const tasksWithoutCustomHashers = [];
     for (const task of tasks) {
-        const customHasher = (0, utils_1.getCustomHasher)(task, projectGraph);
+        const customHasher = (0, utils_1.getCustomHasher)(task, projectsConfigurations.projects);
         if (customHasher) {
             tasksWithCustomHashers.push(task);
         }
@@ -117,7 +131,7 @@ async function hashTasks(hasher, projectGraph, taskGraph, env, taskDetails, task
     const ioService = (0, task_io_service_1.getTaskIOService)();
     const hasInputSubscribers = ioService.hasTaskInputSubscribers();
     const customHasherPromises = tasksWithCustomHashers.map(async (task) => {
-        const customHasher = (0, utils_1.getCustomHasher)(task, projectGraph);
+        const customHasher = (0, utils_1.getCustomHasher)(task, projectsConfigurations.projects);
         const { value, details, inputs } = await customHasher(task, {
             hasher,
             projectGraph,
@@ -125,7 +139,7 @@ async function hashTasks(hasher, projectGraph, taskGraph, env, taskDetails, task
             workspaceConfig: projectsConfigurations,
             projectsConfigurations,
             nxJsonConfiguration: nxJson,
-            env,
+            env: perTaskEnvs[task.id],
         });
         task.hash = value;
         task.hashDetails = details;
@@ -138,7 +152,7 @@ async function hashTasks(hasher, projectGraph, taskGraph, env, taskDetails, task
     let batchHashPromise = Promise.resolve();
     if (tasksWithoutCustomHashers.length > 0) {
         batchHashPromise = hasher
-            .hashTasks(tasksWithoutCustomHashers, taskGraph, env)
+            .hashTasks(tasksWithoutCustomHashers, taskGraph, perTaskEnvs)
             .then((hashes) => {
             for (let i = 0; i < tasksWithoutCustomHashers.length; i++) {
                 tasksWithoutCustomHashers[i].hash = hashes[i].value;
@@ -152,12 +166,25 @@ async function hashTasks(hasher, projectGraph, taskGraph, env, taskDetails, task
     }
     await Promise.all([...customHasherPromises, batchHashPromise]);
     if (taskDetails?.recordTaskDetails) {
-        taskDetails.recordTaskDetails(tasks.map((task) => ({
-            hash: task.hash,
-            project: task.target.project,
-            target: task.target.target,
-            configuration: task.target.configuration,
-        })));
+        // Guard against a custom hasher resolving with a falsy value —
+        // the built-in batch hasher always produces a hash, but user-written
+        // custom hashers are untrusted and an empty/undefined hash would
+        // violate the task_details schema downstream.
+        const hashedTasks = [];
+        for (const t of tasks) {
+            if (!t.hash) {
+                continue;
+            }
+            hashedTasks.push({
+                hash: t.hash,
+                project: t.target.project,
+                target: t.target.target,
+                configuration: t.target.configuration,
+            });
+        }
+        if (hashedTasks.length > 0) {
+            taskDetails.recordTaskDetails(hashedTasks);
+        }
     }
     performance.mark('hashMultipleTasks:end');
     performance.measure('hashMultipleTasks', 'hashMultipleTasks:start', 'hashMultipleTasks:end');

package/dist/src/hasher/native-task-hasher-impl.d.ts

@@ -14,5 +14,5 @@ export declare class NativeTaskHasherImpl implements TaskHasherImpl {
         selectivelyHashTsConfig: boolean;
     });
     hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<PartialHash>;
-    hashTasks(tasks: Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<PartialHash[]>;
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<PartialHash[]>;
 }

package/dist/src/hasher/native-task-hasher-impl.js

@@ -25,15 +25,13 @@ class NativeTaskHasherImpl {
         this.hasher = new native_1.TaskHasher(workspaceRoot, this.projectGraphRef, this.projectFileMapRef, this.allWorkspaceFilesRef, Buffer.from(JSON.stringify(tsconfig)), paths, rootTsConfigPath, options);
     }
     async hashTask(task, taskGraph, env, cwd, collectInputs) {
-        const plans = this.planner.getPlansReference([task.id], taskGraph);
-        const shouldCollectInputs = collectInputs ?? (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
-        const hashes = this.hasher.hashPlans(plans, env, cwd ?? process.cwd(), shouldCollectInputs);
-        return hashes[task.id];
+        const hashes = await this.hashTasks([task], taskGraph, { [task.id]: env }, cwd, collectInputs);
+        return hashes[0];
     }
-    async hashTasks(tasks, taskGraph, env, cwd, collectInputs) {
+    async hashTasks(tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
         const plans = this.planner.getPlansReference(tasks.map((t) => t.id), taskGraph);
         const shouldCollectInputs = collectInputs ?? (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
-        const hashes = this.hasher.hashPlans(plans, env, cwd ?? process.cwd(), shouldCollectInputs);
+        const hashes = this.hasher.hashPlans(plans, perTaskEnvs, cwd ?? process.cwd(), shouldCollectInputs);
         return tasks.map((t) => hashes[t.id]);
     }
 }

package/dist/src/hasher/task-hasher.d.ts

@@ -46,18 +46,29 @@ export interface TaskHasher {
     hashTask(task: Task, taskGraph: TaskGraph): Promise<Hash>;
     hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string): Promise<Hash>;
     /**
-     *  @deprecated use hashTasks(tasks:Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v20
-     * @param tasks
+     * @deprecated pass `perTaskEnvs` keyed by `task.id` instead — hashing
+     * every task against one shared env produces the wrong cache key when
+     * tasks have per-project/target `.env` files or custom hashers that
+     * read env. Will be removed in v22.
      */
-    hashTasks(tasks: Task[]): Promise<Hash[]>;
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string): Promise<Hash[]>;
     /**
-     * @deprecated use hashTasks(tasks:Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v20
+     * Hash `tasks`. `perTaskEnvs` must contain an entry keyed by `task.id`
+     * for every task in `tasks` — task-specific env (per-project/target
+     * `.env` files, custom-hasher env reads) participates in the hash, so
+     * a shared env across tasks would compute the wrong cache key when
+     * tasks actually differ.
      */
-    hashTasks(tasks: Task[], taskGraph: TaskGraph): Promise<Hash[]>;
-    hashTasks(tasks: Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string): Promise<Hash[]>;
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string): Promise<Hash[]>;
 }
 export interface TaskHasherImpl {
-    hashTasks(tasks: Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<PartialHash[]>;
+    /**
+     * Hash `tasks` where each task is keyed in `perTaskEnvs` by `task.id`.
+     * Every task must have an entry — callers who want to hash against a
+     * single shared env should construct `{ [task.id]: env }` for every
+     * task.
+     */
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<PartialHash[]>;
     hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<PartialHash>;
 }
 export type Hasher = TaskHasher;
@@ -65,7 +76,7 @@ export declare class DaemonBasedTaskHasher implements TaskHasher {
     private readonly daemonClient;
     private readonly runnerOptions;
     constructor(daemonClient: DaemonClient, runnerOptions: any);
-    hashTasks(tasks: Task[], taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv): Promise<Hash[]>;
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, envOrPerTaskEnvs: NodeJS.ProcessEnv | Record<string, NodeJS.ProcessEnv>): Promise<Hash[]>;
     hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv): Promise<Hash>;
 }
 export declare class InProcessTaskHasher implements TaskHasher {
@@ -75,7 +86,7 @@ export declare class InProcessTaskHasher implements TaskHasher {
     private readonly options;
     private taskHasher;
     constructor(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, externalRustReferences: NxWorkspaceFilesExternals | null, options: any);
-    hashTasks(tasks: Task[], taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<Hash[]>;
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, envOrPerTaskEnvs: NodeJS.ProcessEnv | Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<Hash[]>;
     hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<Hash>;
     private createHashDetails;
     private hashCommand;

package/dist/src/hasher/task-hasher.js

@@ -16,18 +16,46 @@ const minimatch_1 = require("minimatch");
 const native_task_hasher_impl_1 = require("./native-task-hasher-impl");
 const workspace_root_1 = require("../utils/workspace-root");
 const task_io_service_1 = require("../tasks-runner/task-io-service");
+/**
+ * Normalize the legacy single-env `hashTasks(tasks, taskGraph, env)`
+ * signature to the per-task-env shape. External plugins still call the
+ * legacy shape, so `InProcessTaskHasher` and `DaemonBasedTaskHasher`
+ * detect at runtime and broadcast the shared env across every task.
+ *
+ * Detection is by value shape: `NodeJS.ProcessEnv` values are strings
+ * (or undefined), `perTaskEnvs` values are objects.
+ */
+function normalizePerTaskEnvs(tasks, arg) {
+    for (const value of Object.values(arg)) {
+        if (value === undefined)
+            continue;
+        if (typeof value === 'object') {
+            return arg;
+        }
+        // First defined value is a string — legacy env; broadcast it.
+        const env = arg;
+        const perTaskEnvs = {};
+        for (const task of tasks)
+            perTaskEnvs[task.id] = env;
+        return perTaskEnvs;
+    }
+    // Empty or all-undefined: treat as perTaskEnvs — safe because the
+    // Rust-side check will surface a clear error if entries are missing.
+    return arg;
+}
 class DaemonBasedTaskHasher {
     constructor(daemonClient, runnerOptions) {
         this.daemonClient = daemonClient;
         this.runnerOptions = runnerOptions;
     }
-    async hashTasks(tasks, taskGraph, env) {
+    async hashTasks(tasks, taskGraph, envOrPerTaskEnvs) {
         const collectInputs = (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
-        return this.daemonClient.hashTasks(this.runnerOptions, tasks, taskGraph, env ?? process.env, process.cwd(), collectInputs);
+        return this.daemonClient.hashTasks(this.runnerOptions, tasks, taskGraph, normalizePerTaskEnvs(tasks, envOrPerTaskEnvs), process.cwd(), collectInputs);
     }
     async hashTask(task, taskGraph, env) {
-        const collectInputs = (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
-        return (await this.daemonClient.hashTasks(this.runnerOptions, [task], taskGraph, env ?? process.env, process.cwd(), collectInputs))[0];
+        return (await this.hashTasks([task], taskGraph, {
+            [task.id]: env ?? process.env,
+        }))[0];
     }
 }
 exports.DaemonBasedTaskHasher = DaemonBasedTaskHasher;
@@ -41,8 +69,8 @@ class InProcessTaskHasher {
             selectivelyHashTsConfig: this.options?.selectivelyHashTsConfig ?? false,
         });
     }
-    async hashTasks(tasks, taskGraph, env, cwd, collectInputs) {
-        const hashes = await this.taskHasher.hashTasks(tasks, taskGraph, env ?? process.env, cwd ?? process.cwd(), collectInputs);
+    async hashTasks(tasks, taskGraph, envOrPerTaskEnvs, cwd, collectInputs) {
+        const hashes = await this.taskHasher.hashTasks(tasks, taskGraph, normalizePerTaskEnvs(tasks, envOrPerTaskEnvs), cwd ?? process.cwd(), collectInputs);
         return tasks.map((task, index) => this.createHashDetails(task, hashes[index]));
     }
     async hashTask(task, taskGraph, env, cwd, collectInputs) {

package/dist/src/native/index.d.ts

@@ -55,7 +55,9 @@ export declare class HashPlanInspector {
    * Like `inspect()` but returns structured `HashInputs` objects instead of flat strings.
    * Each `HashInstruction` is categorized into the appropriate bucket (files, runtime,
    * environment, depOutputs, external). TsConfiguration is resolved to the root tsconfig
-   * file path. ProjectConfiguration is skipped for now. Cwd is skipped as it's ambient.
+   * file path. JsonFileSet is resolved to the matched JSON file paths (field/excludeField
+   * filters only affect hashing, not which files are reported as inputs).
+   * ProjectConfiguration is skipped for now. Cwd is skipped as it's ambient.
    */
   inspectInputs(hashPlans: ExternalObject<Record<string, Array<HashInstruction>>>): Record<string, HashInputs>
 }
@@ -83,6 +85,11 @@ export declare class NxCache {
   cacheDirectory: string
   constructor(workspaceRoot: string, cachePath: string, dbConnection: ExternalObject<NxDbConnection>, linkTaskDetails?: boolean | undefined | null, maxCacheSize?: number | undefined | null)
   get(hash: string): CachedResult | null
+  /**
+   * Batch version of get() that fetches multiple cache entries in a single
+   * SQL query and reads terminal output files in parallel via Rayon.
+   */
+  getBatch(hashes: Array<string>): Array<CachedResult | undefined | null>
   put(hash: string, terminalOutput: string, outputs: Array<string>, code: number): Array<string>
   applyRemoteCacheResults(hash: string, result: CachedResult, outputs?: Array<string> | undefined | null): void
   getTaskOutputsPath(hash: string): string
@@ -168,7 +175,15 @@ export declare class TaskDetails {
 
 export declare class TaskHasher {
   constructor(workspaceRoot: string, projectGraph: ExternalObject<ProjectGraph>, projectFileMap: ExternalObject<ProjectFiles>, allWorkspaceFiles: ExternalObject<Array<FileData>>, tsConfig: Buffer, tsConfigPaths: Record<string, Array<string>>, rootTsconfigPath?: string | undefined | null, options?: HasherOptions | undefined | null)
-  hashPlans(hashPlans: ExternalObject<Record<string, Array<HashInstruction>>>, jsEnv: Record<string, string>, cwd: string, collectTaskInputs?: boolean | undefined | null): NapiDashMap<string, HashDetails>
+  /**
+   * Hash each task's instructions using the env map keyed by `task.id`.
+   * Every task in `hash_plans` must have an entry in `per_task_envs` —
+   * a missing id surfaces as an error rather than silently hashing
+   * against an empty env. Callers that want to hash all tasks against
+   * the same env should build `per_task_envs` by keying that env under
+   * every task id.
+   */
+  hashPlans(hashPlans: ExternalObject<Record<string, Array<HashInstruction>>>, perTaskEnvs: Record<string, Record<string, string>>, cwd: string, collectTaskInputs?: boolean | undefined | null): NapiDashMap<string, HashDetails>
 }
 
 export declare class Watcher {
@@ -238,7 +253,7 @@ export interface DepsOutputsInput {
 
 /**
  * Detects which AI agent is running and returns its name.
- * Returns None if no agent is detected.
+ * Returns None if no agent is detected or when running inside the Nx daemon.
  * Filtering against supported agents should be done on the TypeScript side.
  */
 export declare function detectAiAgent(): string | null
@@ -311,10 +326,11 @@ export declare function getDefaultMaxCacheSize(cachePath: string): number
 export declare function getEventDimensions(): EventDimensions
 
 /**
- * Expands the given outputs into a list of existing files.
- * This is used when hashing outputs
+ * Batch version of get_files_for_outputs that processes multiple output
+ * entries in parallel using Rayon. Each entry is a list of output paths
+ * for a single task.
  */
-export declare function getFilesForOutputs(directory: string, entries: Array<string>): Array<string>
+export declare function getFilesForOutputsBatch(directory: string, entriesBatch: Array<Array<string>>): Array<Array<string>>
 
 /**
  * If `workspace_root` is inside a git worktree, returns the main repo root.
@@ -413,11 +429,22 @@ export declare function installNxConsoleForEditor(editor: SupportedEditor): Prom
 
 export const IS_WASM: boolean
 
-/** Detects if the current process is being run by an AI agent */
+/**
+ * Detects if the current process is being run by an AI agent.
+ * Always returns false when running inside the Nx daemon, since the daemon
+ * is a long-lived process that should not inherit AI agent behavior from
+ * the client that connected to it.
+ */
 export declare function isAiAgent(): boolean
 
 export declare function isEditorInstalled(editor: SupportedEditor): Promise<boolean>
 
+export interface JsonInput {
+  json: string
+  fields?: Array<string>
+  excludeFields?: Array<string>
+}
+
 export declare function logDebug(message: string): void
 
 /** Combined metadata for groups and processes */

package/dist/src/native/native-bindings.js

@@ -607,7 +607,7 @@ module.exports.flushTelemetry = nativeBinding.flushTelemetry
 module.exports.getBinaryTarget = nativeBinding.getBinaryTarget
 module.exports.getDefaultMaxCacheSize = nativeBinding.getDefaultMaxCacheSize
 module.exports.getEventDimensions = nativeBinding.getEventDimensions
-module.exports.getFilesForOutputs = nativeBinding.getFilesForOutputs
+module.exports.getFilesForOutputsBatch = nativeBinding.getFilesForOutputsBatch
 module.exports.getMainWorktreeRoot = nativeBinding.getMainWorktreeRoot
 module.exports.getTransformableOutputs = nativeBinding.getTransformableOutputs
 module.exports.GroupType = nativeBinding.GroupType

package/dist/src/native/nx.wasi-browser.js

@@ -117,7 +117,6 @@ export const copy = __napiModule.exports.copy
 export const expandOutputs = __napiModule.exports.expandOutputs
 export const findImports = __napiModule.exports.findImports
 export const getBinaryTarget = __napiModule.exports.getBinaryTarget
-export const getFilesForOutputs = __napiModule.exports.getFilesForOutputs
 export const getTransformableOutputs = __napiModule.exports.getTransformableOutputs
 export const hashArray = __napiModule.exports.hashArray
 export const hashFile = __napiModule.exports.hashFile

package/dist/src/native/nx.wasi.cjs

@@ -148,7 +148,6 @@ module.exports.copy = __napiModule.exports.copy
 module.exports.expandOutputs = __napiModule.exports.expandOutputs
 module.exports.findImports = __napiModule.exports.findImports
 module.exports.getBinaryTarget = __napiModule.exports.getBinaryTarget
-module.exports.getFilesForOutputs = __napiModule.exports.getFilesForOutputs
 module.exports.getTransformableOutputs = __napiModule.exports.getTransformableOutputs
 module.exports.hashArray = __napiModule.exports.hashArray
 module.exports.hashFile = __napiModule.exports.hashFile