nx 21.0.0-beta.1 → 21.0.0-beta.10

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,32 +68,11 @@ 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 = [];
@@ -118,11 +116,15 @@ class PseudoTtyProcess {
             }
         }
     }
+    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

@@ -17,7 +17,8 @@ export declare function runCommandForTasks(projectsToRun: ProjectGraphProjectNod
     excludeTaskDependencies: boolean;
     loadDotEnvFiles: boolean;
 }): Promise<TaskResults>;
-export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, }: {
+export declare function setEnvVarsBasedOnArgs(nxArgs: NxArgs, loadDotEnvFiles: boolean): void;
+export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, }: {
     tasks: Task[];
     projectGraph: ProjectGraph;
     taskGraph: TaskGraph;
@@ -26,9 +27,11 @@ export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, life
     nxArgs: NxArgs;
     loadDotEnvFiles: boolean;
     initiatingProject: string | null;
+    initiatingTasks: Task[];
 }): 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

@@ -2,26 +2,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommand = runCommand;
 exports.runCommandForTasks = runCommandForTasks;
+exports.setEnvVarsBasedOnArgs = setEnvVarsBasedOnArgs;
 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");
@@ -29,21 +34,180 @@ const static_run_many_terminal_output_life_cycle_1 = require("./life-cycles/stat
 const static_run_one_terminal_output_life_cycle_1 = require("./life-cycles/static-run-one-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_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, initiatingTasks, 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 = initiatingTasks[0].id;
+            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,
+            initiatingTasks,
+            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;
+            });
+        }
+        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;
+                // 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),
+            restoreTerminal: () => {
+                process.stdout.write = originalStdoutWrite;
+                process.stderr.write = originalStderrWrite;
+                console.log = originalConsoleLog;
+                console.error = originalConsoleError;
+                restoreTerminal();
+            },
+            printSummary,
+            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)({
@@ -127,26 +291,41 @@ async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs
 }
 async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
     const projectNames = projectsToRun.map((t) => t.name);
+    const projectNameSet = new Set(projectNames);
     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 taskResults = await invokeTasksRunner({
-        tasks,
-        projectGraph,
-        taskGraph,
-        lifeCycle,
-        nxJson,
-        nxArgs,
-        loadDotEnvFiles: extraOptions.loadDotEnvFiles,
-        initiatingProject,
-    });
-    await renderIsDone;
-    await (0, powerpack_1.printPowerpackLicense)();
-    return taskResults;
+    const initiatingTasks = tasks.filter((t) => projectNameSet.has(t.target.project) &&
+        nxArgs.targets.includes(t.target.target));
+    const { lifeCycle, renderIsDone, printSummary, restoreTerminal } = await getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides);
+    try {
+        const taskResults = await invokeTasksRunner({
+            tasks,
+            projectGraph,
+            taskGraph,
+            lifeCycle,
+            nxJson,
+            nxArgs,
+            loadDotEnvFiles: extraOptions.loadDotEnvFiles,
+            initiatingProject,
+            initiatingTasks,
+        });
+        await renderIsDone;
+        if (printSummary) {
+            printSummary();
+        }
+        await (0, nx_key_1.printNxKey)();
+        return taskResults;
+    }
+    catch (e) {
+        if (restoreTerminal) {
+            restoreTerminal();
+        }
+        throw e;
+    }
 }
 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 +345,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 +394,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 +412,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 ||
@@ -377,7 +556,7 @@ function setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles) {
         process.env.NX_LOAD_DOT_ENV_FILES = 'true';
     }
 }
-async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, }) {
+async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, }) {
     setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles);
     // this needs to be done before we start to run the tasks
     const taskDetails = (0, hash_task_1.getTaskDetails)();
@@ -397,6 +576,7 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
         lifeCycle: compositedLifeCycle,
     }, {
         initiatingProject: nxArgs.outputStyle === 'compact' ? null : initiatingProject,
+        initiatingTasks,
         projectGraph,
         nxJson,
         nxArgs,
@@ -467,10 +647,9 @@ function constructLifeCycles(lifeCycle) {
     if (process.env.NX_PROFILE) {
         lifeCycles.push(new task_profiling_life_cycle_1.TaskProfilingLifeCycle(process.env.NX_PROFILE));
     }
-    if (!(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
-        lifeCycles.push(process.env.NX_DISABLE_DB !== 'true' && !native_1.IS_WASM
-            ? new task_history_life_cycle_1.TaskHistoryLifeCycle()
-            : new task_history_life_cycle_old_1.LegacyTaskHistoryLifeCycle());
+    const historyLifeCycle = (0, task_history_life_cycle_1.getTasksHistoryLifeCycle)();
+    if (historyLifeCycle) {
+        lifeCycles.push(historyLifeCycle);
     }
     return lifeCycles;
 }
@@ -535,10 +714,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 +735,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/node-child-process.js

@@ -153,18 +153,11 @@ class NodeChildProcessWithDirectOutput {
         this.exitCallbacks.push(cb);
     }
     async getResults() {
-        const terminalOutput = this.getTerminalOutput();
-        if (this.exited) {
-            return Promise.resolve({
-                code: this.exitCode,
-                terminalOutput,
-            });
+        if (!this.exited) {
+            await this.waitForExit();
         }
-        await this.waitForExit();
-        return Promise.resolve({
-            code: this.exitCode,
-            terminalOutput,
-        });
+        const terminalOutput = this.getTerminalOutput();
+        return { code: this.exitCode, terminalOutput };
     }
     waitForExit() {
         return new Promise((res) => {

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

@@ -1,3 +1,4 @@
+import type { Serializable } from 'child_process';
 export declare abstract class RunningTask {
     abstract getResults(): Promise<{
         code: number;
@@ -5,4 +6,6 @@ export declare abstract class RunningTask {
     }>;
     abstract onExit(cb: (code: number) => void): void;
     abstract kill(signal?: NodeJS.Signals | number): Promise<void> | void;
+    abstract onOutput?(cb: (output: string) => void): void;
+    abstract send?(message: Serializable): void;
 }

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

@@ -0,0 +1,14 @@
+import { RunningTask } from './running-task';
+import { RunningTasksService } from '../../native';
+export declare class SharedRunningTask implements RunningTask {
+    private runningTasksService;
+    private exitCallbacks;
+    constructor(runningTasksService: RunningTasksService, taskId: string);
+    getResults(): Promise<{
+        code: number;
+        terminalOutput: string;
+    }>;
+    kill(): void;
+    onExit(cb: (code: number) => void): void;
+    private waitForTaskToFinish;
+}

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedRunningTask = void 0;
+class SharedRunningTask {
+    constructor(runningTasksService, taskId) {
+        this.runningTasksService = runningTasksService;
+        this.exitCallbacks = [];
+        this.waitForTaskToFinish(taskId).then(() => {
+            // notify exit callbacks
+            this.exitCallbacks.forEach((cb) => cb(0));
+        });
+    }
+    async getResults() {
+        throw new Error('Results cannot be retrieved from a shared task');
+    }
+    kill() {
+        this.exitCallbacks.forEach((cb) => cb(0));
+    }
+    onExit(cb) {
+        this.exitCallbacks.push(cb);
+    }
+    async waitForTaskToFinish(taskId) {
+        console.log(`Waiting for ${taskId} in another nx process`);
+        // wait for the running task to finish
+        do {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        } while (this.runningTasksService.getRunningTasks([taskId]).length);
+    }
+}
+exports.SharedRunningTask = SharedRunningTask;

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',
     };
 }
 /**