nx 21.0.0-beta.0 → 21.0.0-beta.10

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,229 @@
+"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 totalStoppedTasks = 0;
+    let timeTakenText;
+    const failedTasks = new Set();
+    const inProgressTasks = 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 */) {
+            totalStoppedTasks++;
+        }
+    };
+    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 + 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) {
+            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 + 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`;
+            }
+            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,
+                ]),
+            ];
+        }
+        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 + totalStoppedTasks !== 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 + totalStoppedTasks === 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 };
+}

package/src/tasks-runner/pseudo-terminal.d.ts

@@ -1,7 +1,8 @@
+import { Serializable } from 'child_process';
 import { ChildProcess, RustPseudoTerminal } from '../native';
 import { PseudoIPCServer } from './pseudo-ipc';
-import { Serializable } from 'child_process';
-export declare function getPseudoTerminal(skipSupportCheck?: boolean): PseudoTerminal;
+import { RunningTask } from './running-tasks/running-task';
+export declare function createPseudoTerminal(skipSupportCheck?: boolean): PseudoTerminal;
 export declare class PseudoTerminal {
     private rustPseudoTerminal;
     private pseudoIPCPath;
@@ -10,6 +11,7 @@ export declare class PseudoTerminal {
     static isSupported(): boolean;
     constructor(rustPseudoTerminal: RustPseudoTerminal);
     init(): Promise<void>;
+    shutdown(): void;
     runCommand(command: string, { cwd, execArgv, jsEnv, quiet, tty, }?: {
         cwd?: string;
         execArgv?: string[];
@@ -25,16 +27,15 @@ export declare class PseudoTerminal {
     }): Promise<PseudoTtyProcessWithSend>;
     sendMessageToChildren(message: Serializable): void;
     onMessageFromChildren(callback: (message: Serializable) => void): void;
-    private setupProcessListeners;
-    private shutdownPseudoIPC;
 }
-export declare class PseudoTtyProcess {
+export declare class PseudoTtyProcess implements RunningTask {
+    rustPseudoTerminal: RustPseudoTerminal;
     private childProcess;
     isAlive: boolean;
     private exitCallbacks;
     private outputCallbacks;
     private terminalOutput;
-    constructor(childProcess: ChildProcess);
+    constructor(rustPseudoTerminal: RustPseudoTerminal, childProcess: ChildProcess);
     getResults(): Promise<{
         code: number;
         terminalOutput: string;
@@ -42,10 +43,12 @@ export declare class PseudoTtyProcess {
     onExit(callback: (code: number) => void): void;
     onOutput(callback: (message: string) => void): void;
     kill(): void;
+    getParserAndWriter(): import("../native").ExternalObject<[ParserArc, WriterArc]>;
 }
 export declare class PseudoTtyProcessWithSend extends PseudoTtyProcess {
+    rustPseudoTerminal: RustPseudoTerminal;
     private id;
     private pseudoIpc;
-    constructor(_childProcess: ChildProcess, id: string, pseudoIpc: PseudoIPCServer);
+    constructor(rustPseudoTerminal: RustPseudoTerminal, _childProcess: ChildProcess, id: string, pseudoIpc: PseudoIPCServer);
     send(message: Serializable): void;
 }