nx 20.5.0-canary.20250201-05e0679 → 21.0.0-beta.0

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

@@ -78,28 +78,42 @@ 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 exitCode = messageToCode(message);
-            this.exitCallbacks.forEach((cb) => cb(exitCode));
+            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 });
+            });
         });
     }
     onExit(callback) {
         this.exitCallbacks.push(callback);
     }
     onOutput(callback) {
-        this.childProcess.onOutput(callback);
+        this.outputCallbacks.push(callback);
     }
     kill() {
-        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) {
+        if (this.isAlive) {
+            try {
+                this.childProcess.kill();
+            }
+            catch {
+                // when the child process completes before we explicitly call kill, this will throw
+                // do nothing
+            }
+            finally {
                 this.isAlive = false;
             }
         }

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

@@ -0,0 +1,14 @@
+import { BatchResults } from '../batch/batch-messages';
+import { ChildProcess, Serializable } from 'child_process';
+export declare class BatchProcess {
+    private childProcess;
+    private executorName;
+    private exitCallbacks;
+    private resultsCallbacks;
+    constructor(childProcess: ChildProcess, executorName: string);
+    onExit(cb: (code: number) => void): void;
+    onResults(cb: (results: BatchResults) => void): void;
+    getResults(): Promise<BatchResults>;
+    send(message: Serializable): void;
+    kill(signal?: NodeJS.Signals | number): void;
+}

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchProcess = void 0;
+const batch_messages_1 = require("../batch/batch-messages");
+const exit_codes_1 = require("../../utils/exit-codes");
+class BatchProcess {
+    constructor(childProcess, executorName) {
+        this.childProcess = childProcess;
+        this.executorName = executorName;
+        this.exitCallbacks = [];
+        this.resultsCallbacks = [];
+        this.childProcess.on('message', (message) => {
+            switch (message.type) {
+                case batch_messages_1.BatchMessageType.CompleteBatchExecution: {
+                    for (const cb of this.resultsCallbacks) {
+                        cb(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);
+                    }
+                }
+            }
+        });
+        this.childProcess.once('exit', (code, signal) => {
+            if (code === null)
+                code = (0, exit_codes_1.signalToCode)(signal);
+            for (const cb of this.exitCallbacks) {
+                cb(code);
+            }
+        });
+    }
+    onExit(cb) {
+        this.exitCallbacks.push(cb);
+    }
+    onResults(cb) {
+        this.resultsCallbacks.push(cb);
+    }
+    async getResults() {
+        return Promise.race([
+            new Promise((_, rej) => {
+                this.onExit((code) => {
+                    if (code !== 0) {
+                        rej(new Error(`"${this.executorName}" exited unexpectedly with code: ${code}`));
+                    }
+                });
+            }),
+            new Promise((res) => {
+                this.onResults(res);
+            }),
+        ]);
+    }
+    send(message) {
+        if (this.childProcess.connected) {
+            this.childProcess.send(message);
+        }
+    }
+    kill(signal) {
+        if (this.childProcess.connected) {
+            this.childProcess.kill(signal);
+        }
+    }
+}
+exports.BatchProcess = BatchProcess;

package/src/tasks-runner/running-tasks/node-child-process.d.ts

@@ -0,0 +1,36 @@
+import { ChildProcess, Serializable } from 'child_process';
+import { RunningTask } from './running-task';
+export declare class NodeChildProcessWithNonDirectOutput implements RunningTask {
+    private childProcess;
+    private terminalOutput;
+    private exitCallbacks;
+    constructor(childProcess: ChildProcess, { streamOutput, prefix }: {
+        streamOutput: boolean;
+        prefix: string;
+    });
+    onExit(cb: (code: number, terminalOutput: string) => void): void;
+    getResults(): Promise<{
+        code: number;
+        terminalOutput: string;
+    }>;
+    send(message: Serializable): void;
+    kill(signal?: NodeJS.Signals | number): void;
+}
+export declare class NodeChildProcessWithDirectOutput implements RunningTask {
+    private childProcess;
+    private temporaryOutputPath;
+    private terminalOutput;
+    private exitCallbacks;
+    private exited;
+    private exitCode;
+    constructor(childProcess: ChildProcess, temporaryOutputPath: string);
+    send(message: Serializable): void;
+    onExit(cb: (code: number, signal: NodeJS.Signals) => void): void;
+    getResults(): Promise<{
+        code: number;
+        terminalOutput: string;
+    }>;
+    waitForExit(): Promise<void>;
+    getTerminalOutput(): string;
+    kill(signal?: NodeJS.Signals | number): void;
+}

package/src/tasks-runner/running-tasks/node-child-process.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeChildProcessWithDirectOutput = exports.NodeChildProcessWithNonDirectOutput = void 0;
+const exit_codes_1 = require("../../utils/exit-codes");
+const stream_1 = require("stream");
+const chalk = require("chalk");
+const fs_1 = require("fs");
+class NodeChildProcessWithNonDirectOutput {
+    constructor(childProcess, { streamOutput, prefix }) {
+        this.childProcess = childProcess;
+        this.terminalOutput = '';
+        this.exitCallbacks = [];
+        if (streamOutput) {
+            if (process.env.NX_PREFIX_OUTPUT === 'true') {
+                const color = getColor(prefix);
+                const prefixText = `${prefix}:`;
+                this.childProcess.stdout
+                    .pipe(logClearLineToPrefixTransformer(color.bold(prefixText) + ' '))
+                    .pipe(addPrefixTransformer(color.bold(prefixText)))
+                    .pipe(process.stdout);
+                this.childProcess.stderr
+                    .pipe(logClearLineToPrefixTransformer(color(prefixText) + ' '))
+                    .pipe(addPrefixTransformer(color(prefixText)))
+                    .pipe(process.stderr);
+            }
+            else {
+                this.childProcess.stdout
+                    .pipe(addPrefixTransformer())
+                    .pipe(process.stdout);
+                this.childProcess.stderr
+                    .pipe(addPrefixTransformer())
+                    .pipe(process.stderr);
+            }
+        }
+        this.childProcess.on('exit', (code, signal) => {
+            if (code === null)
+                code = (0, exit_codes_1.signalToCode)(signal);
+            for (const cb of this.exitCallbacks) {
+                cb(code, this.terminalOutput);
+            }
+        });
+        // Re-emit any messages from the task process
+        this.childProcess.on('message', (message) => {
+            if (process.send) {
+                process.send(message);
+            }
+        });
+        this.childProcess.stdout.on('data', (chunk) => {
+            this.terminalOutput += chunk.toString();
+        });
+        this.childProcess.stderr.on('data', (chunk) => {
+            this.terminalOutput += chunk.toString();
+        });
+    }
+    onExit(cb) {
+        this.exitCallbacks.push(cb);
+    }
+    async getResults() {
+        return new Promise((res) => {
+            this.onExit((code, terminalOutput) => {
+                res({ code, terminalOutput });
+            });
+        });
+    }
+    send(message) {
+        if (this.childProcess.connected) {
+            this.childProcess.send(message);
+        }
+    }
+    kill(signal) {
+        if (this.childProcess.connected) {
+            this.childProcess.kill(signal);
+        }
+    }
+}
+exports.NodeChildProcessWithNonDirectOutput = NodeChildProcessWithNonDirectOutput;
+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();
+        },
+    });
+}
+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();
+        },
+    });
+}
+class NodeChildProcessWithDirectOutput {
+    constructor(childProcess, temporaryOutputPath) {
+        this.childProcess = childProcess;
+        this.temporaryOutputPath = temporaryOutputPath;
+        this.exitCallbacks = [];
+        this.exited = false;
+        // Re-emit any messages from the task process
+        this.childProcess.on('message', (message) => {
+            if (process.send) {
+                process.send(message);
+            }
+        });
+        this.childProcess.on('exit', (code, signal) => {
+            if (code === null)
+                code = (0, exit_codes_1.signalToCode)(signal);
+            this.exited = true;
+            this.exitCode = code;
+            for (const cb of this.exitCallbacks) {
+                cb(code, signal);
+            }
+        });
+    }
+    send(message) {
+        if (this.childProcess.connected) {
+            this.childProcess.send(message);
+        }
+    }
+    onExit(cb) {
+        this.exitCallbacks.push(cb);
+    }
+    async getResults() {
+        const terminalOutput = this.getTerminalOutput();
+        if (this.exited) {
+            return Promise.resolve({
+                code: this.exitCode,
+                terminalOutput,
+            });
+        }
+        await this.waitForExit();
+        return Promise.resolve({
+            code: this.exitCode,
+            terminalOutput,
+        });
+    }
+    waitForExit() {
+        return new Promise((res) => {
+            this.onExit(() => res());
+        });
+    }
+    getTerminalOutput() {
+        this.terminalOutput ??= (0, fs_1.readFileSync)(this.temporaryOutputPath).toString();
+        return this.terminalOutput;
+    }
+    kill(signal) {
+        if (this.childProcess.connected) {
+            this.childProcess.kill(signal);
+        }
+    }
+}
+exports.NodeChildProcessWithDirectOutput = NodeChildProcessWithDirectOutput;

package/src/tasks-runner/running-tasks/noop-child-process.d.ts

@@ -0,0 +1,15 @@
+import { RunningTask } from './running-task';
+export declare class NoopChildProcess implements RunningTask {
+    private results;
+    constructor(results: {
+        code: number;
+        terminalOutput: string;
+    });
+    send(): void;
+    getResults(): Promise<{
+        code: number;
+        terminalOutput: string;
+    }>;
+    kill(): void;
+    onExit(cb: (code: number) => void): void;
+}

package/src/tasks-runner/running-tasks/noop-child-process.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopChildProcess = void 0;
+class NoopChildProcess {
+    constructor(results) {
+        this.results = results;
+    }
+    send() { }
+    async getResults() {
+        return this.results;
+    }
+    kill() {
+        return;
+    }
+    onExit(cb) {
+        cb(this.results.code);
+    }
+}
+exports.NoopChildProcess = NoopChildProcess;

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

@@ -0,0 +1,8 @@
+export declare abstract class RunningTask {
+    abstract getResults(): Promise<{
+        code: number;
+        terminalOutput: string;
+    }>;
+    abstract onExit(cb: (code: number) => void): void;
+    abstract kill(signal?: NodeJS.Signals | number): Promise<void> | void;
+}

package/src/tasks-runner/running-tasks/running-task.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunningTask = void 0;
+class RunningTask {
+}
+exports.RunningTask = RunningTask;

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

@@ -5,6 +5,7 @@ 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;
@@ -27,7 +28,9 @@ export declare class TaskOrchestrator {
     private waitingForTasks;
     private groups;
     private bailed;
-    constructor(hasher: TaskHasher, initiatingProject: string | undefined, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string);
+    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);
     run(): Promise<{
         [id: string]: TaskStatus;
     }>;
@@ -40,7 +43,9 @@ export declare class TaskOrchestrator {
     private applyFromCacheOrRunBatch;
     private runBatch;
     private applyFromCacheOrRunTask;
+    private runTask;
     private runTaskInForkedProcess;
+    private startContinuousTask;
     private preRunSteps;
     private postRunSteps;
     private complete;
@@ -50,4 +55,5 @@ export declare class TaskOrchestrator {
     private openGroup;
     private shouldCopyOutputsFromCache;
     private recordOutputsHash;
+    private cleanup;
 }