nx 21.0.0-canary.20250206-8bd0bcd → 21.0.0-canary.20250418-8619c1d

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';
     }
@@ -36,6 +47,10 @@ async function initTasksRunner(nxArgs) {
                     acc[task.id] = [];
                     return acc;
                 }, {}),
+                continuousDependencies: opts.tasks.reduce((acc, task) => {
+                    acc[task.id] = [];
+                    return acc;
+                }, {}),
             };
             const taskResults = await (0, run_command_1.invokeTasksRunner)({
                 tasks: opts.tasks,
@@ -57,3 +72,45 @@ async function initTasksRunner(nxArgs) {
         },
     };
 }
+async function createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
+    (0, dotenv_1.loadRootEnvFiles)();
+    const invokeRunnerTerminalLifecycle = new invoke_runner_terminal_output_life_cycle_1.InvokeRunnerTerminalOutputLifeCycle(tasks);
+    const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
+    const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
+        ...(0, run_command_1.constructLifeCycles)(invokeRunnerTerminalLifecycle),
+        taskResultsLifecycle,
+        lifeCycle,
+    ]);
+    const { runnerOptions: options } = (0, run_command_1.getRunner)({}, nxJson);
+    let hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, options);
+    const taskGraph = {
+        roots: tasks.map((task) => task.id),
+        tasks: tasks.reduce((acc, task) => {
+            acc[task.id] = task;
+            return acc;
+        }, {}),
+        dependencies: tasks.reduce((acc, task) => {
+            acc[task.id] = [];
+            return acc;
+        }, {}),
+        continuousDependencies: tasks.reduce((acc, task) => {
+            acc[task.id] = [];
+            return acc;
+        }, {}),
+    };
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, projectGraph, taskGraph, nxJson, { ...options, parallel: tasks.length, lifeCycle: compositedLifeCycle }, false, client_1.daemonClient, undefined, taskGraphForHashing);
+    await orchestrator.init();
+    await Promise.all(tasks.map((task) => orchestrator.processTask(task.id)));
+    return orchestrator;
+}
+async function runDiscreteTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle);
+    return tasks.map((task, index) => orchestrator.applyFromCacheOrRunTask(true, task, index));
+}
+async function runContinuousTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle);
+    return tasks.reduce((current, task, index) => {
+        current[task.id] = orchestrator.startContinuousTask(task, index);
+        return current;
+    }, {});
+}

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

@@ -0,0 +1,2 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+export declare function isTuiEnabled(nxJson?: NxJsonConfiguration, 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,14 @@ export interface LifeCycle {
     startTasks?(task: Task[], metadata: TaskMetadata): void | Promise<void>;
     endTasks?(taskResults: TaskResult[], metadata: TaskMetadata): void | Promise<void>;
     printTaskTerminalOutput?(task: Task, status: TaskStatus, output: string): void;
+    registerRunningTask?(taskId: string, parserAndWriter: ExternalObject<[any, any]>): Promise<void>;
+    setTaskStatus?(taskId: string, status: NativeTaskStatus): void;
+    registerForcedShutdownCallback?(callback: () => void): void;
 }
 export declare class CompositeLifeCycle implements LifeCycle {
     private readonly lifeCycles;
     constructor(lifeCycles: LifeCycle[]);
-    startCommand(): Promise<void>;
+    startCommand(parallel?: number): Promise<void>;
     endCommand(): Promise<void>;
     scheduleTask(task: Task): Promise<void>;
     startTask(task: Task): void;
@@ -47,4 +51,7 @@ export declare class CompositeLifeCycle implements LifeCycle {
     startTasks(tasks: Task[], metadata: TaskMetadata): Promise<void>;
     endTasks(taskResults: TaskResult[], metadata: TaskMetadata): Promise<void>;
     printTaskTerminalOutput(task: Task, status: TaskStatus, output: string): void;
+    registerRunningTask(taskId: string, parserAndWriter: ExternalObject<[any, any]>): Promise<void>;
+    setTaskStatus(taskId: string, status: NativeTaskStatus): void;
+    registerForcedShutdownCallback(callback: () => void): void;
 }

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,221 @@
+"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 LEFT_PAD = `   `;
+const SPACER = `  `;
+const EXTENDED_LEFT_PAD = `      `;
+function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides, initiatingProject, 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 tasksToTerminalOutputs = {};
+    const taskIdsInOrderOfCompletion = [];
+    lifeCycle.startTasks = (tasks) => {
+        for (let t of tasks) {
+            inProgressTasks.add(t.id);
+        }
+    };
+    lifeCycle.printTaskTerminalOutput = (task, taskStatus, terminalOutput) => {
+        tasksToTerminalOutputs[task.id] = { terminalOutput, taskStatus };
+        taskIdsInOrderOfCompletion.push(task.id);
+    };
+    lifeCycle.endTasks = (taskResults) => {
+        for (let t of taskResults) {
+            totalCompletedTasks++;
+            inProgressTasks.delete(t.task.id);
+            switch (t.status) {
+                case 'remote-cache':
+                case 'local-cache':
+                case 'local-cache-kept-existing':
+                    totalCachedTasks++;
+                    totalSuccessfulTasks++;
+                    break;
+                case 'success':
+                    totalSuccessfulTasks++;
+                    break;
+                case 'failure':
+                    totalFailedTasks++;
+                    failedTasks.add(t.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();
+        }
+    };
+    const printRunOneSummary = () => {
+        let lines = [];
+        const failure = totalSuccessfulTasks !== 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 === 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 !== 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 === 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,21 +27,28 @@ 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;
-    exitCallbacks: any[];
-    constructor(childProcess: ChildProcess);
+    private exitCallbacks;
+    private outputCallbacks;
+    private terminalOutput;
+    constructor(rustPseudoTerminal: RustPseudoTerminal, childProcess: ChildProcess);
+    getResults(): Promise<{
+        code: number;
+        terminalOutput: string;
+    }>;
     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;
 }