nx 21.0.0-canary.20250206-8bd0bcd → 21.0.0-canary.20250418-8619c1d

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-env.d.ts

@@ -1,10 +1,7 @@
 import { Task } from '../config/task-graph';
 export declare function getEnvVariablesForBatchProcess(skipNxCache: boolean, captureStderr: boolean): NodeJS.ProcessEnv;
 export declare function getTaskSpecificEnv(task: Task): NodeJS.ProcessEnv;
-export declare function getEnvVariablesForTask(task: Task, taskSpecificEnv: NodeJS.ProcessEnv, forceColor: string, skipNxCache: boolean, captureStderr: boolean, outputPath: string, streamOutput: boolean): {
-    [x: string]: string;
-    TZ?: string;
-};
+export declare function getEnvVariablesForTask(task: Task, taskSpecificEnv: NodeJS.ProcessEnv, forceColor: string, skipNxCache: boolean, captureStderr: boolean, outputPath: string, streamOutput: boolean): NodeJS.ProcessEnv;
 /**
  * This function loads a .env file and expands the variables in it.
  * @param filename the .env file to load

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

@@ -75,6 +75,8 @@ function getNxEnvVariablesForTask(task, forceColor, skipNxCache, captureStderr,
     return {
         ...getNxEnvVariablesForForkedProcess(forceColor, skipNxCache, captureStderr, outputPath, streamOutput),
         ...env,
+        // Ensure the TUI does not get spawned within the TUI if ever tasks invoke Nx again
+        NX_TUI: 'false',
     };
 }
 /**

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

@@ -1,10 +1,12 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+import { Task, TaskGraph } from '../config/task-graph';
+import { DaemonClient } from '../daemon/client/client';
 import { TaskHasher } from '../hasher/task-hasher';
+import { NxArgs } from '../utils/command-line-utils';
 import { DefaultTasksRunnerOptions } from './default-tasks-runner';
+import { RunningTask } from './running-tasks/running-task';
 import { TaskStatus } from './tasks-runner';
-import { ProjectGraph } from '../config/project-graph';
-import { TaskGraph } from '../config/task-graph';
-import { DaemonClient } from '../daemon/client/client';
-import { NxJsonConfiguration } from '../config/nx-json';
 export declare class TaskOrchestrator {
     private readonly hasher;
     private readonly initiatingProject;
@@ -15,9 +17,12 @@ export declare class TaskOrchestrator {
     private readonly bail;
     private readonly daemon;
     private readonly outputStyle;
+    private readonly taskGraphForHashing;
     private taskDetails;
     private cache;
+    private readonly tuiEnabled;
     private forkedProcessTaskRunner;
+    private runningTasksService;
     private tasksSchedule;
     private batchEnv;
     private reverseTaskDeps;
@@ -27,22 +32,33 @@ 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, taskGraphForHashing?: TaskGraph);
+    init(): Promise<void>;
     run(): Promise<{
         [id: string]: TaskStatus;
     }>;
     private executeNextBatchOfTasksUsingTaskSchedule;
-    private processScheduledTask;
+    processTask(taskId: string): Promise<NodeJS.ProcessEnv>;
     private processScheduledBatch;
     private processAllScheduledTasks;
     private applyCachedResults;
     private applyCachedResult;
     private applyFromCacheOrRunBatch;
     private runBatch;
-    private applyFromCacheOrRunTask;
+    applyFromCacheOrRunTask(doNotSkipCache: boolean, task: Task, groupId: number): Promise<{
+        task: Task;
+        code: number;
+        status: TaskStatus;
+        terminalOutput?: string;
+    }>;
+    private runTask;
     private runTaskInForkedProcess;
+    startContinuousTask(task: Task, groupId: number): Promise<RunningTask>;
     private preRunSteps;
     private postRunSteps;
+    private scheduleNextTasksAndReleaseThreads;
     private complete;
     private pipeOutputCapture;
     private shouldCacheTaskResult;
@@ -50,4 +66,6 @@ export declare class TaskOrchestrator {
     private openGroup;
     private shouldCopyOutputsFromCache;
     private recordOutputsHash;
+    private cleanup;
 }
+export declare function getThreadCount(options: NxArgs & DefaultTasksRunnerOptions, taskGraph: TaskGraph): number;