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

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

@@ -1,29 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PseudoTtyProcessWithSend = exports.PseudoTtyProcess = exports.PseudoTerminal = void 0;
-exports.getPseudoTerminal = getPseudoTerminal;
+exports.createPseudoTerminal = createPseudoTerminal;
+const os = require("os");
+const socket_utils_1 = require("../daemon/socket-utils");
 const native_1 = require("../native");
 const pseudo_ipc_1 = require("./pseudo-ipc");
-const socket_utils_1 = require("../daemon/socket-utils");
-const os = require("os");
-let pseudoTerminal;
-function getPseudoTerminal(skipSupportCheck = false) {
+// Register single event listeners for all pseudo-terminal instances
+const pseudoTerminalShutdownCallbacks = [];
+process.on('SIGINT', () => {
+    pseudoTerminalShutdownCallbacks.forEach((cb) => cb());
+});
+process.on('SIGTERM', () => {
+    pseudoTerminalShutdownCallbacks.forEach((cb) => cb());
+});
+process.on('SIGHUP', () => {
+    pseudoTerminalShutdownCallbacks.forEach((cb) => cb());
+});
+process.on('exit', () => {
+    pseudoTerminalShutdownCallbacks.forEach((cb) => cb());
+});
+function createPseudoTerminal(skipSupportCheck = false) {
     if (!skipSupportCheck && !PseudoTerminal.isSupported()) {
         throw new Error('Pseudo terminal is not supported on this platform.');
     }
-    pseudoTerminal ??= new PseudoTerminal(new native_1.RustPseudoTerminal());
+    const pseudoTerminal = new PseudoTerminal(new native_1.RustPseudoTerminal());
+    pseudoTerminalShutdownCallbacks.push(pseudoTerminal.shutdown.bind(pseudoTerminal));
     return pseudoTerminal;
 }
+let id = 0;
 class PseudoTerminal {
     static isSupported() {
         return process.stdout.isTTY && supportedPtyPlatform();
     }
     constructor(rustPseudoTerminal) {
         this.rustPseudoTerminal = rustPseudoTerminal;
-        this.pseudoIPCPath = (0, socket_utils_1.getForkedProcessOsSocketPath)(process.pid.toString());
+        this.pseudoIPCPath = (0, socket_utils_1.getForkedProcessOsSocketPath)(process.pid.toString() + '-' + id++);
         this.pseudoIPC = new pseudo_ipc_1.PseudoIPCServer(this.pseudoIPCPath);
         this.initialized = false;
-        this.setupProcessListeners();
     }
     async init() {
         if (this.initialized) {
@@ -32,14 +46,19 @@ class PseudoTerminal {
         await this.pseudoIPC.init();
         this.initialized = true;
     }
+    shutdown() {
+        if (this.initialized) {
+            this.pseudoIPC.close();
+        }
+    }
     runCommand(command, { cwd, execArgv, jsEnv, quiet, tty, } = {}) {
-        return new PseudoTtyProcess(this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, execArgv, quiet, tty));
+        return new PseudoTtyProcess(this.rustPseudoTerminal, this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, execArgv, quiet, tty));
     }
     async fork(id, script, { cwd, execArgv, jsEnv, quiet, }) {
         if (!this.initialized) {
             throw new Error('Call init() before forking processes');
         }
-        const cp = new PseudoTtyProcessWithSend(this.rustPseudoTerminal.fork(id, script, this.pseudoIPCPath, cwd, jsEnv, execArgv, quiet), id, this.pseudoIPC);
+        const cp = new PseudoTtyProcessWithSend(this.rustPseudoTerminal, this.rustPseudoTerminal.fork(id, script, this.pseudoIPCPath, cwd, jsEnv, execArgv, quiet), id, this.pseudoIPC);
         await this.pseudoIPC.waitForChildReady(id);
         return cp;
     }
@@ -49,66 +68,63 @@ class PseudoTerminal {
     onMessageFromChildren(callback) {
         this.pseudoIPC.onMessageFromChildren(callback);
     }
-    setupProcessListeners() {
-        const shutdown = () => {
-            this.shutdownPseudoIPC();
-        };
-        process.on('SIGINT', () => {
-            this.shutdownPseudoIPC();
-        });
-        process.on('SIGTERM', () => {
-            this.shutdownPseudoIPC();
-        });
-        process.on('SIGHUP', () => {
-            this.shutdownPseudoIPC();
-        });
-        process.on('exit', () => {
-            this.shutdownPseudoIPC();
-        });
-    }
-    shutdownPseudoIPC() {
-        if (this.initialized) {
-            this.pseudoIPC.close();
-        }
-    }
 }
 exports.PseudoTerminal = PseudoTerminal;
 class PseudoTtyProcess {
-    constructor(childProcess) {
+    constructor(rustPseudoTerminal, childProcess) {
+        this.rustPseudoTerminal = rustPseudoTerminal;
         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;
             }
         }
     }
+    getParserAndWriter() {
+        return this.childProcess.getParserAndWriter();
+    }
 }
 exports.PseudoTtyProcess = PseudoTtyProcess;
 class PseudoTtyProcessWithSend extends PseudoTtyProcess {
-    constructor(_childProcess, id, pseudoIpc) {
-        super(_childProcess);
+    constructor(rustPseudoTerminal, _childProcess, id, pseudoIpc) {
+        super(rustPseudoTerminal, _childProcess);
+        this.rustPseudoTerminal = rustPseudoTerminal;
         this.id = id;
         this.pseudoIpc = pseudoIpc;
     }

package/src/tasks-runner/run-command.d.ts

@@ -29,6 +29,7 @@ export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, life
 }): Promise<{
     [id: string]: TaskResult;
 }>;
+export declare function constructLifeCycles(lifeCycle: LifeCycle): LifeCycle[];
 export declare function getRunner(nxArgs: NxArgs, nxJson: NxJsonConfiguration): {
     tasksRunner: TasksRunner;
     runnerOptions: any;

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

@@ -3,25 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommand = runCommand;
 exports.runCommandForTasks = runCommandForTasks;
 exports.invokeTasksRunner = invokeTasksRunner;
+exports.constructLifeCycles = constructLifeCycles;
 exports.getRunner = getRunner;
 exports.getRunnerOptions = getRunnerOptions;
 const enquirer_1 = require("enquirer");
+const node_path_1 = require("node:path");
+const node_util_1 = require("node:util");
 const ora = require("ora");
-const path_1 = require("path");
 const nx_json_1 = require("../config/nx-json");
 const client_1 = require("../daemon/client/client");
 const create_task_hasher_1 = require("../hasher/create-task-hasher");
 const hash_task_1 = require("../hasher/hash-task");
 const native_1 = require("../native");
+const tasks_execution_hooks_1 = require("../project-graph/plugins/tasks-execution-hooks");
 const project_graph_1 = require("../project-graph/project-graph");
 const fileutils_1 = require("../utils/fileutils");
+const handle_errors_1 = require("../utils/handle-errors");
 const is_ci_1 = require("../utils/is-ci");
 const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
+const nx_key_1 = require("../utils/nx-key");
 const output_1 = require("../utils/output");
-const handle_errors_1 = require("../utils/handle-errors");
 const sync_generators_1 = require("../utils/sync-generators");
 const workspace_root_1 = require("../utils/workspace-root");
 const create_task_graph_1 = require("./create-task-graph");
+const is_tui_enabled_1 = require("./is-tui-enabled");
 const life_cycle_1 = require("./life-cycle");
 const dynamic_run_many_terminal_output_life_cycle_1 = require("./life-cycles/dynamic-run-many-terminal-output-life-cycle");
 const dynamic_run_one_terminal_output_life_cycle_1 = require("./life-cycles/dynamic-run-one-terminal-output-life-cycle");
@@ -31,19 +36,172 @@ const store_run_information_life_cycle_1 = require("./life-cycles/store-run-info
 const task_history_life_cycle_1 = require("./life-cycles/task-history-life-cycle");
 const task_history_life_cycle_old_1 = require("./life-cycles/task-history-life-cycle-old");
 const task_profiling_life_cycle_1 = require("./life-cycles/task-profiling-life-cycle");
-const task_timings_life_cycle_1 = require("./life-cycles/task-timings-life-cycle");
 const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
+const task_timings_life_cycle_1 = require("./life-cycles/task-timings-life-cycle");
+const tui_summary_life_cycle_1 = require("./life-cycles/tui-summary-life-cycle");
 const task_graph_utils_1 = require("./task-graph-utils");
 const utils_1 = require("./utils");
 const chalk = require("chalk");
-const powerpack_1 = require("../utils/powerpack");
-const tasks_execution_hooks_1 = require("../project-graph/plugins/tasks-execution-hooks");
-async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides) {
+const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+const originalStderrWrite = process.stderr.write.bind(process.stderr);
+const originalConsoleLog = console.log.bind(console);
+const originalConsoleError = console.error.bind(console);
+async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides) {
+    const overridesWithoutHidden = { ...overrides };
+    delete overridesWithoutHidden['__overrides_unparsed__'];
+    if ((0, is_tui_enabled_1.isTuiEnabled)(nxJson)) {
+        const interceptedNxCloudLogs = [];
+        const createPatchedConsoleMethod = (originalMethod) => {
+            return (...args) => {
+                // Check if the log came from the Nx Cloud client, otherwise invoke the original write method
+                const stackTrace = new Error().stack;
+                const isNxCloudLog = stackTrace.includes((0, node_path_1.join)(workspace_root_1.workspaceRoot, '.nx', 'cache', 'cloud'));
+                if (!isNxCloudLog) {
+                    return originalMethod(...args);
+                }
+                // No-op the Nx Cloud client logs
+            };
+        };
+        // The cloud client calls console.log when NX_VERBOSE_LOGGING is set to true
+        console.log = createPatchedConsoleMethod(originalConsoleLog);
+        console.error = createPatchedConsoleMethod(originalConsoleError);
+        const patchedWrite = (_chunk, _encoding, callback) => {
+            // Preserve original behavior around callback and return value, just in case
+            if (callback) {
+                callback();
+            }
+            return true;
+        };
+        process.stdout.write = patchedWrite;
+        process.stderr.write = patchedWrite;
+        const { AppLifeCycle, restoreTerminal } = await Promise.resolve().then(() => require('../native'));
+        let appLifeCycle;
+        const isRunOne = initiatingProject != null;
+        const pinnedTasks = [];
+        const taskText = tasks.length === 1 ? 'task' : 'tasks';
+        const projectText = projectNames.length === 1 ? 'project' : 'projects';
+        let titleText = '';
+        if (isRunOne) {
+            const mainTaskId = (0, create_task_graph_1.createTaskId)(initiatingProject, nxArgs.targets[0], nxArgs.configuration);
+            pinnedTasks.push(mainTaskId);
+            const mainContinuousDependencies = taskGraph.continuousDependencies[mainTaskId];
+            if (mainContinuousDependencies.length > 0) {
+                pinnedTasks.push(mainContinuousDependencies[0]);
+            }
+            const [project, target] = mainTaskId.split(':');
+            titleText = `${target} ${project}`;
+            if (tasks.length > 1) {
+                titleText += `, and ${tasks.length - 1} requisite ${taskText}`;
+            }
+        }
+        else {
+            titleText =
+                nxArgs.targets.join(', ') +
+                    ` for ${projectNames.length} ${projectText}`;
+            if (tasks.length > projectNames.length) {
+                titleText += `, and ${tasks.length - projectNames.length} requisite ${taskText}`;
+            }
+        }
+        let resolveRenderIsDonePromise;
+        // Default renderIsDone that will be overridden if the TUI is used
+        let renderIsDone = new Promise((resolve) => (resolveRenderIsDonePromise = resolve));
+        const { lifeCycle: tsLifeCycle, printSummary } = (0, tui_summary_life_cycle_1.getTuiTerminalSummaryLifeCycle)({
+            projectNames,
+            tasks,
+            args: nxArgs,
+            overrides: overridesWithoutHidden,
+            initiatingProject,
+            resolveRenderIsDonePromise,
+        });
+        if (tasks.length === 0) {
+            renderIsDone = renderIsDone.then(() => {
+                // Revert the patched methods
+                process.stdout.write = originalStdoutWrite;
+                process.stderr.write = originalStderrWrite;
+                console.log = originalConsoleLog;
+                console.error = originalConsoleError;
+                printSummary();
+            });
+        }
+        const lifeCycles = [tsLifeCycle];
+        // Only run the TUI if there are tasks to run
+        if (tasks.length > 0) {
+            appLifeCycle = new AppLifeCycle(tasks, pinnedTasks, nxArgs ?? {}, nxJson.tui ?? {}, titleText);
+            lifeCycles.unshift(appLifeCycle);
+            /**
+             * Patch stdout.write and stderr.write methods to pass Nx Cloud client logs to the TUI via the lifecycle
+             */
+            const createPatchedLogWrite = (originalWrite) => {
+                // @ts-ignore
+                return (chunk, encoding, callback) => {
+                    // Check if the log came from the Nx Cloud client, otherwise invoke the original write method
+                    const stackTrace = new Error().stack;
+                    const isNxCloudLog = stackTrace.includes((0, node_path_1.join)(workspace_root_1.workspaceRoot, '.nx', 'cache', 'cloud'));
+                    if (isNxCloudLog) {
+                        interceptedNxCloudLogs.push(chunk);
+                        // Do not bother to store logs with only whitespace characters, they aren't relevant for the TUI
+                        const trimmedChunk = chunk.toString().trim();
+                        if (trimmedChunk.length) {
+                            // Remove ANSI escape codes, the TUI will control the formatting
+                            appLifeCycle?.__setCloudMessage((0, node_util_1.stripVTControlCharacters)(trimmedChunk));
+                        }
+                    }
+                    // Preserve original behavior around callback and return value, just in case
+                    if (callback) {
+                        callback();
+                    }
+                    return true;
+                };
+            };
+            const createPatchedConsoleMethod = (originalMethod) => {
+                return (...args) => {
+                    // Check if the log came from the Nx Cloud client, otherwise invoke the original write method
+                    const stackTrace = new Error().stack;
+                    const isNxCloudLog = stackTrace.includes((0, node_path_1.join)(workspace_root_1.workspaceRoot, '.nx', 'cache', 'cloud'));
+                    if (!isNxCloudLog) {
+                        return originalMethod(...args);
+                    }
+                    // No-op the Nx Cloud client logs
+                };
+            };
+            process.stdout.write = createPatchedLogWrite(originalStdoutWrite);
+            process.stderr.write = createPatchedLogWrite(originalStderrWrite);
+            // The cloud client calls console.log when NX_VERBOSE_LOGGING is set to true
+            console.log = createPatchedConsoleMethod(originalConsoleLog);
+            console.error = createPatchedConsoleMethod(originalConsoleError);
+            renderIsDone = new Promise((resolve) => {
+                appLifeCycle.__init(() => {
+                    resolve();
+                });
+            })
+                .then(() => {
+                restoreTerminal();
+            })
+                .finally(() => {
+                // Revert the patched methods
+                process.stdout.write = originalStdoutWrite;
+                process.stderr.write = originalStderrWrite;
+                console.log = originalConsoleLog;
+                console.error = originalConsoleError;
+                printSummary();
+                // Print the intercepted Nx Cloud logs
+                for (const log of interceptedNxCloudLogs) {
+                    const logString = log.toString().trimStart();
+                    process.stdout.write(logString);
+                    if (logString) {
+                        process.stdout.write('\n');
+                    }
+                }
+            });
+        }
+        return {
+            lifeCycle: new life_cycle_1.CompositeLifeCycle(lifeCycles),
+            renderIsDone,
+        };
+    }
     const { runnerOptions } = getRunner(nxArgs, nxJson);
     const isRunOne = initiatingProject != null;
     const useDynamicOutput = shouldUseDynamicLifeCycle(tasks, runnerOptions, nxArgs.outputStyle);
-    const overridesWithoutHidden = { ...overrides };
-    delete overridesWithoutHidden['__overrides_unparsed__'];
     if (isRunOne) {
         if (useDynamicOutput) {
             return await (0, dynamic_run_one_terminal_output_life_cycle_1.createRunOneDynamicOutputRenderer)({
@@ -129,7 +287,7 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
     const projectNames = projectsToRun.map((t) => t.name);
     const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
     const tasks = Object.values(taskGraph.tasks);
-    const { lifeCycle, renderIsDone } = await getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides);
+    const { lifeCycle, renderIsDone } = await getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides);
     const taskResults = await invokeTasksRunner({
         tasks,
         projectGraph,
@@ -141,12 +299,12 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
         initiatingProject,
     });
     await renderIsDone;
-    await (0, powerpack_1.printPowerpackLicense)();
+    await (0, nx_key_1.printNxKey)();
     return taskResults;
 }
 async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions) {
     let taskGraph = createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies ?? {}, projectNames, nxArgs, overrides, extraOptions);
-    if (nxArgs.skipSync) {
+    if (nxArgs.skipSync || (0, is_ci_1.isCI)()) {
         return { projectGraph, taskGraph };
     }
     // collect unique syncGenerators from the tasks
@@ -166,9 +324,8 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
     const outOfSyncTitle = 'The workspace is out of sync';
     const resultBodyLines = (0, sync_generators_1.getSyncGeneratorSuccessResultsMessageLines)(results);
     const fixMessage = 'Make sure to run `nx sync` to apply the identified changes or set `sync.applyChanges` to `true` in your `nx.json` to apply them automatically when running tasks in interactive environments.';
-    const willErrorOnCiMessage = 'This will result in an error in CI.';
-    if ((0, is_ci_1.isCI)() || !process.stdout.isTTY) {
-        // If the user is running in CI or is running in a non-TTY environment we
+    if (!process.stdout.isTTY) {
+        // If the user is running a non-TTY environment we
         // throw an error to stop the execution of the tasks.
         if (areAllResultsFailures) {
             output_1.output.error({
@@ -216,7 +373,6 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
                 ...resultBodyLines,
                 '',
                 'Your workspace is set to not apply the identified changes automatically (`sync.applyChanges` is set to `false` in your `nx.json`).',
-                willErrorOnCiMessage,
                 fixMessage,
             ],
         });
@@ -235,10 +391,12 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
         title: outOfSyncTitle,
         bodyLines: [
             ...resultBodyLines,
-            '',
-            nxJson.sync?.applyChanges === true
-                ? 'Proceeding to sync the identified changes automatically (`sync.applyChanges` is set to `true` in your `nx.json`).'
-                : willErrorOnCiMessage,
+            ...(nxJson.sync?.applyChanges === true
+                ? [
+                    '',
+                    'Proceeding to sync the identified changes automatically (`sync.applyChanges` is set to `true` in your `nx.json`).',
+                ]
+                : []),
         ],
     });
     const applyChanges = nxJson.sync?.applyChanges === true ||
@@ -535,10 +693,9 @@ function getRunner(nxArgs, nxJson) {
     try {
         if (isCustomRunnerPath(modulePath)) {
             output_1.output.warn({
-                title: `Custom task runners will no longer be supported in Nx 21.`,
+                title: `Custom task runners will be replaced by a new API starting with Nx 21.`,
                 bodyLines: [
-                    `Use Nx Cloud or the Nx Powerpack caches instead.`,
-                    `For more information, see https://nx.dev/nx-enterprise/powerpack/custom-caching`,
+                    `For more information, see https://nx.dev/deprecated/custom-tasks-runner`,
                 ],
             });
         }
@@ -557,7 +714,7 @@ function getTasksRunnerPath(runner, nxJson) {
     let modulePath = nxJson.tasksRunnerOptions?.[runner]?.runner;
     if (modulePath) {
         if ((0, fileutils_1.isRelativePath)(modulePath)) {
-            return (0, path_1.join)(workspace_root_1.workspaceRoot, modulePath);
+            return (0, node_path_1.join)(workspace_root_1.workspaceRoot, modulePath);
         }
         return modulePath;
     }

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;
+}