nx 23.3.0-beta.0 → 23.3.0-beta.2

package/dist/src/tasks-runner/life-cycles/summary-terminal-output-life-cycle.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SummaryTerminalOutputLifeCycle = void 0;
+const output_1 = require("../../utils/output");
+const terminal_output_path_1 = require("../terminal-output-path");
+/**
+ * Prints a run as a handful of lines rather than a transcript: counts, then one
+ * line per failure naming the file that holds its output. Task output stops
+ * being a stream to read and becomes an artifact to address, so the size of this
+ * renderer's output depends on how many tasks failed, never on how loud they
+ * were.
+ *
+ * Selected by `--output-style=summary`, and by default when Nx is driven by an
+ * AI agent, which otherwise reads thousands of lines of passing output to find
+ * the one failure.
+ */
+class SummaryTerminalOutputLifeCycle {
+    constructor(tasks) {
+        this.tasks = tasks;
+        this.failed = [];
+        this.stopped = [];
+        this.completed = new Set();
+        this.succeeded = 0;
+        this.cached = 0;
+        this.batchLogs = new Map();
+    }
+    setCloudLink(label, url) {
+        this.cloudLink = { label, url };
+    }
+    batchOutputAvailable(batchId, path) {
+        this.batchLogs.set(batchId, path);
+    }
+    /**
+     * Nothing is printed as tasks complete. A summary that interleaved with
+     * progress would be a transcript again.
+     */
+    printTaskTerminalOutput() { }
+    endTasks(taskResults) {
+        for (const { task, status, terminalOutput } of taskResults) {
+            this.completed.add(task.id);
+            switch (status) {
+                case 'failure':
+                    // Whether a log file exists is decided here, not at render time.
+                    // `persistTerminalOutputs` skips only an undefined `terminalOutput`,
+                    // so an empty one still writes a 0-byte file - truthiness, not
+                    // definedness, is what says a reader will find something there.
+                    this.failed.push({
+                        task,
+                        hasOutput: !!terminalOutput,
+                    });
+                    break;
+                case 'stopped':
+                    // Every task of a stopped batch carries `''`: the worker's partial
+                    // log is announced as the batch's own artifact now, not folded into
+                    // any task. So these address a file only when something else wrote
+                    // one, and the batch log is addressed once below.
+                    this.stopped.push({
+                        task,
+                        hasOutput: !!terminalOutput,
+                    });
+                    break;
+                case 'local-cache':
+                case 'local-cache-kept-existing':
+                case 'remote-cache':
+                    this.cached++;
+                    this.succeeded++;
+                    break;
+                default:
+                    this.succeeded++;
+            }
+        }
+    }
+    endCommand() {
+        const skipped = this.tasks.filter((t) => !this.completed.has(t.id)).length;
+        const bodyLines = [];
+        for (const { task, hasOutput } of this.failed) {
+            bodyLines.push('', ...this.failureBlock(task, hasOutput));
+        }
+        if (this.stopped.length > 0) {
+            bodyLines.push('', output_1.output.dim('Stopped before finishing:'), ...this.stopped.flatMap(({ task, hasOutput }) => {
+                const line = `${output_1.output.dim('-')} ${task.id}`;
+                return task.hash && hasOutput
+                    ? [
+                        line,
+                        output_1.output.dim(`  full log: ${(0, terminal_output_path_1.terminalOutputPathForHash)(task.hash)}`),
+                    ]
+                    : [line];
+            }));
+        }
+        if (this.batchLogs.size > 0) {
+            // One line per worker, not per task: a batch's log explains the whole
+            // batch, and no task's own output file contains it.
+            bodyLines.push('', output_1.output.dim('Batch worker logs:'));
+            for (const [batchId, path] of this.batchLogs) {
+                bodyLines.push(`${output_1.output.dim('-')} ${output_1.output.dim(`${batchId}: ${path}`)}`);
+            }
+        }
+        if (this.cloudLink) {
+            bodyLines.push('', `${this.cloudLink.label} ${this.cloudLink.url}`);
+        }
+        bodyLines.push('', output_1.output.dim('Re-run with --output-style=static to inline logs.'));
+        const title = this.countsLine(skipped);
+        if (this.failed.length > 0 || this.stopped.length > 0) {
+            output_1.output.error({ title, bodyLines });
+        }
+        else {
+            output_1.output.success({ title, bodyLines });
+        }
+    }
+    countsLine(skipped) {
+        const parts = [`${this.succeeded} succeeded`];
+        if (this.cached > 0) {
+            parts.push(`${this.cached} cached`);
+        }
+        if (this.failed.length > 0) {
+            parts.push(`${this.failed.length} failed`);
+        }
+        if (this.stopped.length > 0) {
+            parts.push(`${this.stopped.length} stopped`);
+        }
+        if (skipped > 0) {
+            parts.push(`${skipped} skipped`);
+        }
+        return `${this.tasks.length} ${this.tasks.length === 1 ? 'task' : 'tasks'}: ${parts.join(', ')}`;
+    }
+    failureBlock(task, hasOutput) {
+        // No exit code: `completeTasks` rebuilds `TaskResult.code` from the status,
+        // so every failure arrives as 1 and a task killed with 137 or a missing
+        // binary's 127 would all render `(exit 1)`. Printing a number that is
+        // always 1 to a reader whose job is to machine-read this line is worse than
+        // printing none. formatCommand is what every other renderer uses, so a task
+        // reads the same here as it does under --output-style=static.
+        const lines = [
+            `${output_1.output.colors.red('✖')} ${output_1.output.formatCommand(task.id)}`,
+        ];
+        // The log is addressed, not reproduced. `hash` is optional on the type but
+        // always set by the time a task has run — processTask hashes before it
+        // schedules — so that half only guards against printing a bogus path.
+        // `hasOutput` is the load-bearing half: no output, no file, no address.
+        if (task.hash && hasOutput) {
+            lines.push(output_1.output.dim(`  full log: ${(0, terminal_output_path_1.terminalOutputPathForHash)(task.hash)}`));
+        }
+        return lines;
+    }
+}
+exports.SummaryTerminalOutputLifeCycle = SummaryTerminalOutputLifeCycle;

package/dist/src/tasks-runner/prune-task-graph.d.ts

@@ -0,0 +1,17 @@
+import type { TaskGraph } from '../config/task-graph';
+/**
+ * Everything written onto a task as a run progresses: hashes and hash
+ * details by the hasher, timings by the orchestrator, terminal output by the
+ * Nx Cloud life cycle. Nothing that receives a task graph over a socket or
+ * a fork needs any of it. The daemon recomputes hashes, and a worker learns
+ * its own from `NX_TASK_HASH`; hash details are read only by Nx Cloud on the
+ * runner side.
+ */
+export declare const TASK_RESULT_FIELDS: readonly ['hash', 'hashDetails', 'startTime', 'endTime', 'terminalOutput'];
+/**
+ * A copy of the graph with `TASK_RESULT_FIELDS` removed from every task, made
+ * once per graph object. Structure and the remaining fields are fixed once a
+ * graph is built and only result fields change during a run, so the copy
+ * never goes stale, and the source graph is untouched.
+ */
+export declare function pruneTaskGraph(taskGraph: TaskGraph): TaskGraph;

package/dist/src/tasks-runner/prune-task-graph.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_RESULT_FIELDS = void 0;
+exports.pruneTaskGraph = pruneTaskGraph;
+/**
+ * Everything written onto a task as a run progresses: hashes and hash
+ * details by the hasher, timings by the orchestrator, terminal output by the
+ * Nx Cloud life cycle. Nothing that receives a task graph over a socket or
+ * a fork needs any of it. The daemon recomputes hashes, and a worker learns
+ * its own from `NX_TASK_HASH`; hash details are read only by Nx Cloud on the
+ * runner side.
+ */
+exports.TASK_RESULT_FIELDS = [
+    'hash',
+    'hashDetails',
+    'startTime',
+    'endTime',
+    'terminalOutput',
+];
+const prunedGraphs = new WeakMap();
+/**
+ * A copy of the graph with `TASK_RESULT_FIELDS` removed from every task, made
+ * once per graph object. Structure and the remaining fields are fixed once a
+ * graph is built and only result fields change during a run, so the copy
+ * never goes stale, and the source graph is untouched.
+ */
+function pruneTaskGraph(taskGraph) {
+    let pruned = prunedGraphs.get(taskGraph);
+    if (pruned)
+        return pruned;
+    const tasks = {};
+    for (const id in taskGraph.tasks) {
+        const task = taskGraph.tasks[id];
+        const copy = {};
+        for (const key in task) {
+            if (!exports.TASK_RESULT_FIELDS.includes(key)) {
+                copy[key] = task[key];
+            }
+        }
+        tasks[id] = copy;
+    }
+    pruned = { ...taskGraph, tasks };
+    prunedGraphs.set(taskGraph, pruned);
+    return pruned;
+}

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

@@ -35,6 +35,7 @@ const dynamic_run_many_terminal_output_life_cycle_1 = require("./life-cycles/dyn
 const dynamic_run_one_terminal_output_life_cycle_1 = require("./life-cycles/dynamic-run-one-terminal-output-life-cycle");
 const static_run_many_terminal_output_life_cycle_1 = require("./life-cycles/static-run-many-terminal-output-life-cycle");
 const static_run_one_terminal_output_life_cycle_1 = require("./life-cycles/static-run-one-terminal-output-life-cycle");
+const summary_terminal_output_life_cycle_1 = require("./life-cycles/summary-terminal-output-life-cycle");
 const store_run_information_life_cycle_1 = require("./life-cycles/store-run-information-life-cycle");
 const task_history_life_cycle_1 = require("./life-cycles/task-history-life-cycle");
 const task_profiling_life_cycle_1 = require("./life-cycles/task-profiling-life-cycle");
@@ -265,8 +266,14 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
             renderIsDone,
         };
     }
+    if (nxArgs.resolvedOutputStyle === 'summary') {
+        return {
+            lifeCycle: new summary_terminal_output_life_cycle_1.SummaryTerminalOutputLifeCycle(tasks),
+            renderIsDone: Promise.resolve(),
+        };
+    }
     const { runnerOptions } = getRunner(nxArgs, nxJson);
-    const useDynamicOutput = shouldUseDynamicLifeCycle(tasks, runnerOptions, nxArgs.outputStyle);
+    const useDynamicOutput = shouldUseDynamicLifeCycle(tasks, runnerOptions, nxArgs.specifiedOutputStyle);
     if (isRunOne) {
         if (useDynamicOutput) {
             return await (0, dynamic_run_one_terminal_output_life_cycle_1.createRunOneDynamicOutputRenderer)({
@@ -641,12 +648,12 @@ function setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles) {
     // grouping applies, let it win over the implicit request; an output style the
     // user asked for explicitly still wins over grouping.
     const batchMode = process.env.NX_BATCH_MODE === 'true' || nxArgs.batch;
-    if (nxArgs.outputStyle == 'stream' ||
+    if (nxArgs.specifiedOutputStyle == 'stream' ||
         (batchMode && !(0, output_1.isLogGroupingEnabled)())) {
         process.env.NX_STREAM_OUTPUT = 'true';
         process.env.NX_PREFIX_OUTPUT = 'true';
     }
-    if (nxArgs.outputStyle == 'stream-without-prefixes') {
+    if (nxArgs.specifiedOutputStyle == 'stream-without-prefixes') {
         process.env.NX_STREAM_OUTPUT = 'true';
         process.env.NX_PREFIX_OUTPUT = 'false';
     }
@@ -733,6 +740,9 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
                 // per-task-env shape and normalizes internally.
                 return hasher.hashTasks(tasks, taskGraph_, envOrPerTaskEnvs);
             },
+            hashTasksUpfront(tasks, taskGraph_, perTaskEnvs) {
+                return hasher.hashTasksUpfront(tasks, taskGraph_, perTaskEnvs);
+            },
         },
         daemon: client_1.daemonClient,
     });
@@ -789,6 +799,7 @@ function shouldUseDynamicLifeCycle(tasks, options, outputStyle) {
     if ((0, is_ci_1.isCI)())
         return false;
     if ((0, output_1.isStaticOutputStyle)(outputStyle) ||
+        outputStyle === 'summary' ||
         outputStyle === 'stream' ||
         outputStyle === 'stream-without-prefixes')
         return false;

package/dist/src/tasks-runner/running-tasks/batch-process.d.ts

@@ -4,6 +4,20 @@ import { BatchResults } from '../batch/batch-messages';
 export declare class BatchProcess {
     private childProcess;
     private executorName;
+    /**
+     * Whether the active output style puts task bytes on the terminal at all.
+     * `summary` does not, and its life cycle cannot enforce that here: this
+     * class writes to `output` directly from a stream handler, so without being
+     * told it would print a whole batch into a run that asked for log paths.
+     *
+     * False makes this capture rather than print. Suppressing the write alone
+     * would drop the bytes entirely off GitHub Actions, where nothing else
+     * captures them - and the worker's own crash output is exactly what no task
+     * ever claims, so it would exist nowhere.
+     */
+    private readonly printsOutput;
+    /** Labels the capture file so it is identifiable in `batchOutputs/`. */
+    private readonly batchId;
     private exitCallbacks;
     private batchResultsCallbacks;
     private taskResultsCallbacks;
@@ -24,49 +38,109 @@ export declare class BatchProcess {
      * length of a JS string.
      */
     private capturedOutputPath;
-    private capturedOutputFd;
+    private capturedOutputStream;
+    /** Sources paused for backpressure, awaiting a 'drain' that may never come. */
+    private readonly pausedSources;
     /**
      * 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.
+     * stdout delivers past the exit event — and writing then would reach a file
+     * the renderer has already read.
      */
     private capturedOutputDiscarded;
     /**
-     * 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.
+     * Set when the capture file could not be written. Whatever reached it is kept
+     * and still rendered: that is the head of the batch's log, where a compiler's
+     * first non-cascading errors are. Everything after it goes to the terminal -
+     * see `capture`.
      */
     private capturedOutputFailed;
-    private static capturedOutputCount;
-    constructor(childProcess: ChildProcess, executorName: string);
+    /** Set once the failure has been reported, so it is said once per batch. */
+    private capturedOutputWarned;
+    /** Set before `end()`: a write after it would destroy the unflushed tail. */
+    private capturedOutputClosing;
+    private static captureSeq;
+    /** Turns `flushCapturedOutput` waits for a resumed source to empty. */
+    private static readonly MAX_DRAIN_TURNS;
+    /**
+     * Makes the capture file unique across every batch in the process, which
+     * `batchId` alone does not: `TasksSchedule.batchCounters` is per instance, so
+     * a second orchestrator in the same process - `runDiscreteTasks` and
+     * `runContinuousTasks`, not the CLI - re-mints `<executor> 1`, and the pid
+     * cannot separate them.
+     */
+    private readonly captureSeq;
+    /**
+     * Separates this capture from one minted by a DIFFERENT process, which
+     * `captureSeq` cannot: it is a per-process static that restarts at 1. These
+     * files now outlive their batch and `cacheDir` can be shared across checkouts
+     * of a repo, so without this a recycled pid truncates a log an earlier run's
+     * summary is still pointing at.
+     */
+    private readonly captureNonce;
+    constructor(childProcess: ChildProcess, executorName: string, 
+    /**
+     * Whether the active output style puts task bytes on the terminal at all.
+     * `summary` does not, and its life cycle cannot enforce that here: this
+     * class writes to `output` directly from a stream handler, so without being
+     * told it would print a whole batch into a run that asked for log paths.
+     *
+     * False makes this capture rather than print. Suppressing the write alone
+     * would drop the bytes entirely off GitHub Actions, where nothing else
+     * captures them - and the worker's own crash output is exactly what no task
+     * ever claims, so it would exist nowhere.
+     */
+    printsOutput?: boolean, 
+    /** Labels the capture file so it is identifiable in `batchOutputs/`. */
+    batchId?: string);
     onExit(cb: (code: number) => void): void;
     onBatchResults(cb: (results: BatchResults) => void): void;
     onTaskResults(cb: (task: string, result: TaskResult) => void): void;
     onOutput(cb: (output: string) => void): void;
     private capture;
+    /**
+     * Puts bytes the capture could not take back on the terminal, on the stream
+     * they arrived on.
+     */
+    private forwardUncaptured;
+    /**
+     * Names the failure once. A stream reports it asynchronously, so the chunk
+     * that tripped it may or may not have reached disk - unlike a `writeSync`,
+     * there is no byte count to tell. Every chunk after it is forwarded.
+     */
+    private warnCaptureFailed;
+    /**
+     * Lets the worker write again after the capture has stopped.
+     *
+     * Without this a failed capture wedges the whole run: the source stays
+     * paused, so the worker blocks once its stdout pipe fills, never sends its
+     * results, and `getResults` waits on a batch that can no longer finish.
+     */
+    private resumeCapturedSources;
+    private openCapturedOutput;
+    /**
+     * Flushes and closes the capture so the file is complete before a caller
+     * reads it.
+     */
+    flushCapturedOutput(): Promise<void>;
     /**
      * 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.
+     * Not valid to read before `flushCapturedOutput`; that flush ends the stream,
+     * so a chunk arriving afterwards - a worker's stdout can deliver past the
+     * exit event `getResults()` settles on - is dropped rather than appended.
      */
     getCapturedOutputPath(): string | undefined;
     /** Releases the capture file. Safe to call more than once. */
     discardCapturedOutput(): void;
     /**
-     * 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.
+     * Destroys the stream 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.
      */
     private releaseCapturedOutput;
-    /** Closes the fd, keeping the file and its path readable. */
+    /** Destroys the stream, dropping anything still buffered. The file stays. */
     private closeCapturedOutput;
     getResults(): Promise<BatchResults>;
     send(message: Serializable): void;