nx 21.0.0-beta.1 → 21.0.0-canary.20250206-8bd0bcd

package/src/tasks-runner/forked-process-task-runner.d.ts

@@ -1,9 +1,7 @@
 import { DefaultTasksRunnerOptions } from './default-tasks-runner';
 import { Batch } from './tasks-schedule';
+import { BatchResults } from './batch/batch-messages';
 import { Task, TaskGraph } from '../config/task-graph';
-import { PseudoTtyProcess } from './pseudo-terminal';
-import { BatchProcess } from './running-tasks/batch-process';
-import { RunningTask } from './running-tasks/running-task';
 export declare class ForkedProcessTaskRunner {
     private readonly options;
     cliPath: string;
@@ -12,14 +10,17 @@ export declare class ForkedProcessTaskRunner {
     private pseudoTerminal;
     constructor(options: DefaultTasksRunnerOptions);
     init(): Promise<void>;
-    forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }: Batch, fullTaskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<BatchProcess>;
+    forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }: Batch, fullTaskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<BatchResults>;
     forkProcessLegacy(task: Task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }: {
         temporaryOutputPath: string;
         streamOutput: boolean;
         pipeOutput: boolean;
         taskGraph: TaskGraph;
         env: NodeJS.ProcessEnv;
-    }): Promise<RunningTask>;
+    }): Promise<{
+        code: number;
+        terminalOutput: string;
+    }>;
     forkProcess(task: Task, { temporaryOutputPath, streamOutput, taskGraph, env, disablePseudoTerminal, }: {
         temporaryOutputPath: string;
         streamOutput: boolean;
@@ -27,10 +28,15 @@ export declare class ForkedProcessTaskRunner {
         taskGraph: TaskGraph;
         env: NodeJS.ProcessEnv;
         disablePseudoTerminal: boolean;
-    }): Promise<RunningTask | PseudoTtyProcess>;
+    }): Promise<{
+        code: number;
+        terminalOutput: string;
+    }>;
     private forkProcessWithPseudoTerminal;
+    private forkProcessPipeOutputCapture;
     private forkProcessWithPrefixAndNotTTY;
     private forkProcessDirectOutputCapture;
+    private readTerminalOutput;
     private writeTerminalOutput;
     private setupProcessEventListeners;
 }

package/src/tasks-runner/forked-process-task-runner.js

@@ -3,15 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ForkedProcessTaskRunner = void 0;
 const fs_1 = require("fs");
 const child_process_1 = require("child_process");
+const chalk = require("chalk");
 const output_1 = require("../utils/output");
 const utils_1 = require("./utils");
 const path_1 = require("path");
 const batch_messages_1 = require("./batch/batch-messages");
 const strip_indents_1 = require("../utils/strip-indents");
+const stream_1 = require("stream");
 const pseudo_terminal_1 = require("./pseudo-terminal");
 const exit_codes_1 = require("../utils/exit-codes");
-const node_child_process_1 = require("./running-tasks/node-child-process");
-const batch_process_1 = require("./running-tasks/batch-process");
 const forkScript = (0, path_1.join)(__dirname, './fork.js');
 const workerPath = (0, path_1.join)(__dirname, './batch/run-batch.js');
 class ForkedProcessTaskRunner {
@@ -31,42 +31,76 @@ class ForkedProcessTaskRunner {
         this.setupProcessEventListeners();
     }
     // TODO: vsavkin delegate terminal output printing
-    async forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }, fullTaskGraph, env) {
-        const count = Object.keys(batchTaskGraph.tasks).length;
-        if (count > 1) {
-            output_1.output.logSingleLine(`Running ${output_1.output.bold(count)} ${output_1.output.bold('tasks')} with ${output_1.output.bold(executorName)}`);
-        }
-        else {
-            const args = (0, utils_1.getPrintableCommandArgsForTask)(Object.values(batchTaskGraph.tasks)[0]);
-            output_1.output.logCommand(args.join(' '));
-        }
-        const p = (0, child_process_1.fork)(workerPath, {
-            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
-            env,
-        });
-        const cp = new batch_process_1.BatchProcess(p, executorName);
-        this.processes.add(cp);
-        cp.onExit(() => {
-            this.processes.delete(cp);
-        });
-        // Start the tasks
-        cp.send({
-            type: batch_messages_1.BatchMessageType.RunTasks,
-            executorName,
-            batchTaskGraph,
-            fullTaskGraph,
+    forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }, fullTaskGraph, env) {
+        return new Promise((res, rej) => {
+            try {
+                const count = Object.keys(batchTaskGraph.tasks).length;
+                if (count > 1) {
+                    output_1.output.logSingleLine(`Running ${output_1.output.bold(count)} ${output_1.output.bold('tasks')} with ${output_1.output.bold(executorName)}`);
+                }
+                else {
+                    const args = (0, utils_1.getPrintableCommandArgsForTask)(Object.values(batchTaskGraph.tasks)[0]);
+                    output_1.output.logCommand(args.join(' '));
+                }
+                const p = (0, child_process_1.fork)(workerPath, {
+                    stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+                    env,
+                });
+                this.processes.add(p);
+                p.once('exit', (code, signal) => {
+                    this.processes.delete(p);
+                    if (code === null)
+                        code = (0, exit_codes_1.signalToCode)(signal);
+                    if (code !== 0) {
+                        const results = {};
+                        for (const rootTaskId of batchTaskGraph.roots) {
+                            results[rootTaskId] = {
+                                success: false,
+                                terminalOutput: '',
+                            };
+                        }
+                        rej(new Error(`"${executorName}" exited unexpectedly with code: ${code}`));
+                    }
+                });
+                p.on('message', (message) => {
+                    switch (message.type) {
+                        case batch_messages_1.BatchMessageType.CompleteBatchExecution: {
+                            res(message.results);
+                            break;
+                        }
+                        case batch_messages_1.BatchMessageType.RunTasks: {
+                            break;
+                        }
+                        default: {
+                            // Re-emit any non-batch messages from the task process
+                            if (process.send) {
+                                process.send(message);
+                            }
+                        }
+                    }
+                });
+                // Start the tasks
+                p.send({
+                    type: batch_messages_1.BatchMessageType.RunTasks,
+                    executorName,
+                    batchTaskGraph,
+                    fullTaskGraph,
+                });
+            }
+            catch (e) {
+                rej(e);
+            }
         });
-        return cp;
     }
     async forkProcessLegacy(task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }) {
         return pipeOutput
-            ? this.forkProcessWithPrefixAndNotTTY(task, {
+            ? await this.forkProcessPipeOutputCapture(task, {
                 temporaryOutputPath,
                 streamOutput,
                 taskGraph,
                 env,
             })
-            : this.forkProcessDirectOutputCapture(task, {
+            : await this.forkProcessDirectOutputCapture(task, {
                 temporaryOutputPath,
                 streamOutput,
                 taskGraph,
@@ -120,96 +154,158 @@ class ForkedProcessTaskRunner {
         p.onOutput((msg) => {
             terminalOutput += msg;
         });
-        p.onExit((code) => {
-            if (code > 128) {
-                process.exit(code);
-            }
-            this.processes.delete(p);
-            this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
-        });
-        return p;
-    }
-    forkProcessWithPrefixAndNotTTY(task, { streamOutput, temporaryOutputPath, taskGraph, env, }) {
-        try {
-            const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-            if (streamOutput) {
-                output_1.output.logCommand(args.join(' '));
-            }
-            const p = (0, child_process_1.fork)(this.cliPath, {
-                stdio: ['inherit', 'pipe', 'pipe', 'ipc'],
-                env,
-            });
-            // Send message to run the executor
-            p.send({
-                targetDescription: task.target,
-                overrides: task.overrides,
-                taskGraph,
-                isVerbose: this.verbose,
-            });
-            const cp = new node_child_process_1.NodeChildProcessWithNonDirectOutput(p, {
-                streamOutput,
-                prefix: task.target.project,
-            });
-            this.processes.add(cp);
-            cp.onExit((code, terminalOutput) => {
-                this.processes.delete(cp);
-                if (!streamOutput) {
-                    this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
+        return new Promise((res) => {
+            p.onExit((code) => {
+                // If the exit code is greater than 128, it's a special exit code for a signal
+                if (code >= 128) {
+                    process.exit(code);
                 }
                 this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
+                res({
+                    code,
+                    terminalOutput,
+                });
             });
-            return cp;
-        }
-        catch (e) {
-            console.error(e);
-            throw e;
-        }
+        });
     }
-    forkProcessDirectOutputCapture(task, { streamOutput, temporaryOutputPath, taskGraph, env, }) {
-        try {
-            const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-            if (streamOutput) {
-                output_1.output.logCommand(args.join(' '));
-            }
-            const p = (0, child_process_1.fork)(this.cliPath, {
-                stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
-                env,
-            });
-            const cp = new node_child_process_1.NodeChildProcessWithDirectOutput(p, temporaryOutputPath);
-            this.processes.add(cp);
-            // Send message to run the executor
-            p.send({
-                targetDescription: task.target,
-                overrides: task.overrides,
-                taskGraph,
-                isVerbose: this.verbose,
-            });
-            cp.onExit((code, signal) => {
-                this.processes.delete(cp);
-                // we didn't print any output as we were running the command
-                // print all the collected output
-                try {
-                    const terminalOutput = cp.getTerminalOutput();
+    forkProcessPipeOutputCapture(task, { streamOutput, temporaryOutputPath, taskGraph, env, }) {
+        return this.forkProcessWithPrefixAndNotTTY(task, {
+            streamOutput,
+            temporaryOutputPath,
+            taskGraph,
+            env,
+        });
+    }
+    forkProcessWithPrefixAndNotTTY(task, { streamOutput, temporaryOutputPath, taskGraph, env, }) {
+        return new Promise((res, rej) => {
+            try {
+                const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+                if (streamOutput) {
+                    output_1.output.logCommand(args.join(' '));
+                }
+                const p = (0, child_process_1.fork)(this.cliPath, {
+                    stdio: ['inherit', 'pipe', 'pipe', 'ipc'],
+                    env,
+                });
+                this.processes.add(p);
+                // Re-emit any messages from the task process
+                p.on('message', (message) => {
+                    if (process.send) {
+                        process.send(message);
+                    }
+                });
+                // Send message to run the executor
+                p.send({
+                    targetDescription: task.target,
+                    overrides: task.overrides,
+                    taskGraph,
+                    isVerbose: this.verbose,
+                });
+                if (streamOutput) {
+                    if (process.env.NX_PREFIX_OUTPUT === 'true') {
+                        const color = getColor(task.target.project);
+                        const prefixText = `${task.target.project}:`;
+                        p.stdout
+                            .pipe(logClearLineToPrefixTransformer(color.bold(prefixText) + ' '))
+                            .pipe(addPrefixTransformer(color.bold(prefixText)))
+                            .pipe(process.stdout);
+                        p.stderr
+                            .pipe(logClearLineToPrefixTransformer(color(prefixText) + ' '))
+                            .pipe(addPrefixTransformer(color(prefixText)))
+                            .pipe(process.stderr);
+                    }
+                    else {
+                        p.stdout.pipe(addPrefixTransformer()).pipe(process.stdout);
+                        p.stderr.pipe(addPrefixTransformer()).pipe(process.stderr);
+                    }
+                }
+                let outWithErr = [];
+                p.stdout.on('data', (chunk) => {
+                    outWithErr.push(chunk.toString());
+                });
+                p.stderr.on('data', (chunk) => {
+                    outWithErr.push(chunk.toString());
+                });
+                p.on('exit', (code, signal) => {
+                    this.processes.delete(p);
+                    if (code === null)
+                        code = (0, exit_codes_1.signalToCode)(signal);
+                    // we didn't print any output as we were running the command
+                    // print all the collected output|
+                    const terminalOutput = outWithErr.join('');
                     if (!streamOutput) {
                         this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
                     }
+                    this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
+                    res({ code, terminalOutput });
+                });
+            }
+            catch (e) {
+                console.error(e);
+                rej(e);
+            }
+        });
+    }
+    forkProcessDirectOutputCapture(task, { streamOutput, temporaryOutputPath, taskGraph, env, }) {
+        return new Promise((res, rej) => {
+            try {
+                const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+                if (streamOutput) {
+                    output_1.output.logCommand(args.join(' '));
                 }
-                catch (e) {
-                    console.log((0, strip_indents_1.stripIndents) `
+                const p = (0, child_process_1.fork)(this.cliPath, {
+                    stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+                    env,
+                });
+                this.processes.add(p);
+                // Re-emit any messages from the task process
+                p.on('message', (message) => {
+                    if (process.send) {
+                        process.send(message);
+                    }
+                });
+                // Send message to run the executor
+                p.send({
+                    targetDescription: task.target,
+                    overrides: task.overrides,
+                    taskGraph,
+                    isVerbose: this.verbose,
+                });
+                p.on('exit', (code, signal) => {
+                    if (code === null)
+                        code = (0, exit_codes_1.signalToCode)(signal);
+                    // we didn't print any output as we were running the command
+                    // print all the collected output
+                    let terminalOutput = '';
+                    try {
+                        terminalOutput = this.readTerminalOutput(temporaryOutputPath);
+                        if (!streamOutput) {
+                            this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
+                        }
+                    }
+                    catch (e) {
+                        console.log((0, strip_indents_1.stripIndents) `
               Unable to print terminal output for Task "${task.id}".
               Task failed with Exit Code ${code} and Signal "${signal}".
 
               Received error message:
               ${e.message}
             `);
-                }
-            });
-            return cp;
-        }
-        catch (e) {
-            console.error(e);
-            throw e;
-        }
+                    }
+                    res({
+                        code,
+                        terminalOutput,
+                    });
+                });
+            }
+            catch (e) {
+                console.error(e);
+                rej(e);
+            }
+        });
+    }
+    readTerminalOutput(outputPath) {
+        return (0, fs_1.readFileSync)(outputPath).toString();
     }
     writeTerminalOutput(outputPath, content) {
         (0, fs_1.writeFileSync)(outputPath, content);
@@ -222,11 +318,12 @@ class ForkedProcessTaskRunner {
         }
         // When the nx process gets a message, it will be sent into the task's process
         process.on('message', (message) => {
+            // this.publisher.publish(message.toString());
             if (this.pseudoTerminal) {
                 this.pseudoTerminal.sendMessageToChildren(message);
             }
             this.processes.forEach((p) => {
-                if ('send' in p) {
+                if ('connected' in p && p.connected) {
                     p.send(message);
                 }
             });
@@ -234,26 +331,34 @@ class ForkedProcessTaskRunner {
         // Terminate any task processes on exit
         process.on('exit', () => {
             this.processes.forEach((p) => {
-                p.kill();
+                if ('connected' in p ? p.connected : p.isAlive) {
+                    p.kill();
+                }
             });
         });
         process.on('SIGINT', () => {
             this.processes.forEach((p) => {
-                p.kill('SIGTERM');
+                if ('connected' in p ? p.connected : p.isAlive) {
+                    p.kill('SIGTERM');
+                }
             });
             // we exit here because we don't need to write anything to cache.
             process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
         });
         process.on('SIGTERM', () => {
             this.processes.forEach((p) => {
-                p.kill('SIGTERM');
+                if ('connected' in p ? p.connected : p.isAlive) {
+                    p.kill('SIGTERM');
+                }
             });
             // no exit here because we expect child processes to terminate which
             // will store results to the cache and will terminate this process
         });
         process.on('SIGHUP', () => {
             this.processes.forEach((p) => {
-                p.kill('SIGTERM');
+                if ('connected' in p ? p.connected : p.isAlive) {
+                    p.kill('SIGTERM');
+                }
             });
             // no exit here because we expect child processes to terminate which
             // will store results to the cache and will terminate this process
@@ -261,3 +366,51 @@ class ForkedProcessTaskRunner {
     }
 }
 exports.ForkedProcessTaskRunner = ForkedProcessTaskRunner;
+const colors = [
+    chalk.green,
+    chalk.greenBright,
+    chalk.red,
+    chalk.redBright,
+    chalk.cyan,
+    chalk.cyanBright,
+    chalk.yellow,
+    chalk.yellowBright,
+    chalk.magenta,
+    chalk.magentaBright,
+];
+function getColor(projectName) {
+    let code = 0;
+    for (let i = 0; i < projectName.length; ++i) {
+        code += projectName.charCodeAt(i);
+    }
+    const colorIndex = code % colors.length;
+    return colors[colorIndex];
+}
+/**
+ * Prevents terminal escape sequence from clearing line prefix.
+ */
+function logClearLineToPrefixTransformer(prefix) {
+    let prevChunk = null;
+    return new stream_1.Transform({
+        transform(chunk, _encoding, callback) {
+            if (prevChunk && prevChunk.toString() === '\x1b[2K') {
+                chunk = chunk.toString().replace(/\x1b\[1G/g, (m) => m + prefix);
+            }
+            this.push(chunk);
+            prevChunk = chunk;
+            callback();
+        },
+    });
+}
+function addPrefixTransformer(prefix) {
+    const newLineSeparator = process.platform.startsWith('win') ? '\r\n' : '\n';
+    return new stream_1.Transform({
+        transform(chunk, _encoding, callback) {
+            const list = chunk.toString().split(/\r\n|[\n\v\f\r\x85\u2028\u2029]/g);
+            list
+                .filter(Boolean)
+                .forEach((m) => this.push(prefix ? prefix + ' ' + m + newLineSeparator : m + newLineSeparator));
+            callback();
+        },
+    });
+}

package/src/tasks-runner/init-tasks-runner.js

@@ -36,10 +36,6 @@ async function initTasksRunner(nxArgs) {
                     acc[task.id] = [];
                     return acc;
                 }, {}),
-                continuousDependencies: opts.tasks.reduce((acc, task) => {
-                    acc[task.id] = [];
-                    return acc;
-                }, {}),
             };
             const taskResults = await (0, run_command_1.invokeTasksRunner)({
                 tasks: opts.tasks,

package/src/tasks-runner/pseudo-terminal.d.ts

@@ -31,14 +31,8 @@ export declare class PseudoTerminal {
 export declare class PseudoTtyProcess {
     private childProcess;
     isAlive: boolean;
-    private exitCallbacks;
-    private outputCallbacks;
-    private terminalOutput;
+    exitCallbacks: any[];
     constructor(childProcess: ChildProcess);
-    getResults(): Promise<{
-        code: number;
-        terminalOutput: string;
-    }>;
     onExit(callback: (code: number) => void): void;
     onOutput(callback: (message: string) => void): void;
     kill(): void;

package/src/tasks-runner/pseudo-terminal.js

@@ -78,42 +78,28 @@ class PseudoTtyProcess {
         this.childProcess = childProcess;
         this.isAlive = true;
         this.exitCallbacks = [];
-        this.outputCallbacks = [];
-        this.terminalOutput = '';
-        childProcess.onOutput((output) => {
-            this.terminalOutput += output;
-            this.outputCallbacks.forEach((cb) => cb(output));
-        });
         childProcess.onExit((message) => {
             this.isAlive = false;
-            const code = messageToCode(message);
-            childProcess.cleanup();
-            this.exitCallbacks.forEach((cb) => cb(code));
-        });
-    }
-    async getResults() {
-        return new Promise((res) => {
-            this.onExit((code) => {
-                res({ code, terminalOutput: this.terminalOutput });
-            });
+            const exitCode = messageToCode(message);
+            this.exitCallbacks.forEach((cb) => cb(exitCode));
         });
     }
     onExit(callback) {
         this.exitCallbacks.push(callback);
     }
     onOutput(callback) {
-        this.outputCallbacks.push(callback);
+        this.childProcess.onOutput(callback);
     }
     kill() {
-        if (this.isAlive) {
-            try {
-                this.childProcess.kill();
-            }
-            catch {
-                // when the child process completes before we explicitly call kill, this will throw
-                // do nothing
-            }
-            finally {
+        try {
+            this.childProcess.kill();
+        }
+        catch {
+            // when the child process completes before we explicitly call kill, this will throw
+            // do nothing
+        }
+        finally {
+            if (this.isAlive == true) {
                 this.isAlive = false;
             }
         }

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

@@ -5,7 +5,6 @@ import { ProjectGraph } from '../config/project-graph';
 import { TaskGraph } from '../config/task-graph';
 import { DaemonClient } from '../daemon/client/client';
 import { NxJsonConfiguration } from '../config/nx-json';
-import { NxArgs } from '../utils/command-line-utils';
 export declare class TaskOrchestrator {
     private readonly hasher;
     private readonly initiatingProject;
@@ -28,9 +27,7 @@ export declare class TaskOrchestrator {
     private waitingForTasks;
     private groups;
     private bailed;
-    private runningContinuousTasks;
-    private cleaningUp;
-    constructor(hasher: TaskHasher, initiatingProject: string | undefined, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: NxArgs & DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string);
+    constructor(hasher: TaskHasher, initiatingProject: string | undefined, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string);
     run(): Promise<{
         [id: string]: TaskStatus;
     }>;
@@ -43,9 +40,7 @@ export declare class TaskOrchestrator {
     private applyFromCacheOrRunBatch;
     private runBatch;
     private applyFromCacheOrRunTask;
-    private runTask;
     private runTaskInForkedProcess;
-    private startContinuousTask;
     private preRunSteps;
     private postRunSteps;
     private complete;
@@ -55,5 +50,4 @@ export declare class TaskOrchestrator {
     private openGroup;
     private shouldCopyOutputsFromCache;
     private recordOutputsHash;
-    private cleanup;
 }