@depup/nx 23.1.2-depup.1 → 23.2.0-depup.0

package/dist/src/tasks-runner/running-tasks/batch-process.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BatchProcess = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
 const native_1 = require("../../native");
+const cache_directory_1 = require("../../utils/cache-directory");
 const exit_codes_1 = require("../../utils/exit-codes");
+const output_1 = require("../../utils/output");
 const batch_messages_1 = require("../batch/batch-messages");
 class BatchProcess {
     constructor(childProcess, executorName) {
@@ -12,6 +16,18 @@ class BatchProcess {
         this.batchResultsCallbacks = [];
         this.taskResultsCallbacks = [];
         this.outputCallbacks = [];
+        /**
+         * Set once the capture is released. A chunk can still arrive after that —
+         * stdout delivers past the exit event — and reopening then would mint a
+         * second numbered file that nothing ever cleans up.
+         */
+        this.capturedOutputDiscarded = false;
+        /**
+         * Set when writing the capture failed. Distinct from discarded: the bytes
+         * already on disk are still the best record of the batch, so the file is kept
+         * and rendered, while everything after the failure goes live to the terminal.
+         */
+        this.capturedOutputFailed = false;
         this.childProcess.on('message', (message) => {
             switch (message.type) {
                 case batch_messages_1.BatchMessageType.CompleteTask: {
@@ -47,24 +63,39 @@ class BatchProcess {
         // Capture stdout output
         if (this.childProcess.stdout) {
             this.childProcess.stdout.on('data', (chunk) => {
-                const output = chunk.toString();
-                // Maintain current terminal output behavior
-                process.stdout.write(chunk);
+                const text = chunk.toString();
+                // When batch output is being folded, the live copy is suppressed to
+                // keep each group contiguous; it is retained (see capturedOutputPath)
+                // for the renderings that need it. Otherwise, maintain
+                // current terminal output behavior. These chunks are forwarded raw and
+                // routinely end mid-line, so they go through `output` to keep its line
+                // tracking accurate for whatever prints next.
+                if ((0, output_1.shouldGroupBatchOutput)()) {
+                    this.capture(chunk);
+                }
+                else {
+                    output_1.output.writeTaskOutputChunk(chunk);
+                }
                 // Notify callbacks for TUI
                 for (const cb of this.outputCallbacks) {
-                    cb(output);
+                    cb(text);
                 }
             });
         }
         // Capture stderr output
         if (this.childProcess.stderr) {
             this.childProcess.stderr.on('data', (chunk) => {
-                const output = chunk.toString();
-                // Maintain current terminal output behavior
-                process.stderr.write(chunk);
+                const text = chunk.toString();
+                if ((0, output_1.shouldGroupBatchOutput)()) {
+                    this.capture(chunk, process.stderr);
+                }
+                else {
+                    // Maintain current terminal output behavior
+                    output_1.output.writeTaskOutputChunk(chunk, process.stderr);
+                }
                 // Notify callbacks for TUI
                 for (const cb of this.outputCallbacks) {
-                    cb(output);
+                    cb(text);
                 }
             });
         }
@@ -81,6 +112,127 @@ class BatchProcess {
     onOutput(cb) {
         this.outputCallbacks.push(cb);
     }
+    capture(chunk, stream = process.stdout) {
+        // Only a released capture stops recording; a handed-over one keeps
+        // appending until the fold is rendered.
+        if (this.capturedOutputDiscarded) {
+            return;
+        }
+        if (this.capturedOutputFailed) {
+            // Capture is over, but the output is not optional. Everything from here
+            // goes straight to the terminal, on the stream it arrived on.
+            output_1.output.writeTaskOutputChunk(chunk, stream);
+            return;
+        }
+        // Hoisted so the catch can tell how much of this chunk reached the file: a
+        // `writeSync` that fails partway leaves a prefix on disk, and replaying the
+        // whole chunk live would print that prefix twice - once now, once when the
+        // fold reads the file.
+        const bytes = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+        let written = 0;
+        try {
+            if (this.capturedOutputFd === undefined) {
+                const dir = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'batch-outputs');
+                (0, fs_1.mkdirSync)(dir, { recursive: true });
+                const name = `${this.executorName.replace(/[^a-zA-Z0-9]+/g, '-')}-${process.pid}-${++BatchProcess.capturedOutputCount}.log`;
+                const path = (0, path_1.join)(dir, name);
+                // Assigned only once the file is actually open, so a path always names
+                // an fd rather than a file that failed to open.
+                const fd = (0, fs_1.openSync)(path, 'w');
+                this.capturedOutputPath = path;
+                this.capturedOutputFd = fd;
+            }
+            // Written synchronously so the file is complete the moment the batch ends,
+            // with no flush to sequence against the read that renders the fold.
+            while (written < bytes.length) {
+                written += (0, fs_1.writeSync)(this.capturedOutputFd, bytes, written);
+            }
+        }
+        catch (e) {
+            // This runs inside a stream 'data' handler, where a throw is an uncaught
+            // exception rather than something the orchestrator's try can see - so a
+            // full disk or a read-only data directory would take down a run that
+            // otherwise had nothing wrong with it. The capture is an optimization
+            // that the common path discards anyway, so give it up and put the bytes
+            // back on the terminal instead of losing both them and the run.
+            // Latch on a flag of its own rather than reusing the discard flag: that
+            // one makes `capture` return early, which would drop every later chunk
+            // on the floor - captured nowhere and printed nowhere.
+            this.capturedOutputFailed = true;
+            // Close the fd but keep the file. Whatever was written before the failure
+            // is still the head of the batch's log, which is where a compiler's first
+            // non-cascading errors live; unlinking it here would throw away the most
+            // useful bytes precisely when the disk is in trouble.
+            this.closeCapturedOutput();
+            // Forward only what did not reach the file, and do it before warning.
+            // `output.warn` writes to the terminal as well, so if that is the thing
+            // failing, the bytes this handler was handed must already be out - losing
+            // the warning is survivable, losing task output is what this path exists
+            // to prevent.
+            const unwritten = bytes.subarray(written);
+            if (unwritten.length > 0) {
+                output_1.output.writeTaskOutputChunk(unwritten, stream);
+            }
+            output_1.output.warn({
+                title: `Could not capture batch output for ${this.executorName}`,
+                bodyLines: [
+                    e.message,
+                    'Streaming the rest of it live instead; the fold holds what was captured first.',
+                ],
+            });
+        }
+    }
+    /**
+     * Path to the file holding everything held back from the live stream under
+     * log grouping, or undefined if nothing was captured. Used to render the whole
+     * batch as one fold, so output no task claimed is not lost.
+     *
+     * The file is deliberately left open rather than closed here. A worker's
+     * stdout can deliver after its exit event — which is what `getResults()`
+     * settles on — and leaving the fd open keeps such a chunk appending to this
+     * same file instead of minting a second numbered one that nothing cleans up.
+     * The caller reads the file once, synchronously, while rendering the fold, so
+     * anything arriving after that read is not shown; writes are unbuffered, so
+     * the read always sees a complete prefix of what has arrived by then.
+     */
+    getCapturedOutputPath() {
+        return this.capturedOutputPath;
+    }
+    /** Releases the capture file. Safe to call more than once. */
+    discardCapturedOutput() {
+        this.capturedOutputDiscarded = true;
+        this.releaseCapturedOutput();
+    }
+    /**
+     * Closes the fd and unlinks the file, leaving no path behind for a caller to
+     * read. Tolerates a partially-initialized capture, since it also runs when
+     * opening or writing the file is what failed.
+     */
+    releaseCapturedOutput() {
+        this.closeCapturedOutput();
+        if (this.capturedOutputPath) {
+            try {
+                (0, fs_1.rmSync)(this.capturedOutputPath, { force: true });
+            }
+            catch {
+                // `force` covers a missing file but not a locked one: on Windows an fd
+                // that failed to close still holds a share lock. This runs from
+                // `runBatch`'s finally, where throwing would replace the batch's real
+                // result with a cleanup error, so a stale file is the lesser outcome.
+            }
+            this.capturedOutputPath = undefined;
+        }
+    }
+    /** Closes the fd, keeping the file and its path readable. */
+    closeCapturedOutput() {
+        if (this.capturedOutputFd !== undefined) {
+            try {
+                (0, fs_1.closeSync)(this.capturedOutputFd);
+            }
+            catch { }
+            this.capturedOutputFd = undefined;
+        }
+    }
     async getResults() {
         return Promise.race([
             new Promise((_, rej) => {
@@ -108,3 +260,4 @@ class BatchProcess {
     }
 }
 exports.BatchProcess = BatchProcess;
+BatchProcess.capturedOutputCount = 0;

package/dist/src/tasks-runner/task-env.d.ts

@@ -11,6 +11,31 @@ import { Task } from '../config/task-graph';
 export declare function getForceColorForChild(): string;
 export declare function getEnvVariablesForBatchProcess(skipNxCache: boolean, captureStderr: boolean): NodeJS.ProcessEnv;
 export declare function getTaskSpecificEnv(task: Task, graph: ProjectGraph): NodeJS.ProcessEnv;
+/**
+ * Reconstructs, at graph-construction time, the env a task would see: the
+ * root dotenv files Nx loaded at init are unloaded from the ambient env, then
+ * the dotenv files the task would load (`.env.<target>`, project-scoped
+ * `.env`, ...) are applied, so a task-scoped file wins over an init-time root
+ * load. The unload compares values, not provenance: a variable whose value
+ * differs from the root file's is kept and wins over the task files, while a
+ * shell-set value equal to the root file's is unloaded like the file's own.
+ *
+ * `createNodes` runs before any task, so the per-task dotenv files that
+ * `getTaskSpecificEnv` loads at run time are not in `process.env` yet. A plugin
+ * inferring targets from a config that reads `process.env` needs those values
+ * to resolve the config the way the task will. This mirrors
+ * `loadDotEnvFilesForTask` but takes the target coordinates directly (there is
+ * no `Task`/graph yet) and gates on `!== 'false'` rather than `=== 'true'`: the
+ * `'true'` marker is only stamped once the graph exists (`run-command.ts`),
+ * which is after this runs. Only the dotenv overlay is reconstructed: run-time
+ * env like `NX_TASK_TARGET_*` or `NX_TASK_HASH` is not included.
+ *
+ * `baseEnv` is the ambient env the overlay applies to, defaulting to the live
+ * `process.env`. A caller that runs config files in-process passes a snapshot
+ * taken under its load lock instead: a concurrent load's transient env writes
+ * would otherwise be read as ambient and mask the task files' values.
+ */
+export declare function getGraphTimeDotEnvForTask(projectRoot: string, target: string, configuration?: string, nonAtomizedTarget?: string, baseEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 export declare function getEnvVariablesForTask(task: Task, taskSpecificEnv: NodeJS.ProcessEnv, forceColor: string, skipNxCache: boolean, captureStderr: boolean, outputPath: string, streamOutput: boolean): NodeJS.ProcessEnv;
 /**
  * This function loads one or more .env files and expands the variables in them.

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getForceColorForChild = getForceColorForChild;
 exports.getEnvVariablesForBatchProcess = getEnvVariablesForBatchProcess;
 exports.getTaskSpecificEnv = getTaskSpecificEnv;
+exports.getGraphTimeDotEnvForTask = getGraphTimeDotEnvForTask;
 exports.getEnvVariablesForTask = getEnvVariablesForTask;
 exports.loadAndExpandDotEnvFile = loadAndExpandDotEnvFile;
 exports.unloadDotEnvFile = unloadDotEnvFile;
@@ -64,6 +65,44 @@ function getTaskSpecificEnv(task, graph) {
     taskSpecificEnvCache.set(task.id, env);
     return env;
 }
+/**
+ * Reconstructs, at graph-construction time, the env a task would see: the
+ * root dotenv files Nx loaded at init are unloaded from the ambient env, then
+ * the dotenv files the task would load (`.env.<target>`, project-scoped
+ * `.env`, ...) are applied, so a task-scoped file wins over an init-time root
+ * load. The unload compares values, not provenance: a variable whose value
+ * differs from the root file's is kept and wins over the task files, while a
+ * shell-set value equal to the root file's is unloaded like the file's own.
+ *
+ * `createNodes` runs before any task, so the per-task dotenv files that
+ * `getTaskSpecificEnv` loads at run time are not in `process.env` yet. A plugin
+ * inferring targets from a config that reads `process.env` needs those values
+ * to resolve the config the way the task will. This mirrors
+ * `loadDotEnvFilesForTask` but takes the target coordinates directly (there is
+ * no `Task`/graph yet) and gates on `!== 'false'` rather than `=== 'true'`: the
+ * `'true'` marker is only stamped once the graph exists (`run-command.ts`),
+ * which is after this runs. Only the dotenv overlay is reconstructed: run-time
+ * env like `NX_TASK_TARGET_*` or `NX_TASK_HASH` is not included.
+ *
+ * `baseEnv` is the ambient env the overlay applies to, defaulting to the live
+ * `process.env`. A caller that runs config files in-process passes a snapshot
+ * taken under its load lock instead: a concurrent load's transient env writes
+ * would otherwise be read as ambient and mask the task files' values.
+ */
+function getGraphTimeDotEnvForTask(projectRoot, target, configuration, nonAtomizedTarget, baseEnv = process.env) {
+    // Unload the root dotenv files loaded on init of Nx so the task-scoped files win.
+    const env = unloadDotEnvFiles({ ...baseEnv });
+    // Fall back to the live env when the snapshot has no entry: Windows resolves
+    // `process.env` case-insensitively but a plain snapshot keeps whichever
+    // spelling was exported, so a lowercase opt-out is invisible here otherwise.
+    if ((baseEnv.NX_LOAD_DOT_ENV_FILES ?? process.env.NX_LOAD_DOT_ENV_FILES) ===
+        'false') {
+        return env;
+    }
+    const dotEnvFiles = (0, task_env_paths_1.getEnvPathsForTask)(projectRoot, target, configuration, nonAtomizedTarget);
+    loadAndExpandDotEnvFile(dotEnvFiles.map((file) => (0, node_path_1.join)(workspace_root_1.workspaceRoot, file)), env);
+    return env;
+}
 function getEnvVariablesForTask(task, taskSpecificEnv, forceColor, skipNxCache, captureStderr, outputPath, streamOutput) {
     const res = {
         // Start With Dotenv Variables

package/dist/src/tasks-runner/task-orchestrator.d.ts

@@ -41,6 +41,12 @@ export declare class TaskOrchestrator {
     private pendingDiscreteWorkers;
     private groups;
     private continuousTasksStarted;
+    /**
+     * How many folds each batch id has rendered. A batch that reports a strict
+     * subset of its tasks is re-run under the same id, so one id can produce more
+     * than one fold and the redirect lines have to point at the right one.
+     */
+    private batchFoldRenders;
     private bailed;
     private resolveStopPromise;
     private stopRequested;
@@ -118,6 +124,68 @@ export declare class TaskOrchestrator {
     private hashBatchTasks;
     applyFromCacheOrRunBatch(doNotSkipCache: boolean, batch: Batch, groupId: number): Promise<TaskResult[]>;
     private runBatch;
+    /**
+     * Rendering a batch's output must never change the batch's results. A throw
+     * from the printer would otherwise land in `runBatch`'s own error handling:
+     * on the resolved path it rewrites every task to `failure` with the printer's
+     * stack as its output — reporting a green build red to the life cycles and Nx
+     * Cloud — and on the crash path it escapes `runBatch`, replacing the built
+     * failure results with the printer's error. Both call sites degrade to a
+     * warning here instead.
+     */
+    private renderBatchOutputSafely;
+    /**
+     * Prints a completed batch's output once, under log grouping. Live forwarding
+     * was suppressed while grouping, so this is the only copy — which is why the
+     * requested output style has to reach this path rather than stopping at the
+     * life cycle.
+     *
+     * Two things are rendered, and they answer different questions.
+     *
+     * Every task always renders through the life cycle, exactly as in a non-batch
+     * run - failures in full, successes collapsed to a line for run-many, plus the
+     * initiating project in full for run-one. That is what attributes output to a
+     * task, and it is the only place some of it exists: `@nx/jest` synthesizes
+     * each task's `terminalOutput` from an aggregated result and never writes
+     * those per-project summaries to the worker's stdio at all.
+     *
+     * The worker's whole captured log is rendered as a fold above them when the
+     * run asked for full output, or when any task failed or was stopped. A
+     * diagnostic that explains a failure is routinely one no task claimed:
+     * `@nx/maven`'s batch impl writes its exit-code dump and failed-task outputs
+     * to the worker's stderr via `console.error`, and the Maven JVM it spawns
+     * points slf4j at `System.out` because its own stderr carries the result
+     * protocol - two layers, two streams, both captured and neither attributed to
+     * a task - and `@nx/gradle` emits configuration-phase errors before the first
+     * `> Task :x:y` header tells it which task to attribute to. Both catch their
+     * own crash and backfill task results, so the batch resolves and lands here
+     * rather than in the caller's failure path.
+     *
+     * Rendering both duplicates some bytes, deliberately. `@nx/maven` and
+     * `@nx/gradle` tee each task's output into the worker's stdio on the way to
+     * `terminalOutput`, so a failing task's body appears in the fold and again in
+     * its own block. That is bounded on the default style, where successes
+     * collapse to a line each and a crashed batch backfills a short
+     * `e.toString()` rather than a body, so the case with the largest fold
+     * duplicates the least. Under a full-output style it is not bounded: every
+     * task prints in full beside a log that already contains it, which is the
+     * price of that style asking for everything. What it buys either way is
+     * attribution the fold cannot express. The
+     * alternative, letting the fold replace per-task rendering, silently dropped
+     * `@nx/jest`'s summaries and is what this shape exists to avoid.
+     *
+     * A batch that never reported results is handled by the caller instead.
+     */
+    private printGroupedBatchOutput;
+    /**
+     * Renders a batch's whole output as one fold, plus — unless `redirectLines`
+     * is off — a line per task pointing at it. The fold is labelled with the
+     * executor and a run-unique id (the same
+     * executor can run more than one batch), rather than an arbitrary task. Safe
+     * to write to `output` directly: grouping implies GitHub Actions implies a
+     * non-TTY, static lifecycle.
+     */
+    private printBatchFold;
     /**
      * Bulk-resolve cache hits for a set of tasks: fetch cached entries,
      * copy outputs as needed, fire lifecycle, and return the TaskResults

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

@@ -90,6 +90,12 @@ class TaskOrchestrator {
         this.pendingDiscreteWorkers = new Set();
         this.groups = [];
         this.continuousTasksStarted = 0;
+        /**
+         * How many folds each batch id has rendered. A batch that reports a strict
+         * subset of its tasks is re-run under the same id, so one id can produce more
+         * than one fold and the redirect lines have to point at the right one.
+         */
+        this.batchFoldRenders = new Map();
         this.bailed = false;
         this.resolveStopPromise = null;
         this.stopRequested = false;
@@ -576,8 +582,9 @@ class TaskOrchestrator {
     }
     async runBatch(batch, env, groupId) {
         const runBatchStart = perf_hooks_1.performance.mark('TaskOrchestrator-run-batch:start');
+        let batchProcess;
         try {
-            const batchProcess = await this.forkedProcessTaskRunner.forkProcessForBatch(batch, this.projectGraph, this.fullTaskGraph, env);
+            batchProcess = await this.forkedProcessTaskRunner.forkProcessForBatch(batch, this.projectGraph, this.fullTaskGraph, env);
             // Stream output from batch process to the batch
             batchProcess.onOutput((output) => {
                 this.options.lifeCycle.appendBatchOutput?.(batch.id, output);
@@ -595,7 +602,12 @@ class TaskOrchestrator {
                 // Skipped tasks didn't run, so they have no terminal output and don't
                 // need a per-task PTY — calling printTaskTerminalOutput would otherwise
                 // allocate one just to write a cursor-hide escape.
-                if (status !== 'skipped') {
+                //
+                // When the batch is being folded, printing is deferred to batch end
+                // (printGroupedBatchOutput), which always renders each task through the
+                // life cycle and adds the worker's whole log as a fold when the run
+                // asked for full output or any task failed or was stopped.
+                if (status !== 'skipped' && !(0, output_1.shouldGroupBatchOutput)()) {
                     this.options.lifeCycle.printTaskTerminalOutput(task, status, result.terminalOutput ?? '');
                 }
                 task.startTime = result.startTime;
@@ -607,7 +619,7 @@ class TaskOrchestrator {
             });
             const results = await batchProcess.getResults();
             const batchResultEntries = Object.entries(results);
-            return batchResultEntries.map(([taskId, result]) => {
+            const taskResults = batchResultEntries.map(([taskId, result]) => {
                 const task = this.taskGraph.tasks[taskId];
                 task.startTime = result.startTime;
                 task.endTime = result.endTime;
@@ -619,10 +631,14 @@ class TaskOrchestrator {
                     terminalOutput: result.terminalOutput,
                 };
             });
+            if ((0, output_1.shouldGroupBatchOutput)()) {
+                this.renderBatchOutputSafely(batch.id, () => this.printGroupedBatchOutput(batch, taskResults, batchProcess.getCapturedOutputPath()));
+            }
+            return taskResults;
         }
         catch (e) {
             const isBatchStopping = this.stopRequested;
-            return Object.keys(batch.taskGraph.tasks).map((taskId) => {
+            const taskResults = Object.keys(batch.taskGraph.tasks).map((taskId) => {
                 const task = this.taskGraph.tasks[taskId];
                 if (isBatchStopping) {
                     task.endTime = Date.now();
@@ -634,12 +650,147 @@ class TaskOrchestrator {
                     terminalOutput: isBatchStopping ? '' : (e.stack ?? e.message ?? ''),
                 };
             });
+            // The worker died without reporting results, so nothing was attributed to
+            // a task and no per-task output ran. Everything it wrote went to
+            // stdout/stderr, held back under log grouping — surface it as one fold.
+            // Outside grouping it already streamed live. This matters just as much
+            // when the batch was stopped: every task is marked stopped whether or not
+            // it finished, so the log is the only record of what got through. Only
+            // the exit-code error is dropped there, since it restates the
+            // cancellation.
+            if ((0, output_1.shouldGroupBatchOutput)()) {
+                const capturedOutputPath = batchProcess?.getCapturedOutputPath();
+                const trailer = isBatchStopping ? undefined : e.message;
+                if (capturedOutputPath || trailer) {
+                    this.renderBatchOutputSafely(batch.id, () => this.printBatchFold(batch, taskResults, {
+                        capturedOutputPath,
+                        trailer,
+                    }));
+                }
+            }
+            return taskResults;
         }
         finally {
+            batchProcess?.discardCapturedOutput();
             const runBatchEnd = perf_hooks_1.performance.mark('TaskOrchestrator-run-batch:end');
             perf_hooks_1.performance.measure('TaskOrchestrator-run-batch', runBatchStart.name, runBatchEnd.name);
         }
     }
+    /**
+     * Rendering a batch's output must never change the batch's results. A throw
+     * from the printer would otherwise land in `runBatch`'s own error handling:
+     * on the resolved path it rewrites every task to `failure` with the printer's
+     * stack as its output — reporting a green build red to the life cycles and Nx
+     * Cloud — and on the crash path it escapes `runBatch`, replacing the built
+     * failure results with the printer's error. Both call sites degrade to a
+     * warning here instead.
+     */
+    renderBatchOutputSafely(batchId, render) {
+        try {
+            render();
+        }
+        catch (e) {
+            output_1.output.warn({
+                title: `Could not render output for batch ${batchId}`,
+                bodyLines: [e.message],
+            });
+        }
+    }
+    /**
+     * Prints a completed batch's output once, under log grouping. Live forwarding
+     * was suppressed while grouping, so this is the only copy — which is why the
+     * requested output style has to reach this path rather than stopping at the
+     * life cycle.
+     *
+     * Two things are rendered, and they answer different questions.
+     *
+     * Every task always renders through the life cycle, exactly as in a non-batch
+     * run - failures in full, successes collapsed to a line for run-many, plus the
+     * initiating project in full for run-one. That is what attributes output to a
+     * task, and it is the only place some of it exists: `@nx/jest` synthesizes
+     * each task's `terminalOutput` from an aggregated result and never writes
+     * those per-project summaries to the worker's stdio at all.
+     *
+     * The worker's whole captured log is rendered as a fold above them when the
+     * run asked for full output, or when any task failed or was stopped. A
+     * diagnostic that explains a failure is routinely one no task claimed:
+     * `@nx/maven`'s batch impl writes its exit-code dump and failed-task outputs
+     * to the worker's stderr via `console.error`, and the Maven JVM it spawns
+     * points slf4j at `System.out` because its own stderr carries the result
+     * protocol - two layers, two streams, both captured and neither attributed to
+     * a task - and `@nx/gradle` emits configuration-phase errors before the first
+     * `> Task :x:y` header tells it which task to attribute to. Both catch their
+     * own crash and backfill task results, so the batch resolves and lands here
+     * rather than in the caller's failure path.
+     *
+     * Rendering both duplicates some bytes, deliberately. `@nx/maven` and
+     * `@nx/gradle` tee each task's output into the worker's stdio on the way to
+     * `terminalOutput`, so a failing task's body appears in the fold and again in
+     * its own block. That is bounded on the default style, where successes
+     * collapse to a line each and a crashed batch backfills a short
+     * `e.toString()` rather than a body, so the case with the largest fold
+     * duplicates the least. Under a full-output style it is not bounded: every
+     * task prints in full beside a log that already contains it, which is the
+     * price of that style asking for everything. What it buys either way is
+     * attribution the fold cannot express. The
+     * alternative, letting the fold replace per-task rendering, silently dropped
+     * `@nx/jest`'s summaries and is what this shape exists to avoid.
+     *
+     * A batch that never reported results is handled by the caller instead.
+     */
+    printGroupedBatchOutput(batch, taskResults, capturedOutputPath) {
+        // Read from the same field the streaming decision uses. `this.options` has
+        // its own `outputStyle`, merged from `nx.json`'s tasksRunnerOptions, so the
+        // two disagree whenever a style is configured there but not named on the
+        // command line - and `init-tasks-runner` passes a populated `options` with
+        // no style argument at all, so on that path only `options` can carry one.
+        const printsFullOutput = (0, output_1.printsFullTaskOutput)({
+            verbose: this.options.verbose,
+            outputStyle: this.outputStyle,
+        });
+        const batchOwnsTheDiagnostic = taskResults.some((r) => r.status === 'failure' || r.status === 'stopped');
+        if ((printsFullOutput || batchOwnsTheDiagnostic) && capturedOutputPath) {
+            // No redirect lines: every task renders itself below, so there is nothing
+            // to redirect anyone to.
+            this.printBatchFold(batch, taskResults, { capturedOutputPath }, { redirectLines: false });
+        }
+        for (const { task, status, terminalOutput } of taskResults) {
+            if (status !== 'skipped') {
+                this.options.lifeCycle.printTaskTerminalOutput(task, status, terminalOutput ?? '');
+            }
+        }
+    }
+    /**
+     * Renders a batch's whole output as one fold, plus — unless `redirectLines`
+     * is off — a line per task pointing at it. The fold is labelled with the
+     * executor and a run-unique id (the same
+     * executor can run more than one batch), rather than an arbitrary task. Safe
+     * to write to `output` directly: grouping implies GitHub Actions implies a
+     * non-TTY, static lifecycle.
+     */
+    printBatchFold(batch, taskResults, body, { redirectLines = true } = {}) {
+        // batch.id is already `<executor> <n>`, numbered per executor when the batch
+        // was scheduled. Deriving a second number here would drift from it, since
+        // only batches that render a fold would be counted. The suffix disambiguates
+        // re-runs of the same batch rather than replacing the id, so it cannot.
+        const renders = (this.batchFoldRenders.get(batch.id) ?? 0) + 1;
+        this.batchFoldRenders.set(batch.id, renders);
+        const label = renders === 1 ? `batch ${batch.id}` : `batch ${batch.id}:${renders}`;
+        const worst = taskResults.some((r) => r.status === 'failure')
+            ? 'failure'
+            : taskResults.some((r) => r.status === 'stopped')
+                ? 'stopped'
+                : 'success';
+        output_1.output.logBatchGroup(label, body, worst);
+        if (!redirectLines) {
+            return;
+        }
+        for (const { task, status } of taskResults) {
+            if (status !== 'skipped') {
+                output_1.output.logCommandRedirect((0, utils_1.getPrintableCommandArgsForTask)(task).join(' '), status, `(output in "${label}" above)`);
+            }
+        }
+    }
     // endregion Batch
     // region Single Task
     /**
@@ -727,7 +878,7 @@ class TaskOrchestrator {
         await this.preRunSteps([task], { groupId });
         const pipeOutput = await this.pipeOutputCapture(task);
         const temporaryOutputPath = this.cache.temporaryOutputPath(task);
-        const streamOutput = this.outputStyle === 'static'
+        const streamOutput = (0, output_1.isStaticOutputStyle)(this.outputStyle)
             ? false
             : (0, utils_1.shouldStreamOutput)(task, this.initiatingProject);
         const env = pipeOutput
@@ -805,7 +956,7 @@ class TaskOrchestrator {
                 else if (this.tuiEnabled) {
                     if (runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
                         // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
-                        this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+                        this.options.lifeCycle.registerRunningTask(task.id, runningTask.getPtyHandles());
                         runningTask.onOutput((output) => {
                             this.options.lifeCycle.appendTaskOutput(task.id, output, true);
                         });
@@ -854,7 +1005,7 @@ class TaskOrchestrator {
             if (this.tuiEnabled) {
                 if (runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
                     // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
-                    this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+                    this.options.lifeCycle.registerRunningTask(task.id, runningTask.getPtyHandles());
                     runningTask.onOutput((output) => {
                         this.options.lifeCycle.appendTaskOutput(task.id, output, true);
                     });
@@ -938,7 +1089,7 @@ class TaskOrchestrator {
         const pipeOutput = await this.pipeOutputCapture(task);
         // obtain metadata
         const temporaryOutputPath = this.cache.temporaryOutputPath(task);
-        const streamOutput = this.outputStyle === 'static'
+        const streamOutput = (0, output_1.isStaticOutputStyle)(this.outputStyle)
             ? false
             : (0, utils_1.shouldStreamOutput)(task, this.initiatingProject);
         let env = pipeOutput

package/dist/src/utils/analytics-enabled.d.ts

@@ -0,0 +1,7 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+/**
+ * Analytics are opt-in: both `"analytics": false` and an unset flag mean no
+ * event is ever sent. Anything enabled for the sake of analytics (network
+ * allowlists, endpoints) gates on this, not on an explicit opt-out alone.
+ */
+export declare function isAnalyticsEnabled(nxJson: NxJsonConfiguration | null): boolean;

package/dist/src/utils/analytics-enabled.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAnalyticsEnabled = isAnalyticsEnabled;
+/**
+ * Analytics are opt-in: both `"analytics": false` and an unset flag mean no
+ * event is ever sent. Anything enabled for the sake of analytics (network
+ * allowlists, endpoints) gates on this, not on an explicit opt-out alone.
+ */
+function isAnalyticsEnabled(nxJson) {
+    return nxJson?.analytics === true;
+}