nx 21.0.0-beta.1 → 21.0.0-beta.2

package/src/tasks-runner/create-task-graph.js

@@ -5,6 +5,7 @@ exports.createTaskGraph = createTaskGraph;
 exports.mapTargetDefaultsToDependencies = mapTargetDefaultsToDependencies;
 exports.filterDummyTasks = filterDummyTasks;
 exports.getNonDummyDeps = getNonDummyDeps;
+exports.createTaskId = createTaskId;
 const utils_1 = require("./utils");
 const project_graph_utils_1 = require("../utils/project-graph-utils");
 const output_1 = require("../utils/output");
@@ -33,7 +34,7 @@ class ProcessTasks {
                 const project = this.projectGraph.nodes[projectName];
                 if (targets.length === 1 || project.data.targets[target]) {
                     const resolvedConfiguration = this.resolveConfiguration(project, target, configuration);
-                    const id = this.getId(projectName, target, resolvedConfiguration);
+                    const id = createTaskId(projectName, target, resolvedConfiguration);
                     const task = this.createTask(id, project, target, resolvedConfiguration, overrides);
                     this.tasks[task.id] = task;
                     this.dependencies[task.id] = [];
@@ -120,7 +121,7 @@ class ProcessTasks {
         const selfProject = this.projectGraph.nodes[projectName];
         if ((0, project_graph_utils_1.projectHasTarget)(selfProject, dependencyConfig.target)) {
             const resolvedConfiguration = this.resolveConfiguration(selfProject, dependencyConfig.target, configuration);
-            const selfTaskId = this.getId(selfProject.name, dependencyConfig.target, resolvedConfiguration);
+            const selfTaskId = createTaskId(selfProject.name, dependencyConfig.target, resolvedConfiguration);
             if (!this.tasks[selfTaskId]) {
                 const newTask = this.createTask(selfTaskId, selfProject, dependencyConfig.target, resolvedConfiguration, taskOverrides);
                 this.tasks[selfTaskId] = newTask;
@@ -149,7 +150,7 @@ class ProcessTasks {
                 continue;
             if ((0, project_graph_utils_1.projectHasTarget)(depProject, dependencyConfig.target)) {
                 const resolvedConfiguration = this.resolveConfiguration(depProject, dependencyConfig.target, configuration);
-                const depTargetId = this.getId(depProject.name, dependencyConfig.target, resolvedConfiguration);
+                const depTargetId = createTaskId(depProject.name, dependencyConfig.target, resolvedConfiguration);
                 const depTargetConfiguration = this.projectGraph.nodes[depProject.name].data.targets[dependencyConfig.target];
                 if (task.id !== depTargetId) {
                     if (depTargetConfiguration.continuous) {
@@ -169,7 +170,7 @@ class ProcessTasks {
             }
             else {
                 // Create a dummy task for task.target.project... which simulates if depProject had dependencyConfig.target
-                const dummyId = this.getId(depProject.name, task.target.project +
+                const dummyId = createTaskId(depProject.name, task.target.project +
                     '__' +
                     dependencyConfig.target +
                     DUMMY_TASK_TARGET, undefined);
@@ -218,13 +219,6 @@ class ProcessTasks {
             ? configuration
             : defaultConfiguration;
     }
-    getId(project, target, configuration) {
-        let id = `${project}:${target}`;
-        if (configuration) {
-            id += `:${configuration}`;
-        }
-        return id;
-    }
 }
 exports.ProcessTasks = ProcessTasks;
 function createTaskGraph(projectGraph, extraTargetDependencies, projectNames, targets, configuration, overrides, excludeTaskDependencies = false) {
@@ -299,3 +293,10 @@ function getNonDummyDeps(currentTask, dependencies, cycles, seen = new Set()) {
         return [currentTask];
     }
 }
+function createTaskId(project, target, configuration) {
+    let id = `${project}:${target}`;
+    if (configuration) {
+        id += `:${configuration}`;
+    }
+    return id;
+}

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

@@ -54,26 +54,17 @@ class RemoteCacheV2 {
 }
 exports.RemoteCacheV2 = RemoteCacheV2;
 const defaultTasksRunner = async (tasks, options, context) => {
-    if (options['parallel'] === 'false' ||
-        options['parallel'] === false) {
-        options['parallel'] = 1;
-    }
-    else if (options['parallel'] === 'true' ||
-        options['parallel'] === true ||
-        options['parallel'] === undefined ||
-        options['parallel'] === '') {
-        options['parallel'] = Number(options['maxParallel'] || 3);
-    }
-    await options.lifeCycle.startCommand();
+    const threadCount = (0, task_orchestrator_1.getThreadCount)(options, context.taskGraph);
+    await options.lifeCycle.startCommand(threadCount);
     try {
-        return await runAllTasks(tasks, options, context);
+        return await runAllTasks(options, context);
     }
     finally {
         await options.lifeCycle.endCommand();
     }
 };
 exports.defaultTasksRunner = defaultTasksRunner;
-async function runAllTasks(tasks, options, context) {
+async function runAllTasks(options, context) {
     const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.projectGraph, context.taskGraph, context.nxJson, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.outputStyle);
     return orchestrator.run();
 }

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

@@ -2,17 +2,19 @@ import { DefaultTasksRunnerOptions } from './default-tasks-runner';
 import { Batch } from './tasks-schedule';
 import { Task, TaskGraph } from '../config/task-graph';
 import { PseudoTtyProcess } from './pseudo-terminal';
+import { ProjectGraph } from '../config/project-graph';
 import { BatchProcess } from './running-tasks/batch-process';
 import { RunningTask } from './running-tasks/running-task';
 export declare class ForkedProcessTaskRunner {
     private readonly options;
+    private readonly tuiEnabled;
     cliPath: string;
     private readonly verbose;
     private processes;
-    private pseudoTerminal;
-    constructor(options: DefaultTasksRunnerOptions);
+    private pseudoTerminals;
+    constructor(options: DefaultTasksRunnerOptions, tuiEnabled: boolean);
     init(): Promise<void>;
-    forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }: Batch, fullTaskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<BatchProcess>;
+    forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }: Batch, projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<BatchProcess>;
     forkProcessLegacy(task: Task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }: {
         temporaryOutputPath: string;
         streamOutput: boolean;
@@ -28,6 +30,7 @@ export declare class ForkedProcessTaskRunner {
         env: NodeJS.ProcessEnv;
         disablePseudoTerminal: boolean;
     }): Promise<RunningTask | PseudoTtyProcess>;
+    private createPseudoTerminal;
     private forkProcessWithPseudoTerminal;
     private forkProcessWithPrefixAndNotTTY;
     private forkProcessDirectOutputCapture;

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

@@ -12,26 +12,23 @@ 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 native_1 = require("../native");
 const forkScript = (0, path_1.join)(__dirname, './fork.js');
 const workerPath = (0, path_1.join)(__dirname, './batch/run-batch.js');
 class ForkedProcessTaskRunner {
-    constructor(options) {
+    constructor(options, tuiEnabled) {
         this.options = options;
+        this.tuiEnabled = tuiEnabled;
         this.cliPath = (0, utils_1.getCliPath)();
         this.verbose = process.env.NX_VERBOSE_LOGGING === 'true';
         this.processes = new Set();
-        this.pseudoTerminal = pseudo_terminal_1.PseudoTerminal.isSupported()
-            ? (0, pseudo_terminal_1.getPseudoTerminal)()
-            : null;
+        this.pseudoTerminals = new Set();
     }
     async init() {
-        if (this.pseudoTerminal) {
-            await this.pseudoTerminal.init();
-        }
         this.setupProcessEventListeners();
     }
     // TODO: vsavkin delegate terminal output printing
-    async forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }, fullTaskGraph, env) {
+    async forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }, projectGraph, 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)}`);
@@ -53,6 +50,7 @@ class ForkedProcessTaskRunner {
         cp.send({
             type: batch_messages_1.BatchMessageType.RunTasks,
             executorName,
+            projectGraph,
             batchTaskGraph,
             fullTaskGraph,
         });
@@ -74,14 +72,15 @@ class ForkedProcessTaskRunner {
             });
     }
     async forkProcess(task, { temporaryOutputPath, streamOutput, taskGraph, env, disablePseudoTerminal, }) {
-        const shouldPrefix = streamOutput && process.env.NX_PREFIX_OUTPUT === 'true';
+        const shouldPrefix = streamOutput &&
+            process.env.NX_PREFIX_OUTPUT === 'true' &&
+            !this.tuiEnabled;
         // streamOutput would be false if we are running multiple targets
         // there's no point in running the commands in a pty if we are not streaming the output
-        if (!this.pseudoTerminal ||
-            disablePseudoTerminal ||
-            !streamOutput ||
-            shouldPrefix) {
-            return this.forkProcessWithPrefixAndNotTTY(task, {
+        if (pseudo_terminal_1.PseudoTerminal.isSupported() &&
+            !disablePseudoTerminal &&
+            (this.tuiEnabled || (streamOutput && !shouldPrefix))) {
+            return this.forkProcessWithPseudoTerminal(task, {
                 temporaryOutputPath,
                 streamOutput,
                 taskGraph,
@@ -89,7 +88,7 @@ class ForkedProcessTaskRunner {
             });
         }
         else {
-            return this.forkProcessWithPseudoTerminal(task, {
+            return this.forkProcessWithPrefixAndNotTTY(task, {
                 temporaryOutputPath,
                 streamOutput,
                 taskGraph,
@@ -97,13 +96,19 @@ class ForkedProcessTaskRunner {
             });
         }
     }
+    async createPseudoTerminal() {
+        const terminal = new pseudo_terminal_1.PseudoTerminal(new native_1.RustPseudoTerminal());
+        await terminal.init();
+        terminal.onMessageFromChildren((message) => {
+            process.send(message);
+        });
+        return terminal;
+    }
     async forkProcessWithPseudoTerminal(task, { temporaryOutputPath, streamOutput, taskGraph, env, }) {
-        const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-        if (streamOutput) {
-            output_1.output.logCommand(args.join(' '));
-        }
         const childId = task.id;
-        const p = await this.pseudoTerminal.fork(childId, forkScript, {
+        const pseudoTerminal = await this.createPseudoTerminal();
+        this.pseudoTerminals.add(pseudoTerminal);
+        const p = await pseudoTerminal.fork(childId, forkScript, {
             cwd: process.cwd(),
             execArgv: process.execArgv,
             jsEnv: env,
@@ -124,6 +129,7 @@ class ForkedProcessTaskRunner {
             if (code > 128) {
                 process.exit(code);
             }
+            this.pseudoTerminals.delete(pseudoTerminal);
             this.processes.delete(p);
             this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
         });
@@ -215,16 +221,11 @@ class ForkedProcessTaskRunner {
         (0, fs_1.writeFileSync)(outputPath, content);
     }
     setupProcessEventListeners() {
-        if (this.pseudoTerminal) {
-            this.pseudoTerminal.onMessageFromChildren((message) => {
-                process.send(message);
-            });
-        }
         // When the nx process gets a message, it will be sent into the task's process
         process.on('message', (message) => {
-            if (this.pseudoTerminal) {
-                this.pseudoTerminal.sendMessageToChildren(message);
-            }
+            this.pseudoTerminals.forEach((p) => {
+                p.sendMessageToChildren(message);
+            });
             this.processes.forEach((p) => {
                 if ('send' in p) {
                     p.send(message);

package/src/tasks-runner/init-tasks-runner.d.ts

@@ -1,6 +1,13 @@
 import { NxArgs } from '../utils/command-line-utils';
 import { Task, TaskGraph } from '../config/task-graph';
-import { TaskResult } from './life-cycle';
+import { LifeCycle, TaskResult } from './life-cycle';
+import type { ProjectGraph } from '../config/project-graph';
+import type { NxJsonConfiguration } from '../config/nx-json';
+import { RunningTask } from './running-tasks/running-task';
+/**
+ * This function is deprecated. Do not use this
+ * @deprecated This function is deprecated. Do not use this
+ */
 export declare function initTasksRunner(nxArgs: NxArgs): Promise<{
     invoke: (opts: {
         tasks: Task[];
@@ -11,3 +18,10 @@ export declare function initTasksRunner(nxArgs: NxArgs): Promise<{
         taskResults: Record<string, TaskResult>;
     }>;
 }>;
+export declare function runDiscreteTasks(tasks: Task[], projectGraph: ProjectGraph, taskGraphForHashing: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Promise<{
+    task: Task;
+    code: number;
+    status: import("./tasks-runner").TaskStatus;
+    terminalOutput?: string;
+}>[]>;
+export declare function runContinuousTasks(tasks: Task[], projectGraph: ProjectGraph, taskGraphForHashing: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Record<string, Promise<RunningTask>>>;

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

@@ -1,17 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initTasksRunner = initTasksRunner;
-const configuration_1 = require("../config/configuration");
+exports.runDiscreteTasks = runDiscreteTasks;
+exports.runContinuousTasks = runContinuousTasks;
+const nx_json_1 = require("../config/nx-json");
 const project_graph_1 = require("../project-graph/project-graph");
 const run_command_1 = require("./run-command");
 const invoke_runner_terminal_output_life_cycle_1 = require("./life-cycles/invoke-runner-terminal-output-life-cycle");
 const perf_hooks_1 = require("perf_hooks");
 const utils_1 = require("./utils");
 const dotenv_1 = require("../utils/dotenv");
+const life_cycle_1 = require("./life-cycle");
+const task_orchestrator_1 = require("./task-orchestrator");
+const create_task_hasher_1 = require("../hasher/create-task-hasher");
+const client_1 = require("../daemon/client/client");
+const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
+/**
+ * This function is deprecated. Do not use this
+ * @deprecated This function is deprecated. Do not use this
+ */
 async function initTasksRunner(nxArgs) {
     perf_hooks_1.performance.mark('init-local');
     (0, dotenv_1.loadRootEnvFiles)();
-    const nxJson = (0, configuration_1.readNxJson)();
+    const nxJson = (0, nx_json_1.readNxJson)();
     if (nxArgs.verbose) {
         process.env.NX_VERBOSE_LOGGING = 'true';
     }
@@ -61,3 +72,45 @@ async function initTasksRunner(nxArgs) {
         },
     };
 }
+async function createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
+    (0, dotenv_1.loadRootEnvFiles)();
+    const invokeRunnerTerminalLifecycle = new invoke_runner_terminal_output_life_cycle_1.InvokeRunnerTerminalOutputLifeCycle(tasks);
+    const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
+    const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
+        ...(0, run_command_1.constructLifeCycles)(invokeRunnerTerminalLifecycle),
+        taskResultsLifecycle,
+        lifeCycle,
+    ]);
+    const { runnerOptions: options } = (0, run_command_1.getRunner)({}, nxJson);
+    let hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, options);
+    const taskGraph = {
+        roots: tasks.map((task) => task.id),
+        tasks: tasks.reduce((acc, task) => {
+            acc[task.id] = task;
+            return acc;
+        }, {}),
+        dependencies: tasks.reduce((acc, task) => {
+            acc[task.id] = [];
+            return acc;
+        }, {}),
+        continuousDependencies: tasks.reduce((acc, task) => {
+            acc[task.id] = [];
+            return acc;
+        }, {}),
+    };
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, projectGraph, taskGraph, nxJson, { ...options, parallel: tasks.length, lifeCycle: compositedLifeCycle }, false, client_1.daemonClient, undefined, taskGraphForHashing);
+    await orchestrator.init();
+    await Promise.all(tasks.map((task) => orchestrator.processTask(task.id)));
+    return orchestrator;
+}
+async function runDiscreteTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle);
+    return tasks.map((task, index) => orchestrator.applyFromCacheOrRunTask(true, task, index));
+}
+async function runContinuousTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle);
+    return tasks.reduce((current, task, index) => {
+        current[task.id] = orchestrator.startContinuousTask(task, index);
+        return current;
+    }, {});
+}

package/src/tasks-runner/is-tui-enabled.d.ts

@@ -0,0 +1,2 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+export declare function isTuiEnabled(nxJson?: NxJsonConfiguration): any;

package/src/tasks-runner/is-tui-enabled.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTuiEnabled = isTuiEnabled;
+const devkit_internals_1 = require("../devkit-internals");
+let tuiEnabled = undefined;
+function isTuiEnabled(nxJson) {
+    if (tuiEnabled !== undefined) {
+        return tuiEnabled;
+    }
+    // If the current terminal/environment is not capable of displaying the TUI, we don't run it
+    const isWindows = process.platform === 'win32';
+    const isCapable = process.stderr.isTTY && isUnicodeSupported();
+    // Windows is not working well right now, temporarily disable it on Windows even if it has been specified as enabled
+    // TODO(@JamesHenry): Remove this check once Windows issues are fixed.
+    if (!isCapable || isWindows) {
+        tuiEnabled = false;
+        process.env.NX_TUI = 'false';
+        return tuiEnabled;
+    }
+    // The environment variable takes precedence over the nx.json config
+    if (typeof process.env.NX_TUI === 'string') {
+        tuiEnabled = process.env.NX_TUI === 'true' ? true : false;
+        return tuiEnabled;
+    }
+    // Only read from disk if nx.json config is not already provided (and we have not been able to determine tuiEnabled based on the above checks)
+    if (!nxJson) {
+        nxJson = (0, devkit_internals_1.readNxJsonFromDisk)();
+    }
+    // Respect user config
+    if (typeof nxJson.tui?.enabled === 'boolean') {
+        tuiEnabled = Boolean(nxJson.tui?.enabled);
+    }
+    else {
+        // Default to enabling the TUI if the system is capable of displaying it
+        tuiEnabled = true;
+    }
+    // Also set the environment variable for consistency and ease of checking on the rust side, for example
+    process.env.NX_TUI = tuiEnabled.toString();
+    return tuiEnabled;
+}
+// Credit to https://github.com/sindresorhus/is-unicode-supported/blob/e0373335038856c63034c8eef6ac43ee3827a601/index.js
+function isUnicodeSupported() {
+    const { env } = process;
+    const { TERM, TERM_PROGRAM } = env;
+    if (process.platform !== 'win32') {
+        return TERM !== 'linux'; // Linux console (kernel)
+    }
+    return (Boolean(env.WT_SESSION) || // Windows Terminal
+        Boolean(env.TERMINUS_SUBLIME) || // Terminus (<0.2.27)
+        env.ConEmuTask === '{cmd::Cmder}' || // ConEmu and cmder
+        TERM_PROGRAM === 'Terminus-Sublime' ||
+        TERM_PROGRAM === 'vscode' ||
+        TERM === 'xterm-256color' ||
+        TERM === 'alacritty' ||
+        TERM === 'rxvt-unicode' ||
+        TERM === 'rxvt-unicode-256color' ||
+        env.TERMINAL_EMULATOR === 'JetBrains-JediTerm');
+}

package/src/tasks-runner/life-cycle.d.ts

@@ -1,5 +1,6 @@
-import { TaskStatus } from './tasks-runner';
 import { Task } from '../config/task-graph';
+import { ExternalObject, TaskStatus as NativeTaskStatus } from '../native';
+import { TaskStatus } from './tasks-runner';
 /**
  * The result of a completed {@link Task}
  */
@@ -17,7 +18,7 @@ export interface TaskMetadata {
     groupId: number;
 }
 export interface LifeCycle {
-    startCommand?(): void | Promise<void>;
+    startCommand?(parallel?: number): void | Promise<void>;
     endCommand?(): void | Promise<void>;
     scheduleTask?(task: Task): void | Promise<void>;
     /**
@@ -35,11 +36,14 @@ export interface LifeCycle {
     startTasks?(task: Task[], metadata: TaskMetadata): void | Promise<void>;
     endTasks?(taskResults: TaskResult[], metadata: TaskMetadata): void | Promise<void>;
     printTaskTerminalOutput?(task: Task, status: TaskStatus, output: string): void;
+    registerRunningTask?(taskId: string, parserAndWriter: ExternalObject<[any, any]>): Promise<void>;
+    setTaskStatus?(taskId: string, status: NativeTaskStatus): void;
+    registerForcedShutdownCallback?(callback: () => void): void;
 }
 export declare class CompositeLifeCycle implements LifeCycle {
     private readonly lifeCycles;
     constructor(lifeCycles: LifeCycle[]);
-    startCommand(): Promise<void>;
+    startCommand(parallel?: number): Promise<void>;
     endCommand(): Promise<void>;
     scheduleTask(task: Task): Promise<void>;
     startTask(task: Task): void;
@@ -47,4 +51,7 @@ export declare class CompositeLifeCycle implements LifeCycle {
     startTasks(tasks: Task[], metadata: TaskMetadata): Promise<void>;
     endTasks(taskResults: TaskResult[], metadata: TaskMetadata): Promise<void>;
     printTaskTerminalOutput(task: Task, status: TaskStatus, output: string): void;
+    registerRunningTask(taskId: string, parserAndWriter: ExternalObject<[any, any]>): Promise<void>;
+    setTaskStatus(taskId: string, status: NativeTaskStatus): void;
+    registerForcedShutdownCallback(callback: () => void): void;
 }

package/src/tasks-runner/life-cycle.js

@@ -5,10 +5,10 @@ class CompositeLifeCycle {
     constructor(lifeCycles) {
         this.lifeCycles = lifeCycles;
     }
-    async startCommand() {
+    async startCommand(parallel) {
         for (let l of this.lifeCycles) {
             if (l.startCommand) {
-                await l.startCommand();
+                await l.startCommand(parallel);
             }
         }
     }
@@ -67,5 +67,26 @@ class CompositeLifeCycle {
             }
         }
     }
+    async registerRunningTask(taskId, parserAndWriter) {
+        for (let l of this.lifeCycles) {
+            if (l.registerRunningTask) {
+                await l.registerRunningTask(taskId, parserAndWriter);
+            }
+        }
+    }
+    setTaskStatus(taskId, status) {
+        for (let l of this.lifeCycles) {
+            if (l.setTaskStatus) {
+                l.setTaskStatus(taskId, status);
+            }
+        }
+    }
+    registerForcedShutdownCallback(callback) {
+        for (let l of this.lifeCycles) {
+            if (l.registerForcedShutdownCallback) {
+                l.registerForcedShutdownCallback(callback);
+            }
+        }
+    }
 }
 exports.CompositeLifeCycle = CompositeLifeCycle;

package/src/tasks-runner/life-cycles/task-history-life-cycle-old.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LegacyTaskHistoryLifeCycle = void 0;
-const serialize_target_1 = require("../../utils/serialize-target");
-const output_1 = require("../../utils/output");
 const legacy_task_history_1 = require("../../utils/legacy-task-history");
+const output_1 = require("../../utils/output");
+const serialize_target_1 = require("../../utils/serialize-target");
+const is_tui_enabled_1 = require("../is-tui-enabled");
 class LegacyTaskHistoryLifeCycle {
     constructor() {
         this.startTimings = {};
@@ -38,6 +39,10 @@ class LegacyTaskHistoryLifeCycle {
                 flakyTasks.push((0, serialize_target_1.serializeTarget)(history[hash][0].project, history[hash][0].target, history[hash][0].configuration));
             }
         }
+        // Do not directly print output when using the TUI
+        if ((0, is_tui_enabled_1.isTuiEnabled)()) {
+            return;
+        }
         if (flakyTasks.length > 0) {
             output_1.output.warn({
                 title: `Nx detected ${flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,

package/src/tasks-runner/life-cycles/task-history-life-cycle.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskHistoryLifeCycle = void 0;
-const serialize_target_1 = require("../../utils/serialize-target");
 const output_1 = require("../../utils/output");
+const serialize_target_1 = require("../../utils/serialize-target");
 const task_history_1 = require("../../utils/task-history");
+const is_tui_enabled_1 = require("../is-tui-enabled");
 class TaskHistoryLifeCycle {
     constructor() {
         this.startTimings = {};
@@ -36,6 +37,10 @@ class TaskHistoryLifeCycle {
         }
         await this.taskHistory.recordTaskRuns(entries.map(([_, v]) => v));
         const flakyTasks = await this.taskHistory.getFlakyTasks(entries.map(([hash]) => hash));
+        // Do not directly print output when using the TUI
+        if ((0, is_tui_enabled_1.isTuiEnabled)()) {
+            return;
+        }
         if (flakyTasks.length > 0) {
             output_1.output.warn({
                 title: `Nx detected ${flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,

package/src/tasks-runner/life-cycles/tui-summary-life-cycle.d.ts

@@ -0,0 +1,17 @@
+import { Task } from '../../config/task-graph';
+import type { LifeCycle } from '../life-cycle';
+export declare function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides, initiatingProject, resolveRenderIsDonePromise, }: {
+    projectNames: string[];
+    tasks: Task[];
+    args: {
+        targets?: string[];
+        configuration?: string;
+        parallel?: number;
+    };
+    overrides: Record<string, unknown>;
+    initiatingProject: string;
+    resolveRenderIsDonePromise: (value: void) => void;
+}): {
+    lifeCycle: Partial<LifeCycle>;
+    printSummary: () => void;
+};