nx 21.0.0-canary.20250422-8619c1d → 21.0.0-canary.20250424-e23b25f

package/src/executors/run-commands/run-commands.impl.d.ts

@@ -1,5 +1,4 @@
 import { ExecutorContext } from '../../config/misc-interfaces';
-import { PseudoTtyProcess } from '../../tasks-runner/pseudo-terminal';
 import { ParallelRunningTasks, SeriallyRunningTasks } from './running-tasks';
 export declare const LARGE_BUFFER: number;
 export type Json = {
@@ -55,5 +54,5 @@ export default function (options: RunCommandsOptions, context: ExecutorContext):
     success: boolean;
     terminalOutput: string;
 }>;
-export declare function runCommands(options: RunCommandsOptions, context: ExecutorContext): Promise<PseudoTtyProcess | ParallelRunningTasks | SeriallyRunningTasks>;
+export declare function runCommands(options: RunCommandsOptions, context: ExecutorContext): Promise<import("../../tasks-runner/pseudo-terminal").PseudoTtyProcess | ParallelRunningTasks | SeriallyRunningTasks>;
 export declare function interpolateArgsIntoCommand(command: string, opts: Pick<NormalizedRunCommandsOptions, 'args' | 'parsedArgs' | '__unparsed__' | 'unknownOptions' | 'unparsedCommandArgs'>, forwardAllArgs: boolean): string;

package/src/executors/run-commands/run-commands.impl.js

@@ -57,7 +57,7 @@ async function runCommands(options, context) {
         const runningTask = isSingleCommandAndCanUsePseudoTerminal
             ? await (0, running_tasks_1.runSingleCommandWithPseudoTerminal)(normalized, context)
             : options.parallel
-                ? new running_tasks_1.ParallelRunningTasks(normalized, context, tuiEnabled)
+                ? new running_tasks_1.ParallelRunningTasks(normalized, context)
                 : new running_tasks_1.SeriallyRunningTasks(normalized, context, tuiEnabled);
         return runningTask;
     }

package/src/executors/run-commands/running-tasks.d.ts

@@ -4,16 +4,17 @@ import { PseudoTtyProcess } from '../../tasks-runner/pseudo-terminal';
 import { RunningTask } from '../../tasks-runner/running-tasks/running-task';
 import { NormalizedRunCommandsOptions } from './run-commands.impl';
 export declare class ParallelRunningTasks implements RunningTask {
-    private readonly tuiEnabled;
     private readonly childProcesses;
     private readyWhenStatus;
     private readonly streamOutput;
     private exitCallbacks;
-    constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext, tuiEnabled: boolean);
+    private outputCallbacks;
+    constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext);
     getResults(): Promise<{
         code: number;
         terminalOutput: string;
     }>;
+    onOutput(cb: (terminalOutput: string) => void): void;
     onExit(cb: (code: number, terminalOutput: string) => void): void;
     send(message: Serializable): void;
     kill(signal?: NodeJS.Signals | number): Promise<void>;
@@ -26,12 +27,14 @@ export declare class SeriallyRunningTasks implements RunningTask {
     private exitCallbacks;
     private code;
     private error;
+    private outputCallbacks;
     constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext, tuiEnabled: boolean);
     getResults(): Promise<{
         code: number;
         terminalOutput: string;
     }>;
     onExit(cb: (code: number, terminalOutput: string) => void): void;
+    onOutput(cb: (terminalOutput: string) => void): void;
     send(message: Serializable): void;
     kill(signal?: NodeJS.Signals | number): void | Promise<void>;
     private run;

package/src/executors/run-commands/running-tasks.js

@@ -12,9 +12,9 @@ const task_env_1 = require("../../tasks-runner/task-env");
 const exit_codes_1 = require("../../utils/exit-codes");
 const run_commands_impl_1 = require("./run-commands.impl");
 class ParallelRunningTasks {
-    constructor(options, context, tuiEnabled) {
-        this.tuiEnabled = tuiEnabled;
+    constructor(options, context) {
         this.exitCallbacks = [];
+        this.outputCallbacks = [];
         this.childProcesses = options.commands.map((commandConfig) => new RunningNodeProcess(commandConfig, options.color, calculateCwd(options.cwd, context), options.env ?? {}, options.readyWhenStatus, options.streamOutput, options.envFile));
         this.readyWhenStatus = options.readyWhenStatus;
         this.streamOutput = options.streamOutput;
@@ -27,6 +27,9 @@ class ParallelRunningTasks {
             });
         });
     }
+    onOutput(cb) {
+        this.outputCallbacks.push(cb);
+    }
     onExit(cb) {
         this.exitCallbacks.push(cb);
     }
@@ -48,6 +51,11 @@ class ParallelRunningTasks {
     async run() {
         if (this.readyWhenStatus.length) {
             let { childProcess, result: { code, terminalOutput }, } = await Promise.race(this.childProcesses.map((childProcess) => new Promise((res) => {
+                childProcess.onOutput((terminalOutput) => {
+                    for (const cb of this.outputCallbacks) {
+                        cb(terminalOutput);
+                    }
+                });
                 childProcess.onExit((code, terminalOutput) => {
                     res({
                         childProcess,
@@ -67,10 +75,18 @@ class ParallelRunningTasks {
             }
         }
         else {
-            const results = await Promise.all(this.childProcesses.map((childProcess) => childProcess.getResults().then((result) => ({
-                childProcess,
-                result,
-            }))));
+            const results = await Promise.all(this.childProcesses.map(async (childProcess) => {
+                childProcess.onOutput((terminalOutput) => {
+                    for (const cb of this.outputCallbacks) {
+                        cb(terminalOutput);
+                    }
+                });
+                const result = await childProcess.getResults();
+                return {
+                    childProcess,
+                    result,
+                };
+            }));
             let terminalOutput = results
                 .map((r) => r.result.terminalOutput)
                 .join('\r\n');
@@ -103,6 +119,7 @@ class SeriallyRunningTasks {
         this.currentProcess = null;
         this.exitCallbacks = [];
         this.code = 0;
+        this.outputCallbacks = [];
         this.run(options, context)
             .catch((e) => {
             this.error = e;
@@ -128,6 +145,9 @@ class SeriallyRunningTasks {
     onExit(cb) {
         this.exitCallbacks.push(cb);
     }
+    onOutput(cb) {
+        this.outputCallbacks.push(cb);
+    }
     send(message) {
         throw new Error('Not implemented');
     }
@@ -138,6 +158,11 @@ class SeriallyRunningTasks {
         for (const c of options.commands) {
             const childProcess = await this.createProcess(c, options.color, calculateCwd(options.cwd, context), options.processEnv ?? options.env ?? {}, options.usePty, options.streamOutput, options.tty, options.envFile);
             this.currentProcess = childProcess;
+            childProcess.onOutput((output) => {
+                for (const cb of this.outputCallbacks) {
+                    cb(output);
+                }
+            });
             let { code, terminalOutput } = await childProcess.getResults();
             this.terminalOutput += terminalOutput;
             this.code = code;
@@ -173,6 +198,7 @@ class RunningNodeProcess {
         this.readyWhenStatus = readyWhenStatus;
         this.terminalOutput = '';
         this.exitCallbacks = [];
+        this.outputCallbacks = [];
         env = processEnv(color, cwd, env, envFile);
         this.command = commandConfig.command;
         this.terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
@@ -194,6 +220,9 @@ class RunningNodeProcess {
             });
         });
     }
+    onOutput(cb) {
+        this.outputCallbacks.push(cb);
+    }
     onExit(cb) {
         this.exitCallbacks.push(cb);
     }
@@ -212,10 +241,16 @@ class RunningNodeProcess {
             });
         });
     }
+    triggerOutputListeners(output) {
+        for (const cb of this.outputCallbacks) {
+            cb(output);
+        }
+    }
     addListeners(commandConfig, streamOutput) {
         this.childProcess.stdout.on('data', (data) => {
             const output = addColorAndPrefix(data, commandConfig);
             this.terminalOutput += output;
+            this.triggerOutputListeners(output);
             if (streamOutput) {
                 process.stdout.write(output);
             }
@@ -229,6 +264,7 @@ class RunningNodeProcess {
         this.childProcess.stderr.on('data', (err) => {
             const output = addColorAndPrefix(err, commandConfig);
             this.terminalOutput += output;
+            this.triggerOutputListeners(output);
             if (streamOutput) {
                 process.stderr.write(output);
             }

package/src/native/index.d.ts

@@ -17,6 +17,8 @@ export declare class AppLifeCycle {
   endCommand(): void
   __init(doneCallback: () => any): void
   registerRunningTask(taskId: string, parserAndWriter: ExternalObject<[ParserArc, WriterArc]>): void
+  registerRunningTaskWithEmptyParser(taskId: string): void
+  appendTaskOutput(taskId: string, output: string): void
   setTaskStatus(taskId: string, status: TaskStatus): void
   registerForcedShutdownCallback(forcedShutdownCallback: () => any): void
   __setCloudMessage(message: string): Promise<void>
@@ -322,7 +324,8 @@ export declare const enum TaskStatus {
   RemoteCache = 5,
   NotStarted = 6,
   InProgress = 7,
-  Shared = 8
+  Shared = 8,
+  Stopped = 9
 }
 
 export interface TaskTarget {

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

@@ -65,7 +65,7 @@ const defaultTasksRunner = async (tasks, options, context) => {
 };
 exports.defaultTasksRunner = defaultTasksRunner;
 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);
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.initiatingTasks, context.projectGraph, context.taskGraph, context.nxJson, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.outputStyle);
     return orchestrator.run();
 }
 exports.default = exports.defaultTasksRunner;

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

@@ -140,6 +140,9 @@ class ForkedProcessTaskRunner {
             }
             this.pseudoTerminals.delete(pseudoTerminal);
             this.processes.delete(p);
+            if (!streamOutput) {
+                this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
+            }
             this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
         });
         return p;

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

@@ -61,6 +61,7 @@ async function initTasksRunner(nxArgs) {
                 nxArgs: { ...nxArgs, parallel: opts.parallel },
                 loadDotEnvFiles: true,
                 initiatingProject: null,
+                initiatingTasks: [],
             });
             return {
                 status: Object.values(taskResults).some((taskResult) => taskResult.status === 'failure' || taskResult.status === 'skipped')
@@ -98,7 +99,7 @@ async function createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJs
             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);
+    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;

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

@@ -36,7 +36,9 @@ 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>;
+    registerRunningTask?(taskId: string, parserAndWriter: ExternalObject<[any, any]>): void;
+    registerRunningTaskWithEmptyParser?(taskId: string): void;
+    appendTaskOutput?(taskId: string, output: string): void;
     setTaskStatus?(taskId: string, status: NativeTaskStatus): void;
     registerForcedShutdownCallback?(callback: () => void): void;
 }
@@ -51,7 +53,9 @@ 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>;
+    registerRunningTask(taskId: string, parserAndWriter: ExternalObject<[any, any]>): void;
+    registerRunningTaskWithEmptyParser(taskId: string): void;
+    appendTaskOutput(taskId: string, output: string): void;
     setTaskStatus(taskId: string, status: NativeTaskStatus): void;
     registerForcedShutdownCallback(callback: () => void): void;
 }

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

@@ -67,10 +67,24 @@ class CompositeLifeCycle {
             }
         }
     }
-    async registerRunningTask(taskId, parserAndWriter) {
+    registerRunningTask(taskId, parserAndWriter) {
         for (let l of this.lifeCycles) {
             if (l.registerRunningTask) {
-                await l.registerRunningTask(taskId, parserAndWriter);
+                l.registerRunningTask(taskId, parserAndWriter);
+            }
+        }
+    }
+    registerRunningTaskWithEmptyParser(taskId) {
+        for (let l of this.lifeCycles) {
+            if (l.registerRunningTaskWithEmptyParser) {
+                l.registerRunningTaskWithEmptyParser(taskId);
+            }
+        }
+    }
+    appendTaskOutput(taskId, output) {
+        for (let l of this.lifeCycles) {
+            if (l.appendTaskOutput) {
+                l.appendTaskOutput(taskId, output);
             }
         }
     }

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

@@ -1,6 +1,6 @@
 import { Task } from '../../config/task-graph';
 import type { LifeCycle } from '../life-cycle';
-export declare function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides, initiatingProject, resolveRenderIsDonePromise, }: {
+export declare function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides, initiatingProject, initiatingTasks, resolveRenderIsDonePromise, }: {
     projectNames: string[];
     tasks: Task[];
     args: {
@@ -10,6 +10,7 @@ export declare function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, ar
     };
     overrides: Record<string, unknown>;
     initiatingProject: string;
+    initiatingTasks: Task[];
     resolveRenderIsDonePromise: (value: void) => void;
 }): {
     lifeCycle: Partial<LifeCycle>;

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

@@ -10,7 +10,7 @@ const figures = require("figures");
 const LEFT_PAD = `   `;
 const SPACER = `  `;
 const EXTENDED_LEFT_PAD = `      `;
-function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides, initiatingProject, resolveRenderIsDonePromise, }) {
+function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides, initiatingProject, initiatingTasks, resolveRenderIsDonePromise, }) {
     const lifeCycle = {};
     const start = process.hrtime();
     const targets = args.targets;
@@ -19,6 +19,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
     let totalSuccessfulTasks = 0;
     let totalFailedTasks = 0;
     let totalCompletedTasks = 0;
+    let totalStoppedTasks = 0;
     let timeTakenText;
     const failedTasks = new Set();
     const inProgressTasks = new Set();
@@ -30,14 +31,19 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
         }
     };
     lifeCycle.printTaskTerminalOutput = (task, taskStatus, terminalOutput) => {
-        tasksToTerminalOutputs[task.id] = { terminalOutput, taskStatus };
         taskIdsInOrderOfCompletion.push(task.id);
+        tasksToTerminalOutputs[task.id] = { terminalOutput, taskStatus };
+    };
+    lifeCycle.setTaskStatus = (taskId, taskStatus) => {
+        if (taskStatus === 9 /* NativeTaskStatus.Stopped */) {
+            totalStoppedTasks++;
+        }
     };
     lifeCycle.endTasks = (taskResults) => {
-        for (let t of taskResults) {
+        for (const { task, status } of taskResults) {
             totalCompletedTasks++;
-            inProgressTasks.delete(t.task.id);
-            switch (t.status) {
+            inProgressTasks.delete(task.id);
+            switch (status) {
                 case 'remote-cache':
                 case 'local-cache':
                 case 'local-cache-kept-existing':
@@ -49,7 +55,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
                     break;
                 case 'failure':
                     totalFailedTasks++;
-                    failedTasks.add(t.task.id);
+                    failedTasks.add(task.id);
                     break;
             }
         }
@@ -75,7 +81,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
     };
     const printRunOneSummary = () => {
         let lines = [];
-        const failure = totalSuccessfulTasks !== totalTasks;
+        const failure = totalSuccessfulTasks + totalStoppedTasks !== totalTasks;
         // Prints task outputs in the order they were completed
         // above the summary, since run-one should print all task results.
         for (const taskId of taskIdsInOrderOfCompletion) {
@@ -99,7 +105,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
             }
             lines = [output_1.output.colors.green(lines.join(node_os_1.EOL))];
         }
-        else if (totalCompletedTasks === totalTasks) {
+        else if (totalCompletedTasks + totalStoppedTasks === totalTasks) {
             let text = `Ran target ${output_1.output.bold(targets[0])} for project ${output_1.output.bold(initiatingProject)}`;
             if (tasks.length > 1) {
                 text += ` and ${output_1.output.bold(tasks.length - 1)} task(s) they depend on`;
@@ -137,7 +143,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
     const printRunManySummary = () => {
         console.log('');
         const lines = [];
-        const failure = totalSuccessfulTasks !== totalTasks;
+        const failure = totalSuccessfulTasks + totalStoppedTasks !== totalTasks;
         for (const taskId of taskIdsInOrderOfCompletion) {
             const { terminalOutput, taskStatus } = tasksToTerminalOutputs[taskId];
             if (taskStatus === 'failure') {
@@ -149,7 +155,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
             }
         }
         lines.push(...output_1.output.getVerticalSeparatorLines(failure ? 'red' : 'green'));
-        if (totalSuccessfulTasks === totalTasks) {
+        if (totalSuccessfulTasks + totalStoppedTasks === totalTasks) {
             const successSummaryRows = [];
             const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
             const taskOverridesRows = [];

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

@@ -17,7 +17,7 @@ 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 invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, }: {
     tasks: Task[];
     projectGraph: ProjectGraph;
     taskGraph: TaskGraph;
@@ -26,6 +26,7 @@ export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, life
     nxArgs: NxArgs;
     loadDotEnvFiles: boolean;
     initiatingProject: string | null;
+    initiatingTasks: Task[];
 }): Promise<{
     [id: string]: TaskResult;
 }>;

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

@@ -46,7 +46,7 @@ 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) {
+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)) {
@@ -82,7 +82,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, projectNames, 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);
+            const mainTaskId = initiatingTasks[0].id;
             pinnedTasks.push(mainTaskId);
             const mainContinuousDependencies = taskGraph.continuousDependencies[mainTaskId];
             if (mainContinuousDependencies.length > 0) {
@@ -111,6 +111,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks
             args: nxArgs,
             overrides: overridesWithoutHidden,
             initiatingProject,
+            initiatingTasks,
             resolveRenderIsDonePromise,
         });
         if (tasks.length === 0) {
@@ -120,7 +121,6 @@ async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks
                 process.stderr.write = originalStderrWrite;
                 console.log = originalConsoleLog;
                 console.error = originalConsoleError;
-                printSummary();
             });
         }
         const lifeCycles = [tsLifeCycle];
@@ -183,7 +183,6 @@ async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks
                 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();
@@ -196,6 +195,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks
         }
         return {
             lifeCycle: new life_cycle_1.CompositeLifeCycle(lifeCycles),
+            printSummary,
             renderIsDone,
         };
     }
@@ -285,9 +285,12 @@ 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, taskGraph, nxArgs, nxJson, overrides);
+    const initiatingTasks = tasks.filter((t) => projectNameSet.has(t.target.project) &&
+        nxArgs.targets.includes(t.target.target));
+    const { lifeCycle, renderIsDone, printSummary } = await getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides);
     const taskResults = await invokeTasksRunner({
         tasks,
         projectGraph,
@@ -297,8 +300,12 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
         nxArgs,
         loadDotEnvFiles: extraOptions.loadDotEnvFiles,
         initiatingProject,
+        initiatingTasks,
     });
     await renderIsDone;
+    if (printSummary) {
+        printSummary();
+    }
     await (0, nx_key_1.printNxKey)();
     return taskResults;
 }
@@ -535,7 +542,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)();
@@ -555,6 +562,7 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
         lifeCycle: compositedLifeCycle,
     }, {
         initiatingProject: nxArgs.outputStyle === 'compact' ? null : initiatingProject,
+        initiatingTasks,
         projectGraph,
         nxJson,
         nxArgs,

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

@@ -7,9 +7,11 @@ 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 { SharedRunningTask } from './running-tasks/shared-running-task';
 export declare class TaskOrchestrator {
     private readonly hasher;
     private readonly initiatingProject;
+    private readonly initiatingTasks;
     private readonly projectGraph;
     private readonly taskGraph;
     private readonly nxJson;
@@ -26,6 +28,7 @@ export declare class TaskOrchestrator {
     private tasksSchedule;
     private batchEnv;
     private reverseTaskDeps;
+    private initializingTaskIds;
     private processedTasks;
     private processedBatches;
     private completedTasks;
@@ -33,8 +36,7 @@ export declare class TaskOrchestrator {
     private groups;
     private bailed;
     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);
+    constructor(hasher: TaskHasher, initiatingProject: string | undefined, initiatingTasks: Task[], 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;
@@ -55,7 +57,7 @@ export declare class TaskOrchestrator {
     }>;
     private runTask;
     private runTaskInForkedProcess;
-    startContinuousTask(task: Task, groupId: number): Promise<RunningTask>;
+    startContinuousTask(task: Task, groupId: number): Promise<RunningTask | SharedRunningTask>;
     private preRunSteps;
     private postRunSteps;
     private scheduleNextTasksAndReleaseThreads;
@@ -67,5 +69,6 @@ export declare class TaskOrchestrator {
     private shouldCopyOutputsFromCache;
     private recordOutputsHash;
     private cleanup;
+    private cleanUpUnneededContinuousTasks;
 }
 export declare function getThreadCount(options: NxArgs & DefaultTasksRunnerOptions, taskGraph: TaskGraph): number;