@ohos-ports/nx 19.8.4-beta.0

package/src/tasks-runner/life-cycles/dynamic-run-one-terminal-output-life-cycle.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRunOneDynamicOutputRenderer = createRunOneDynamicOutputRenderer;
+const cliCursor = require("cli-cursor");
+const cli_spinners_1 = require("cli-spinners");
+const os_1 = require("os");
+const readline = require("readline");
+const output_1 = require("../../utils/output");
+const pretty_time_1 = require("./pretty-time");
+const formatting_utils_1 = require("./formatting-utils");
+const view_logs_utils_1 = require("./view-logs-utils");
+const LEFT_PAD = `   `;
+const SPACER = `  `;
+const EXTENDED_LEFT_PAD = `      `;
+/**
+ * The following function is responsible for creating a life cycle with dynamic
+ * outputs, meaning previous outputs can be rewritten or modified as new outputs
+ * are added. It is therefore intended for use on a user's local machines.
+ *
+ * In CI environments the static equivalent of this life cycle should be used.
+ *
+ * NOTE: output.dim() should be preferred over output.colors.gray() because it
+ * is much more consistently readable across different terminal color themes.
+ */
+async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, args, overrides, }) {
+    cliCursor.hide();
+    // Show the cursor again after the process exits
+    process.on('exit', () => {
+        cliCursor.show();
+    });
+    let resolveRenderIsDonePromise;
+    const renderIsDone = new Promise((resolve) => (resolveRenderIsDonePromise = resolve)).then(() => {
+        clearRenderInterval();
+        cliCursor.show();
+    });
+    function clearRenderInterval() {
+        if (renderDependentTargetsIntervalId) {
+            clearInterval(renderDependentTargetsIntervalId);
+        }
+    }
+    process.on('exit', () => clearRenderInterval());
+    process.on('SIGINT', () => clearRenderInterval());
+    process.on('SIGTERM', () => clearRenderInterval());
+    process.on('SIGHUP', () => clearRenderInterval());
+    const lifeCycle = {};
+    const start = process.hrtime();
+    const figures = await Promise.resolve().then(() => require('figures'));
+    let state = 'EXECUTING_DEPENDENT_TARGETS';
+    const tasksToTerminalOutputs = {};
+    const totalTasks = tasks.length;
+    const totalDependentTasks = totalTasks - 1;
+    const totalTasksFromInitiatingProject = tasks.filter((t) => t.target.project === initiatingProject).length;
+    // Tasks from the initiating project are treated differently, they forward their output
+    const totalDependentTasksNotFromInitiatingProject = totalTasks - totalTasksFromInitiatingProject;
+    const targetName = tasks[0].target.target;
+    let dependentTargetsNumLines = 0;
+    let totalCompletedTasks = 0;
+    let totalSuccessfulTasks = 0;
+    let totalFailedTasks = 0;
+    let totalCachedTasks = 0;
+    // Used to control the rendering of the spinner
+    let dependentTargetsCurrentFrame = 0;
+    let renderDependentTargetsIntervalId;
+    const moveCursorToStartOfDependentTargetLines = () => {
+        readline.moveCursor(process.stdout, 0, -dependentTargetsNumLines);
+    };
+    const renderLines = (lines, dividerColor = 'cyan', renderDivider = true) => {
+        let additionalLines = 0;
+        if (renderDivider) {
+            const dividerLines = output_1.output.getVerticalSeparatorLines(dividerColor);
+            for (const line of dividerLines) {
+                output_1.output.overwriteLine(line);
+            }
+            additionalLines += dividerLines.length;
+            lines.push('');
+        }
+        for (const line of lines) {
+            output_1.output.overwriteLine(line);
+        }
+        dependentTargetsNumLines = lines.length + additionalLines;
+        // clear any possible text below the cursor's position
+        readline.clearScreenDown(process.stdout);
+    };
+    const renderDependentTargets = (renderDivider = true) => {
+        if (totalDependentTasksNotFromInitiatingProject <= 0) {
+            return;
+        }
+        const max = cli_spinners_1.dots.frames.length - 1;
+        const curr = dependentTargetsCurrentFrame;
+        dependentTargetsCurrentFrame = curr >= max ? 0 : curr + 1;
+        const linesToRender = [''];
+        const remainingDependentTasksNotFromInitiatingProject = totalDependentTasksNotFromInitiatingProject - totalCompletedTasks;
+        switch (state) {
+            case 'EXECUTING_DEPENDENT_TARGETS':
+                if (totalFailedTasks === 0) {
+                    linesToRender.push(`${LEFT_PAD}${output_1.output.colors.cyan(cli_spinners_1.dots.frames[dependentTargetsCurrentFrame])}${SPACER}${output_1.output.dim(`Nx is waiting on ${remainingDependentTasksNotFromInitiatingProject} dependent project tasks before running tasks from`)} ${initiatingProject}${output_1.output.dim('...')}`);
+                    if (totalSuccessfulTasks > 0) {
+                        linesToRender.push('');
+                    }
+                }
+                break;
+        }
+        if (totalFailedTasks > 0) {
+            linesToRender.push(output_1.output.colors.red.dim(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} dependent project tasks failed (see below)`));
+        }
+        if (totalSuccessfulTasks > 0) {
+            linesToRender.push(output_1.output.dim(`${LEFT_PAD}${output_1.output.dim(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} dependent project tasks succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`));
+        }
+        moveCursorToStartOfDependentTargetLines();
+        if (linesToRender.length > 1) {
+            renderLines(linesToRender, 'gray', renderDivider && state !== 'EXECUTING_DEPENDENT_TARGETS');
+        }
+        else {
+            renderLines([]);
+        }
+    };
+    lifeCycle.startCommand = () => {
+        renderDependentTargets();
+    };
+    lifeCycle.startTasks = (tasks) => {
+        for (const task of tasks) {
+            // Move from the dependent project tasks phase to the initiating project's targets
+            if (task.target.project === initiatingProject &&
+                state !== 'EXECUTING_INITIATING_PROJECT_TARGET') {
+                state = 'EXECUTING_INITIATING_PROJECT_TARGET';
+                clearRenderInterval();
+                renderDependentTargets(false);
+                if (totalDependentTasksNotFromInitiatingProject > 0) {
+                    output_1.output.addNewline();
+                    process.stdout.write(`${LEFT_PAD}${output_1.output.dim('Hint: you can run the command with')} --verbose ${output_1.output.dim('to see the full dependent project outputs')}` + os_1.EOL);
+                    output_1.output.addVerticalSeparator('gray');
+                }
+            }
+        }
+        if (!renderDependentTargetsIntervalId &&
+            state === 'EXECUTING_DEPENDENT_TARGETS') {
+            renderDependentTargetsIntervalId = setInterval(renderDependentTargets, 100);
+        }
+    };
+    lifeCycle.printTaskTerminalOutput = (task, cacheStatus, terminalOutput) => {
+        if (task.target.project === initiatingProject) {
+            output_1.output.logCommandOutput(task.id, cacheStatus, terminalOutput);
+        }
+        else {
+            tasksToTerminalOutputs[task.id] = terminalOutput;
+        }
+    };
+    lifeCycle.endTasks = (taskResults) => {
+        for (let t of taskResults) {
+            totalCompletedTasks++;
+            switch (t.status) {
+                case 'remote-cache':
+                case 'local-cache':
+                case 'local-cache-kept-existing':
+                    totalCachedTasks++;
+                    totalSuccessfulTasks++;
+                    break;
+                case 'success':
+                    totalSuccessfulTasks++;
+                    break;
+                case 'failure':
+                    totalFailedTasks++;
+                    /**
+                     * A dependent project has failed so we stop executing and update the relevant
+                     * dependent project task messaging
+                     */
+                    if (t.task.target.project !== initiatingProject) {
+                        clearRenderInterval();
+                        renderDependentTargets(false);
+                        output_1.output.addVerticalSeparator('red');
+                        output_1.output.logCommandOutput(t.task.id, t.status, tasksToTerminalOutputs[t.task.id]);
+                    }
+                    break;
+            }
+            delete tasksToTerminalOutputs[t.task.id];
+        }
+    };
+    lifeCycle.endCommand = () => {
+        clearRenderInterval();
+        const timeTakenText = (0, pretty_time_1.prettyTime)(process.hrtime(start));
+        if (totalSuccessfulTasks === totalTasks) {
+            state = 'COMPLETED_SUCCESSFULLY';
+            const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)([initiatingProject], [targetName], 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));
+            }
+            const pinnedFooterLines = [
+                output_1.output.applyNxPrefix('green', output_1.output.colors.green(text) + output_1.output.dim(` (${timeTakenText})`)),
+                ...taskOverridesLines,
+            ];
+            if (totalCachedTasks > 0) {
+                pinnedFooterLines.push(output_1.output.dim(`${os_1.EOL}Nx read the output from the cache instead of running the command for ${totalCachedTasks} out of ${totalTasks} tasks.`));
+            }
+            renderLines(pinnedFooterLines, 'green');
+        }
+        else {
+            state = 'COMPLETED_WITH_ERRORS';
+            let text = `Ran target ${output_1.output.bold(targetName)} for project ${output_1.output.bold(initiatingProject)}`;
+            if (totalDependentTasks > 0) {
+                text += ` and ${output_1.output.bold(totalDependentTasks)} 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);
+            renderLines([
+                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,
+            ], 'red');
+        }
+        resolveRenderIsDonePromise();
+    };
+    return { lifeCycle, renderIsDone };
+}

package/src/tasks-runner/life-cycles/empty-terminal-output-life-cycle.d.ts

@@ -0,0 +1,5 @@
+import type { LifeCycle } from '../life-cycle';
+import { TaskStatus } from '../tasks-runner';
+export declare class EmptyTerminalOutputLifeCycle implements LifeCycle {
+    printTaskTerminalOutput(task: any, cacheStatus: TaskStatus, terminalOutput: string): void;
+}

package/src/tasks-runner/life-cycles/empty-terminal-output-life-cycle.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyTerminalOutputLifeCycle = void 0;
+const output_1 = require("../../utils/output");
+const utils_1 = require("../utils");
+class EmptyTerminalOutputLifeCycle {
+    printTaskTerminalOutput(task, cacheStatus, terminalOutput) {
+        if (cacheStatus === 'success' ||
+            cacheStatus === 'failure' ||
+            cacheStatus === 'skipped') {
+            const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+            output_1.output.logCommandOutput(args.join(' '), cacheStatus, terminalOutput);
+        }
+    }
+}
+exports.EmptyTerminalOutputLifeCycle = EmptyTerminalOutputLifeCycle;

package/src/tasks-runner/life-cycles/formatting-utils.d.ts

@@ -0,0 +1,3 @@
+import { Task } from '../../config/task-graph';
+export declare function formatFlags(leftPadding: string, flag: string, value: any): string;
+export declare function formatTargetsAndProjects(projectNames: string[], targets: string[], tasks: Task[]): string;

package/src/tasks-runner/life-cycles/formatting-utils.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFlags = formatFlags;
+exports.formatTargetsAndProjects = formatTargetsAndProjects;
+const output_1 = require("../../utils/output");
+function formatFlags(leftPadding, flag, value) {
+    return flag == '_'
+        ? `${leftPadding}  ${value.join(' ')}`
+        : `${leftPadding}  --${flag}=${formatValue(value)}`;
+}
+function formatValue(value) {
+    if (Array.isArray(value)) {
+        return `[${value.join(',')}]`;
+    }
+    else if (typeof value === 'object') {
+        return JSON.stringify(value);
+    }
+    else {
+        return value;
+    }
+}
+function formatTargetsAndProjects(projectNames, targets, tasks) {
+    let targetsText = '';
+    let projectsText = '';
+    let dependentTasksText = '';
+    const tasksTargets = new Set();
+    const tasksProjects = new Set();
+    const dependentTasks = new Set();
+    tasks.forEach((task) => {
+        tasksTargets.add(task.target.target);
+        tasksProjects.add(task.target.project);
+        if (!projectNames.includes(task.target.project) ||
+            !targets.includes(task.target.target)) {
+            dependentTasks.add(task);
+        }
+    });
+    targets = targets.filter((t) => tasksTargets.has(t)); // filter out targets that don't exist
+    projectNames = projectNames.filter((p) => tasksProjects.has(p)); // filter out projects that don't exist
+    if (targets.length === 1) {
+        targetsText = `target ${output_1.output.bold(targets[0])}`;
+    }
+    else {
+        targetsText = `targets ${targets.map((t) => output_1.output.bold(t)).join(', ')}`;
+    }
+    if (projectNames.length === 1) {
+        projectsText = `project ${projectNames[0]}`;
+    }
+    else {
+        projectsText = `${projectNames.length} projects`;
+    }
+    if (dependentTasks.size > 0) {
+        dependentTasksText = ` and ${output_1.output.bold(dependentTasks.size)} ${dependentTasks.size === 1 ? 'task' : 'tasks'} ${projectNames.length === 1 ? 'it depends on' : 'they depend on'}`;
+    }
+    return `${targetsText} for ${projectsText}${dependentTasksText}`;
+}

package/src/tasks-runner/life-cycles/invoke-runner-terminal-output-life-cycle.d.ts

@@ -0,0 +1,13 @@
+import { TaskStatus } from '../tasks-runner';
+import type { LifeCycle, TaskResult } from '../life-cycle';
+import { Task } from '../../config/task-graph';
+export declare class InvokeRunnerTerminalOutputLifeCycle implements LifeCycle {
+    private readonly tasks;
+    failedTasks: Task[];
+    cachedTasks: Task[];
+    constructor(tasks: Task[]);
+    startCommand(): void;
+    endCommand(): void;
+    endTasks(taskResults: TaskResult[]): void;
+    printTaskTerminalOutput(task: Task, cacheStatus: TaskStatus, terminalOutput: string): void;
+}

package/src/tasks-runner/life-cycles/invoke-runner-terminal-output-life-cycle.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvokeRunnerTerminalOutputLifeCycle = void 0;
+const output_1 = require("../../utils/output");
+const utils_1 = require("../utils");
+class InvokeRunnerTerminalOutputLifeCycle {
+    constructor(tasks) {
+        this.tasks = tasks;
+        this.failedTasks = [];
+        this.cachedTasks = [];
+    }
+    startCommand() {
+        output_1.output.log({
+            color: 'cyan',
+            title: `Running ${this.tasks.length} tasks:`,
+            bodyLines: this.tasks.map((task) => `- Task ${task.id} ${task.overrides.__overrides_unparsed__.length > 0
+                ? `Overrides: ${task.overrides.__overrides_unparsed__.join(' ')}`
+                : ''}`),
+        });
+        output_1.output.addVerticalSeparatorWithoutNewLines('cyan');
+    }
+    endCommand() {
+        output_1.output.addNewline();
+        const taskIds = this.tasks.map((task) => {
+            const cached = this.cachedTasks.indexOf(task) !== -1;
+            const failed = this.failedTasks.indexOf(task) !== -1;
+            return `- Task ${task.id} ${task.overrides.__overrides_unparsed__.length > 0
+                ? `Overrides: ${task.overrides.__overrides_unparsed__.join(' ')}`
+                : ''} ${cached ? 'CACHED' : ''} ${failed ? 'FAILED' : ''}`;
+        });
+        if (this.failedTasks.length === 0) {
+            output_1.output.addVerticalSeparatorWithoutNewLines('green');
+            output_1.output.success({
+                title: `Successfully ran ${this.tasks.length} tasks:`,
+                bodyLines: taskIds,
+            });
+        }
+        else {
+            output_1.output.addVerticalSeparatorWithoutNewLines('red');
+            output_1.output.error({
+                title: `Ran ${this.tasks.length} tasks:`,
+                bodyLines: taskIds,
+            });
+        }
+    }
+    endTasks(taskResults) {
+        for (let t of taskResults) {
+            if (t.status === 'failure') {
+                this.failedTasks.push(t.task);
+            }
+            else if (t.status === 'local-cache') {
+                this.cachedTasks.push(t.task);
+            }
+            else if (t.status === 'local-cache-kept-existing') {
+                this.cachedTasks.push(t.task);
+            }
+            else if (t.status === 'remote-cache') {
+                this.cachedTasks.push(t.task);
+            }
+        }
+    }
+    printTaskTerminalOutput(task, cacheStatus, terminalOutput) {
+        const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+        output_1.output.logCommandOutput(args.join(' '), cacheStatus, terminalOutput);
+    }
+}
+exports.InvokeRunnerTerminalOutputLifeCycle = InvokeRunnerTerminalOutputLifeCycle;

package/src/tasks-runner/life-cycles/pretty-time.d.ts

@@ -0,0 +1,4 @@
+/**
+ * All credit to https://github.com/jonschlinkert/pretty-time
+ */
+export declare function prettyTime(time: any, smallest?: any, digits?: any): string;

package/src/tasks-runner/life-cycles/pretty-time.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * All credit to https://github.com/jonschlinkert/pretty-time
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyTime = prettyTime;
+const nano = (time) => +time[0] * 1e9 + +time[1];
+const scale = {
+    w: 6048e11,
+    d: 864e11,
+    h: 36e11,
+    m: 6e10,
+    s: 1e9,
+    ms: 1e6,
+    μs: 1e3,
+    ns: 1,
+};
+const regex = {
+    w: /^(w((ee)?k)?s?)$/,
+    d: /^(d(ay)?s?)$/,
+    h: /^(h((ou)?r)?s?)$/,
+    m: /^(min(ute)?s?|m)$/,
+    s: /^((sec(ond)?)s?|s)$/,
+    ms: /^(milli(second)?s?|ms)$/,
+    μs: /^(micro(second)?s?|μs)$/,
+    ns: /^(nano(second)?s?|ns?)$/,
+};
+const isSmallest = function (uom, unit) {
+    return regex[uom].test(unit);
+};
+const round = function (num, digits) {
+    const n = Math.abs(num);
+    return /[0-9]/.test(digits) ? Number(n.toFixed(digits)) : Math.round(n);
+};
+function prettyTime(time, smallest, digits) {
+    const isNumber = /^[0-9]+$/.test(time);
+    if (!isNumber && !Array.isArray(time)) {
+        throw new TypeError('expected an array or number in nanoseconds');
+    }
+    if (Array.isArray(time) && time.length !== 2) {
+        throw new TypeError('expected an array from process.hrtime()');
+    }
+    if (/^[0-9]+$/.test(smallest)) {
+        digits = smallest;
+        smallest = null;
+    }
+    let num = isNumber ? time : nano(time);
+    let res = '';
+    let prev;
+    for (const uom of Object.keys(scale)) {
+        const step = scale[uom];
+        let inc = num / step;
+        if (smallest && isSmallest(uom, smallest)) {
+            inc = round(inc, digits);
+            if (prev && inc === prev / step)
+                --inc;
+            res += inc + uom;
+            return res.trim();
+        }
+        if (inc < 1)
+            continue;
+        if (!smallest) {
+            inc = round(inc, digits);
+            res += inc + uom;
+            return res;
+        }
+        prev = step;
+        inc = Math.floor(inc);
+        num -= inc * step;
+        res += inc + uom + ' ';
+    }
+    return res.trim();
+}

package/src/tasks-runner/life-cycles/static-run-many-terminal-output-life-cycle.d.ts

@@ -0,0 +1,29 @@
+import { TaskStatus } from '../tasks-runner';
+import type { LifeCycle, TaskResult } from '../life-cycle';
+import { Task } from '../../config/task-graph';
+/**
+ * The following life cycle's outputs are static, meaning no previous content
+ * is rewritten or modified as new outputs are added. It is therefore intended
+ * for use in CI environments.
+ *
+ * For the common case of a user executing a command on their local machine,
+ * the dynamic equivalent of this life cycle is usually preferable.
+ */
+export declare class StaticRunManyTerminalOutputLifeCycle implements LifeCycle {
+    private readonly projectNames;
+    private readonly tasks;
+    private readonly args;
+    private readonly taskOverrides;
+    failedTasks: Task[];
+    cachedTasks: Task[];
+    allCompletedTasks: Map<string, Task>;
+    constructor(projectNames: string[], tasks: Task[], args: {
+        targets?: string[];
+        configuration?: string;
+    }, taskOverrides: any);
+    startCommand(): void;
+    endCommand(): void;
+    private skippedTasks;
+    endTasks(taskResults: TaskResult[]): void;
+    printTaskTerminalOutput(task: Task, cacheStatus: TaskStatus, terminalOutput: string): void;
+}

package/src/tasks-runner/life-cycles/static-run-many-terminal-output-life-cycle.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticRunManyTerminalOutputLifeCycle = void 0;
+const output_1 = require("../../utils/output");
+const utils_1 = require("../utils");
+const formatting_utils_1 = require("./formatting-utils");
+/**
+ * The following life cycle's outputs are static, meaning no previous content
+ * is rewritten or modified as new outputs are added. It is therefore intended
+ * for use in CI environments.
+ *
+ * For the common case of a user executing a command on their local machine,
+ * the dynamic equivalent of this life cycle is usually preferable.
+ */
+class StaticRunManyTerminalOutputLifeCycle {
+    constructor(projectNames, tasks, args, taskOverrides) {
+        this.projectNames = projectNames;
+        this.tasks = tasks;
+        this.args = args;
+        this.taskOverrides = taskOverrides;
+        this.failedTasks = [];
+        this.cachedTasks = [];
+        this.allCompletedTasks = new Map();
+    }
+    startCommand() {
+        if (this.tasks.length === 0) {
+            return;
+        }
+        if (this.projectNames.length <= 0) {
+            output_1.output.logSingleLine(`No projects with ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)} were run`);
+            return;
+        }
+        const bodyLines = this.projectNames.map((affectedProject) => `${output_1.output.dim('-')} ${affectedProject}`);
+        if (Object.keys(this.taskOverrides).length > 0) {
+            bodyLines.push('');
+            bodyLines.push(`${output_1.output.dim('With additional flags:')}`);
+            Object.entries(this.taskOverrides)
+                .map(([flag, value]) => (0, formatting_utils_1.formatFlags)('', flag, value))
+                .forEach((arg) => bodyLines.push(arg));
+        }
+        const title = `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)}:`;
+        output_1.output.log({
+            color: 'cyan',
+            title,
+            bodyLines,
+        });
+        output_1.output.addVerticalSeparatorWithoutNewLines('cyan');
+    }
+    endCommand() {
+        output_1.output.addNewline();
+        if (this.tasks.length === 0) {
+            output_1.output.logSingleLine(`No tasks were run`);
+            return;
+        }
+        if (this.failedTasks.length === 0) {
+            output_1.output.addVerticalSeparatorWithoutNewLines('green');
+            const bodyLines = this.cachedTasks.length > 0
+                ? [
+                    output_1.output.dim(`Nx read the output from the cache instead of running the command for ${this.cachedTasks.length} out of ${this.tasks.length} tasks.`),
+                ]
+                : [];
+            output_1.output.success({
+                title: `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)}`,
+                bodyLines,
+            });
+        }
+        else {
+            output_1.output.addVerticalSeparatorWithoutNewLines('red');
+            const bodyLines = [];
+            const skippedTasks = this.skippedTasks();
+            if (skippedTasks.length > 0) {
+                bodyLines.push(output_1.output.dim('Tasks not run because their dependencies failed or --nx-bail=true:'), '', ...skippedTasks.map((task) => `${output_1.output.dim('-')} ${task.id}`), '');
+            }
+            bodyLines.push(output_1.output.dim('Failed tasks:'), '', ...[...this.failedTasks.values()].map((task) => `${output_1.output.dim('-')} ${task.id}`));
+            output_1.output.error({
+                title: `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)} failed`,
+                bodyLines,
+            });
+        }
+    }
+    skippedTasks() {
+        return this.tasks.filter((t) => !this.allCompletedTasks.has(t.id));
+    }
+    endTasks(taskResults) {
+        for (let t of taskResults) {
+            this.allCompletedTasks.set(t.task.id, t.task);
+            if (t.status === 'failure') {
+                this.failedTasks.push(t.task);
+            }
+            else if (t.status === 'local-cache') {
+                this.cachedTasks.push(t.task);
+            }
+            else if (t.status === 'local-cache-kept-existing') {
+                this.cachedTasks.push(t.task);
+            }
+            else if (t.status === 'remote-cache') {
+                this.cachedTasks.push(t.task);
+            }
+        }
+    }
+    printTaskTerminalOutput(task, cacheStatus, terminalOutput) {
+        const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+        output_1.output.logCommandOutput(args.join(' '), cacheStatus, terminalOutput);
+    }
+}
+exports.StaticRunManyTerminalOutputLifeCycle = StaticRunManyTerminalOutputLifeCycle;

package/src/tasks-runner/life-cycles/static-run-one-terminal-output-life-cycle.d.ts

@@ -0,0 +1,28 @@
+import { TaskStatus } from '../tasks-runner';
+import type { LifeCycle, TaskResult } from '../life-cycle';
+import { Task } from '../../config/task-graph';
+/**
+ * The following life cycle's outputs are static, meaning no previous content
+ * is rewritten or modified as new outputs are added. It is therefore intended
+ * for use in CI environments.
+ *
+ * For the common case of a user executing a command on their local machine,
+ * the dynamic equivalent of this life cycle is usually preferable.
+ */
+export declare class StaticRunOneTerminalOutputLifeCycle implements LifeCycle {
+    private readonly initiatingProject;
+    private readonly projectNames;
+    private readonly tasks;
+    private readonly args;
+    failedTasks: Task[];
+    cachedTasks: Task[];
+    constructor(initiatingProject: string, projectNames: string[], tasks: Task[], args: {
+        targets?: string[];
+        configuration?: string;
+        verbose?: boolean;
+    });
+    startCommand(): void;
+    endCommand(): void;
+    endTasks(taskResults: TaskResult[]): void;
+    printTaskTerminalOutput(task: Task, status: TaskStatus, terminalOutput: string): void;
+}