nx 21.0.0-beta.1 → 21.0.0-beta.11

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';
     }
@@ -50,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')
@@ -61,3 +73,51 @@ 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 nxArgs = {
+        ...options,
+        parallel: tasks.length,
+        lifeCycle: compositedLifeCycle,
+    };
+    (0, run_command_1.setEnvVarsBasedOnArgs)(nxArgs, true);
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, [], projectGraph, taskGraph, nxJson, nxArgs, false, client_1.daemonClient, undefined, taskGraphForHashing);
+    await orchestrator.init();
+    orchestrator.processTasks(tasks.map((task) => 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, skipCapableCheck?: boolean): any;

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTuiEnabled = isTuiEnabled;
+const devkit_internals_1 = require("../devkit-internals");
+const is_ci_1 = require("../utils/is-ci");
+let tuiEnabled = undefined;
+function isTuiEnabled(nxJson, skipCapableCheck = false) {
+    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 = skipCapableCheck || (process.stderr.isTTY && isUnicodeSupported());
+    if (!isCapable) {
+        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';
+        return tuiEnabled;
+    }
+    // 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 ((0, is_ci_1.isCI)() || isWindows) {
+        tuiEnabled = false;
+        process.env.NX_TUI = '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,16 @@ 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]>): void;
+    registerRunningTaskWithEmptyParser?(taskId: string): void;
+    appendTaskOutput?(taskId: string, output: string): 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 +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]>): 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

@@ -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,40 @@ class CompositeLifeCycle {
             }
         }
     }
+    registerRunningTask(taskId, parserAndWriter) {
+        for (let l of this.lifeCycles) {
+            if (l.registerRunningTask) {
+                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);
+            }
+        }
+    }
+    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.d.ts

@@ -3,7 +3,9 @@ import { LifeCycle, TaskResult } from '../life-cycle';
 export declare class LegacyTaskHistoryLifeCycle implements LifeCycle {
     private startTimings;
     private taskRuns;
+    private flakyTasks;
     startTasks(tasks: Task[]): void;
     endTasks(taskResults: TaskResult[]): Promise<void>;
     endCommand(): Promise<void>;
+    printFlakyTasksMessage(): void;
 }

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 = {};
@@ -30,20 +31,27 @@ class LegacyTaskHistoryLifeCycle {
     async endCommand() {
         await (0, legacy_task_history_1.writeTaskRunsToHistory)(this.taskRuns);
         const history = await (0, legacy_task_history_1.getHistoryForHashes)(this.taskRuns.map((t) => t.hash));
-        const flakyTasks = [];
+        this.flakyTasks = [];
         // check if any hash has different exit codes => flaky
         for (let hash in history) {
             if (history[hash].length > 1 &&
                 history[hash].some((run) => run.code !== history[hash][0].code)) {
-                flakyTasks.push((0, serialize_target_1.serializeTarget)(history[hash][0].project, history[hash][0].target, history[hash][0].configuration));
+                this.flakyTasks.push((0, serialize_target_1.serializeTarget)(history[hash][0].project, history[hash][0].target, history[hash][0].configuration));
             }
         }
-        if (flakyTasks.length > 0) {
+        // Do not directly print output when using the TUI
+        if ((0, is_tui_enabled_1.isTuiEnabled)()) {
+            return;
+        }
+        this.printFlakyTasksMessage();
+    }
+    printFlakyTasksMessage() {
+        if (this.flakyTasks.length > 0) {
             output_1.output.warn({
-                title: `Nx detected ${flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                title: `Nx detected ${this.flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
                 bodyLines: [
                     ,
-                    ...flakyTasks.map((t) => `  ${t}`),
+                    ...this.flakyTasks.map((t) => `  ${t}`),
                     '',
                     `Flaky tasks can disrupt your CI pipeline. Automatically retry them with Nx Cloud. Learn more at https://nx.dev/ci/features/flaky-tasks`,
                 ],

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

@@ -1,10 +1,15 @@
 import { Task } from '../../config/task-graph';
 import { LifeCycle, TaskResult } from '../life-cycle';
+import { LegacyTaskHistoryLifeCycle } from './task-history-life-cycle-old';
+export declare function getTasksHistoryLifeCycle(): TaskHistoryLifeCycle | LegacyTaskHistoryLifeCycle | null;
 export declare class TaskHistoryLifeCycle implements LifeCycle {
     private startTimings;
     private taskRuns;
     private taskHistory;
+    private flakyTasks;
+    constructor();
     startTasks(tasks: Task[]): void;
     endTasks(taskResults: TaskResult[]): Promise<void>;
     endCommand(): Promise<void>;
+    printFlakyTasksMessage(): void;
 }

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

@@ -1,14 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskHistoryLifeCycle = void 0;
-const serialize_target_1 = require("../../utils/serialize-target");
+exports.getTasksHistoryLifeCycle = getTasksHistoryLifeCycle;
+const native_1 = require("../../native");
 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");
+const task_history_life_cycle_old_1 = require("./task-history-life-cycle-old");
+const nx_cloud_utils_1 = require("../../utils/nx-cloud-utils");
+const nx_json_1 = require("../../config/nx-json");
+let tasksHistoryLifeCycle;
+function getTasksHistoryLifeCycle() {
+    if (!(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
+        if (!tasksHistoryLifeCycle) {
+            tasksHistoryLifeCycle =
+                process.env.NX_DISABLE_DB !== 'true' && !native_1.IS_WASM
+                    ? new TaskHistoryLifeCycle()
+                    : new task_history_life_cycle_old_1.LegacyTaskHistoryLifeCycle();
+        }
+        return tasksHistoryLifeCycle;
+    }
+    return null;
+}
 class TaskHistoryLifeCycle {
     constructor() {
         this.startTimings = {};
         this.taskRuns = new Map();
         this.taskHistory = (0, task_history_1.getTaskHistory)();
+        if (tasksHistoryLifeCycle) {
+            throw new Error('TaskHistoryLifeCycle is a singleton and should not be instantiated multiple times');
+        }
+        tasksHistoryLifeCycle = this;
     }
     startTasks(tasks) {
         for (let task of tasks) {
@@ -35,13 +58,20 @@ class TaskHistoryLifeCycle {
             return;
         }
         await this.taskHistory.recordTaskRuns(entries.map(([_, v]) => v));
-        const flakyTasks = await this.taskHistory.getFlakyTasks(entries.map(([hash]) => hash));
-        if (flakyTasks.length > 0) {
+        this.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;
+        }
+        this.printFlakyTasksMessage();
+    }
+    printFlakyTasksMessage() {
+        if (this.flakyTasks.length > 0) {
             output_1.output.warn({
-                title: `Nx detected ${flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                title: `Nx detected ${this.flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
                 bodyLines: [
                     ,
-                    ...flakyTasks.map((hash) => {
+                    ...this.flakyTasks.map((hash) => {
                         const taskRun = this.taskRuns.get(hash);
                         return `  ${(0, serialize_target_1.serializeTarget)(taskRun.target.project, taskRun.target.target, taskRun.target.configuration)}`;
                     }),

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

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

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

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTuiTerminalSummaryLifeCycle = getTuiTerminalSummaryLifeCycle;
+const node_os_1 = require("node:os");
+const output_1 = require("../../utils/output");
+const formatting_utils_1 = require("./formatting-utils");
+const pretty_time_1 = require("./pretty-time");
+const view_logs_utils_1 = require("./view-logs-utils");
+const figures = require("figures");
+const task_history_life_cycle_1 = require("./task-history-life-cycle");
+const LEFT_PAD = `   `;
+const SPACER = `  `;
+const EXTENDED_LEFT_PAD = `      `;
+function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides, initiatingProject, initiatingTasks, resolveRenderIsDonePromise, }) {
+    const lifeCycle = {};
+    const start = process.hrtime();
+    const targets = args.targets;
+    const totalTasks = tasks.length;
+    let totalCachedTasks = 0;
+    let totalSuccessfulTasks = 0;
+    let totalFailedTasks = 0;
+    let totalCompletedTasks = 0;
+    let timeTakenText;
+    const failedTasks = new Set();
+    const inProgressTasks = new Set();
+    const stoppedTasks = new Set();
+    const tasksToTerminalOutputs = {};
+    const taskIdsInOrderOfCompletion = [];
+    lifeCycle.startTasks = (tasks) => {
+        for (let t of tasks) {
+            inProgressTasks.add(t.id);
+        }
+    };
+    lifeCycle.printTaskTerminalOutput = (task, taskStatus, terminalOutput) => {
+        taskIdsInOrderOfCompletion.push(task.id);
+        tasksToTerminalOutputs[task.id] = { terminalOutput, taskStatus };
+    };
+    lifeCycle.setTaskStatus = (taskId, taskStatus) => {
+        if (taskStatus === 9 /* NativeTaskStatus.Stopped */) {
+            stoppedTasks.add(taskId);
+            inProgressTasks.delete(taskId);
+        }
+    };
+    lifeCycle.endTasks = (taskResults) => {
+        for (const { task, status } of taskResults) {
+            totalCompletedTasks++;
+            inProgressTasks.delete(task.id);
+            switch (status) {
+                case 'remote-cache':
+                case 'local-cache':
+                case 'local-cache-kept-existing':
+                    totalCachedTasks++;
+                    totalSuccessfulTasks++;
+                    break;
+                case 'success':
+                    totalSuccessfulTasks++;
+                    break;
+                case 'failure':
+                    totalFailedTasks++;
+                    failedTasks.add(task.id);
+                    break;
+            }
+        }
+    };
+    lifeCycle.endCommand = () => {
+        timeTakenText = (0, pretty_time_1.prettyTime)(process.hrtime(start));
+        resolveRenderIsDonePromise();
+    };
+    const printSummary = () => {
+        const isRunOne = initiatingProject && targets?.length === 1;
+        // Handles when the user interrupts the process
+        timeTakenText ??= (0, pretty_time_1.prettyTime)(process.hrtime(start));
+        if (totalTasks === 0) {
+            console.log(`\n${output_1.output.applyNxPrefix('gray', 'No tasks were run')}\n`);
+            return;
+        }
+        if (isRunOne) {
+            printRunOneSummary();
+        }
+        else {
+            printRunManySummary();
+        }
+        (0, task_history_life_cycle_1.getTasksHistoryLifeCycle)()?.printFlakyTasksMessage();
+    };
+    const printRunOneSummary = () => {
+        let lines = [];
+        const failure = totalSuccessfulTasks + stoppedTasks.size !== 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) {
+            const { terminalOutput, taskStatus } = tasksToTerminalOutputs[taskId];
+            output_1.output.logCommandOutput(taskId, taskStatus, terminalOutput);
+        }
+        lines.push(...output_1.output.getVerticalSeparatorLines(failure ? 'red' : 'green'));
+        if (!failure) {
+            const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)([initiatingProject], targets, tasks)}`;
+            const taskOverridesLines = [];
+            if (Object.keys(overrides).length > 0) {
+                taskOverridesLines.push('');
+                taskOverridesLines.push(`${EXTENDED_LEFT_PAD}${output_1.output.dim.green('With additional flags:')}`);
+                Object.entries(overrides)
+                    .map(([flag, value]) => output_1.output.dim.green((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value)))
+                    .forEach((arg) => taskOverridesLines.push(arg));
+            }
+            lines.push(output_1.output.applyNxPrefix('green', output_1.output.colors.green(text) + output_1.output.dim(` (${timeTakenText})`)), ...taskOverridesLines);
+            if (totalCachedTasks > 0) {
+                lines.push(output_1.output.dim(`${node_os_1.EOL}Nx read the output from the cache instead of running the command for ${totalCachedTasks} out of ${totalTasks} tasks.`));
+            }
+            lines = [output_1.output.colors.green(lines.join(node_os_1.EOL))];
+        }
+        else if (totalCompletedTasks + stoppedTasks.size === 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`;
+            }
+            const taskOverridesLines = [];
+            if (Object.keys(overrides).length > 0) {
+                taskOverridesLines.push('');
+                taskOverridesLines.push(`${EXTENDED_LEFT_PAD}${output_1.output.dim.red('With additional flags:')}`);
+                Object.entries(overrides)
+                    .map(([flag, value]) => output_1.output.dim.red((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value)))
+                    .forEach((arg) => taskOverridesLines.push(arg));
+            }
+            const viewLogs = (0, view_logs_utils_1.viewLogsFooterRows)(totalFailedTasks);
+            lines = [
+                output_1.output.colors.red([
+                    output_1.output.applyNxPrefix('red', output_1.output.colors.red(text) + output_1.output.dim(` (${timeTakenText})`)),
+                    ...taskOverridesLines,
+                    '',
+                    `${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} failed`,
+                    `${LEFT_PAD}${output_1.output.dim(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`,
+                    ...viewLogs,
+                ].join(node_os_1.EOL)),
+            ];
+        }
+        else {
+            lines = [
+                ...output_1.output.getVerticalSeparatorLines('red'),
+                output_1.output.applyNxPrefix('red', output_1.output.colors.red(`Cancelled running target ${output_1.output.bold(targets[0])} for project ${output_1.output.bold(initiatingProject)}`) + output_1.output.dim(` (${timeTakenText})`)),
+            ];
+        }
+        // adds some vertical space after the summary to avoid bunching against terminal
+        lines.push('');
+        console.log(lines.join(node_os_1.EOL));
+    };
+    const printRunManySummary = () => {
+        console.log('');
+        const lines = [];
+        const failure = totalSuccessfulTasks + stoppedTasks.size !== totalTasks;
+        for (const taskId of taskIdsInOrderOfCompletion) {
+            const { terminalOutput, taskStatus } = tasksToTerminalOutputs[taskId];
+            if (taskStatus === 'failure') {
+                output_1.output.logCommandOutput(taskId, taskStatus, terminalOutput);
+                lines.push(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${output_1.output.colors.gray('nx run ')}${taskId}`);
+            }
+            else {
+                lines.push(`${LEFT_PAD}${output_1.output.colors.green(figures.tick)}${SPACER}${output_1.output.colors.gray('nx run ')}${taskId}`);
+            }
+        }
+        lines.push(...output_1.output.getVerticalSeparatorLines(failure ? 'red' : 'green'));
+        if (totalSuccessfulTasks + stoppedTasks.size === totalTasks) {
+            const successSummaryRows = [];
+            const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
+            const taskOverridesRows = [];
+            if (Object.keys(overrides).length > 0) {
+                taskOverridesRows.push('');
+                taskOverridesRows.push(`${EXTENDED_LEFT_PAD}${output_1.output.dim.green('With additional flags:')}`);
+                Object.entries(overrides)
+                    .map(([flag, value]) => output_1.output.dim.green((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value)))
+                    .forEach((arg) => taskOverridesRows.push(arg));
+            }
+            successSummaryRows.push(...[
+                output_1.output.applyNxPrefix('green', output_1.output.colors.green(text) + output_1.output.dim.white(` (${timeTakenText})`)),
+                ...taskOverridesRows,
+            ]);
+            if (totalCachedTasks > 0) {
+                successSummaryRows.push(output_1.output.dim(`${node_os_1.EOL}Nx read the output from the cache instead of running the command for ${totalCachedTasks} out of ${totalTasks} tasks.`));
+            }
+            lines.push(successSummaryRows.join(node_os_1.EOL));
+        }
+        else {
+            const text = `${inProgressTasks.size ? 'Cancelled while running' : 'Ran'} ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
+            const taskOverridesRows = [];
+            if (Object.keys(overrides).length > 0) {
+                taskOverridesRows.push('');
+                taskOverridesRows.push(`${EXTENDED_LEFT_PAD}${output_1.output.dim.red('With additional flags:')}`);
+                Object.entries(overrides)
+                    .map(([flag, value]) => output_1.output.dim.red((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value)))
+                    .forEach((arg) => taskOverridesRows.push(arg));
+            }
+            const numFailedToPrint = 5;
+            const failedTasksForPrinting = Array.from(failedTasks).slice(0, numFailedToPrint);
+            const failureSummaryRows = [
+                output_1.output.applyNxPrefix('red', output_1.output.colors.red(text) + output_1.output.dim.white(` (${timeTakenText})`)),
+                ...taskOverridesRows,
+                '',
+            ];
+            if (totalCompletedTasks > 0) {
+                if (totalSuccessfulTasks > 0) {
+                    failureSummaryRows.push(output_1.output.dim(`${LEFT_PAD}${output_1.output.dim(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`), '');
+                }
+                if (totalFailedTasks > 0) {
+                    failureSummaryRows.push(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} targets failed, including the following:`, '', `${failedTasksForPrinting
+                        .map((t) => `${EXTENDED_LEFT_PAD}${output_1.output.colors.red('-')} ${output_1.output.formatCommand(t.toString())}`)
+                        .join('\n')}`, '');
+                    if (failedTasks.size > numFailedToPrint) {
+                        failureSummaryRows.push(output_1.output.dim(`${EXTENDED_LEFT_PAD}...and ${failedTasks.size - numFailedToPrint} more...`));
+                    }
+                }
+                if (totalCompletedTasks !== totalTasks) {
+                    const remainingTasks = totalTasks - totalCompletedTasks;
+                    if (inProgressTasks.size) {
+                        failureSummaryRows.push(`${LEFT_PAD}${output_1.output.colors.red(figures.ellipsis)}${SPACER}${inProgressTasks.size}${`/${totalTasks}`} targets were in progress, including the following:`, '', `${Array.from(inProgressTasks)
+                            .map((t) => `${EXTENDED_LEFT_PAD}${output_1.output.colors.red('-')} ${output_1.output.formatCommand(t.toString())}`)
+                            .join(node_os_1.EOL)}`, '');
+                    }
+                    if (remainingTasks - inProgressTasks.size > 0) {
+                        failureSummaryRows.push(output_1.output.dim(`${LEFT_PAD}${output_1.output.colors.red(figures.ellipsis)}${SPACER}${remainingTasks - inProgressTasks.size}${`/${totalTasks}`} targets had not started.`), '');
+                    }
+                }
+                failureSummaryRows.push(...(0, view_logs_utils_1.viewLogsFooterRows)(failedTasks.size));
+                lines.push(output_1.output.colors.red(failureSummaryRows.join(node_os_1.EOL)));
+            }
+        }
+        // adds some vertical space after the summary to avoid bunching against terminal
+        lines.push('');
+        console.log(lines.join(node_os_1.EOL));
+    };
+    return { lifeCycle, printSummary };
+}