nx 17.0.3 → 17.0.5

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

@@ -9,6 +9,9 @@ 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
@@ -74,7 +77,7 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
         // Create vertical breathing room for cursor position under the pinned footer
         lines.push('');
         for (const line of lines) {
-            output_1.output.overwriteLine(output_1.output.X_PADDING + line);
+            output_1.output.overwriteLine(line);
         }
         pinnedFooterNumLines = lines.length + additionalLines;
         // clear any possible text below the cursor's position
@@ -90,7 +93,7 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
         switch (status) {
             case 'local-cache':
                 writeCompletedTaskResultLine(`${output_1.output.colors.green(figures.tick) +
-                    '  ' +
+                    SPACER +
                     output_1.output.formatCommand(task.id)}  ${output_1.output.dim('[local cache]')}`);
                 if (isVerbose) {
                     writeCommandOutputBlock(tasksToTerminalOutputs[task.id]);
@@ -98,7 +101,7 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
                 break;
             case 'local-cache-kept-existing':
                 writeCompletedTaskResultLine(`${output_1.output.colors.green(figures.tick) +
-                    '  ' +
+                    SPACER +
                     output_1.output.formatCommand(task.id)}  ${output_1.output.dim('[existing outputs match the cache, left as is]')}`);
                 if (isVerbose) {
                     writeCommandOutputBlock(tasksToTerminalOutputs[task.id]);
@@ -106,7 +109,7 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
                 break;
             case 'remote-cache':
                 writeCompletedTaskResultLine(`${output_1.output.colors.green(figures.tick) +
-                    '  ' +
+                    SPACER +
                     output_1.output.formatCommand(task.id)}  ${output_1.output.dim('[remote cache]')}`);
                 if (isVerbose) {
                     writeCommandOutputBlock(tasksToTerminalOutputs[task.id]);
@@ -115,7 +118,7 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
             case 'success': {
                 const timeTakenText = (0, pretty_time_1.prettyTime)(process.hrtime(tasksToProcessStartTimes[task.id]));
                 writeCompletedTaskResultLine(output_1.output.colors.green(figures.tick) +
-                    '  ' +
+                    SPACER +
                     output_1.output.formatCommand(task.id) +
                     output_1.output.dim(` (${timeTakenText})`));
                 if (isVerbose) {
@@ -124,9 +127,10 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
                 break;
             }
             case 'failure':
+                output_1.output.addNewline();
                 output_1.output.addNewline();
                 writeCompletedTaskResultLine(output_1.output.colors.red(figures.cross) +
-                    '  ' +
+                    SPACER +
                     output_1.output.formatCommand(output_1.output.colors.red(task.id)));
                 writeCommandOutputBlock(tasksToTerminalOutputs[task.id]);
                 break;
@@ -143,10 +147,10 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
         const runningTasks = taskRows.filter((row) => row.status === 'running');
         const remainingTasks = totalTasks - totalCompletedTasks;
         if (runningTasks.length > 0) {
-            additionalFooterRows.push(output_1.output.dim(`   ${output_1.output.colors.cyan(figures.arrowRight)}    Executing ${runningTasks.length}/${remainingTasks} remaining tasks${runningTasks.length > 1 ? ' in parallel' : ''}...`));
+            additionalFooterRows.push(output_1.output.dim(`${LEFT_PAD}${output_1.output.colors.cyan(figures.arrowRight)}${SPACER}Executing ${runningTasks.length}/${remainingTasks} remaining tasks${runningTasks.length > 1 ? ' in parallel' : ''}...`));
             additionalFooterRows.push('');
             for (const runningTask of runningTasks) {
-                additionalFooterRows.push(`   ${output_1.output.dim.cyan(cli_spinners_1.dots.frames[currentFrame])}    ${output_1.output.formatCommand(runningTask.task.id)}`);
+                additionalFooterRows.push(`${LEFT_PAD}${output_1.output.dim.cyan(cli_spinners_1.dots.frames[currentFrame])}${SPACER}${output_1.output.formatCommand(runningTask.task.id)}`);
             }
             /**
              * Reduce layout thrashing by ensuring that there is a relatively consistent
@@ -170,21 +174,20 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
             additionalFooterRows.push('');
         }
         if (totalSuccessfulTasks > 0) {
-            additionalFooterRows.push(`   ${output_1.output.colors.green(figures.tick)}    ${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`);
+            additionalFooterRows.push(`${LEFT_PAD}${output_1.output.colors.green(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`);
         }
         if (totalFailedTasks > 0) {
-            additionalFooterRows.push(`   ${output_1.output.colors.red(figures.cross)}    ${totalFailedTasks}${`/${totalCompletedTasks}`} failed`);
+            additionalFooterRows.push(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} failed`);
         }
         moveCursorToStartOfPinnedFooter();
         if (additionalFooterRows.length > 1) {
             const text = `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
             const taskOverridesRows = [];
             if (Object.keys(overrides).length > 0) {
-                const leftPadding = `${output_1.output.X_PADDING}       `;
                 taskOverridesRows.push('');
-                taskOverridesRows.push(`${leftPadding}${output_1.output.dim.cyan('With additional flags:')}`);
+                taskOverridesRows.push(`${EXTENDED_LEFT_PAD}${output_1.output.dim.cyan('With additional flags:')}`);
                 Object.entries(overrides)
-                    .map(([flag, value]) => output_1.output.dim.cyan((0, formatting_utils_1.formatFlags)(leftPadding, flag, value)))
+                    .map(([flag, value]) => output_1.output.dim.cyan((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value)))
                     .forEach((arg) => taskOverridesRows.push(arg));
             }
             const pinnedFooterLines = [
@@ -221,11 +224,10 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
             const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
             const taskOverridesRows = [];
             if (Object.keys(overrides).length > 0) {
-                const leftPadding = `${output_1.output.X_PADDING}       `;
                 taskOverridesRows.push('');
-                taskOverridesRows.push(`${leftPadding}${output_1.output.dim.green('With additional flags:')}`);
+                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)(leftPadding, flag, value)))
+                    .map(([flag, value]) => output_1.output.dim.green((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value)))
                     .forEach((arg) => taskOverridesRows.push(arg));
             }
             const pinnedFooterLines = [
@@ -233,7 +235,7 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
                 ...taskOverridesRows,
             ];
             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.`));
+                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.`));
             }
             renderPinnedFooter(pinnedFooterLines, 'green');
         }
@@ -241,11 +243,10 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
             const text = `Ran ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
             const taskOverridesRows = [];
             if (Object.keys(overrides).length > 0) {
-                const leftPadding = `${output_1.output.X_PADDING}       `;
                 taskOverridesRows.push('');
-                taskOverridesRows.push(`${leftPadding}${output_1.output.dim.red('With additional flags:')}`);
+                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)(leftPadding, flag, value)))
+                    .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;
@@ -254,15 +255,16 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
                 output_1.output.applyNxPrefix('red', output_1.output.colors.red(text) + output_1.output.dim.white(` (${timeTakenText})`)),
                 ...taskOverridesRows,
                 '',
-                output_1.output.dim(`   ${output_1.output.dim(figures.tick)}    ${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`),
+                output_1.output.dim(`${LEFT_PAD}${output_1.output.dim(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`),
+                '',
+                `${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} targets failed, including the following:`,
                 '',
-                `   ${output_1.output.colors.red(figures.cross)}    ${totalFailedTasks}${`/${totalCompletedTasks}`} targets failed, including the following:`,
                 `${failedTasksForPrinting
-                    .map((t) => `        ${output_1.output.colors.red('-')} ${output_1.output.formatCommand(t.toString())}`)
+                    .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(`        ...and ${failedTasks.size - numFailedToPrint} more...`));
+                failureSummaryRows.push(output_1.output.dim(`${EXTENDED_LEFT_PAD}...and ${failedTasks.size - numFailedToPrint} more...`));
             }
             failureSummaryRows.push(...(0, view_logs_utils_1.viewLogsFooterRows)(failedTasks.size));
             renderPinnedFooter(failureSummaryRows, 'red');
@@ -314,8 +316,7 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
 }
 exports.createRunManyDynamicOutputRenderer = createRunManyDynamicOutputRenderer;
 function writeCompletedTaskResultLine(line) {
-    const additionalXPadding = '   ';
-    output_1.output.overwriteLine(output_1.output.X_PADDING + additionalXPadding + line);
+    output_1.output.overwriteLine(LEFT_PAD + line);
 }
 /**
  * There's not much we can do in order to "neaten up" the outputs of
@@ -326,7 +327,6 @@ function writeCompletedTaskResultLine(line) {
 function writeCommandOutputBlock(commandOutput) {
     commandOutput = commandOutput || '';
     commandOutput = commandOutput.trimStart();
-    const additionalXPadding = '      ';
     const lines = commandOutput.split(os_1.EOL);
     let totalTrailingEmptyLines = 0;
     for (let i = lines.length - 1; i >= 0; i--) {
@@ -341,5 +341,5 @@ function writeCommandOutputBlock(commandOutput) {
     }
     lines.push('');
     // Indent the command output to make it look more "designed" in the context of the dynamic output
-    lines.forEach((l) => output_1.output.overwriteLine(`${output_1.output.X_PADDING}${additionalXPadding}${l}`));
+    lines.forEach((l) => output_1.output.overwriteLine(`${EXTENDED_LEFT_PAD}${l}`));
 }

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

@@ -9,6 +9,9 @@ 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
@@ -57,7 +60,7 @@ async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, arg
     const moveCursorToStartOfDependentTargetLines = () => {
         readline.moveCursor(process.stdout, 0, -dependentTargetsNumLines);
     };
-    const renderLines = (lines, dividerColor = 'cyan', renderDivider = true, skipPadding = false) => {
+    const renderLines = (lines, dividerColor = 'cyan', renderDivider = true) => {
         let additionalLines = 0;
         if (renderDivider) {
             const dividerLines = output_1.output.getVerticalSeparatorLines(dividerColor);
@@ -68,7 +71,7 @@ async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, arg
             lines.push('');
         }
         for (const line of lines) {
-            output_1.output.overwriteLine((skipPadding ? '' : output_1.output.X_PADDING) + line);
+            output_1.output.overwriteLine(line);
         }
         dependentTargetsNumLines = lines.length + additionalLines;
         // clear any possible text below the cursor's position
@@ -86,7 +89,7 @@ async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, arg
         switch (state) {
             case 'EXECUTING_DEPENDENT_TARGETS':
                 if (totalFailedTasks === 0) {
-                    linesToRender.push(`   ${output_1.output.colors.cyan(cli_spinners_1.dots.frames[dependentTargetsCurrentFrame])}    ${output_1.output.dim(`Nx is waiting on ${remainingDependentTasksNotFromInitiatingProject} dependent project tasks before running tasks from`)} ${initiatingProject}${output_1.output.dim('...')}`);
+                    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('');
                     }
@@ -94,14 +97,14 @@ async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, arg
                 break;
         }
         if (totalFailedTasks > 0) {
-            linesToRender.push(output_1.output.colors.red.dim(`   ${output_1.output.colors.red(figures.cross)}    ${totalFailedTasks}${`/${totalCompletedTasks}`} dependent project tasks failed (see below)`));
+            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(`   ${output_1.output.dim(figures.tick)}    ${totalSuccessfulTasks}${`/${totalCompletedTasks}`} dependent project tasks succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`));
+            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', true);
+            renderLines(linesToRender, 'gray', renderDivider && state !== 'EXECUTING_DEPENDENT_TARGETS');
         }
         else {
             renderLines([]);
@@ -120,7 +123,7 @@ async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, arg
                 renderDependentTargets(false);
                 if (totalDependentTasksNotFromInitiatingProject > 0) {
                     output_1.output.addNewline();
-                    process.stdout.write(`   ${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);
+                    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');
                 }
             }
@@ -132,9 +135,7 @@ async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, arg
     };
     lifeCycle.printTaskTerminalOutput = (task, cacheStatus, terminalOutput) => {
         if (task.target.project === initiatingProject) {
-            output_1.output.logCommand(task.id, cacheStatus);
-            output_1.output.addNewline();
-            process.stdout.write(terminalOutput);
+            output_1.output.logCommandOutput(task.id, cacheStatus, terminalOutput);
         }
         else {
             tasksToTerminalOutputs[task.id] = terminalOutput;
@@ -163,9 +164,7 @@ async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, arg
                         clearRenderInterval();
                         renderDependentTargets(false);
                         output_1.output.addVerticalSeparator('red');
-                        output_1.output.logCommand(t.task.id, t.status);
-                        output_1.output.addNewline();
-                        process.stdout.write(tasksToTerminalOutputs[t.task.id]);
+                        output_1.output.logCommandOutput(t.task.id, t.status, tasksToTerminalOutputs[t.task.id]);
                     }
                     break;
             }
@@ -180,11 +179,10 @@ async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, arg
             const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)([initiatingProject], [targetName], tasks)}`;
             const taskOverridesLines = [];
             if (Object.keys(overrides).length > 0) {
-                const leftPadding = `${output_1.output.X_PADDING}       `;
                 taskOverridesLines.push('');
-                taskOverridesLines.push(`${leftPadding}${output_1.output.dim.green('With additional flags:')}`);
+                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)(leftPadding, flag, value)))
+                    .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 = [
@@ -192,7 +190,7 @@ async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, arg
                 ...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.`));
+                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');
         }
@@ -204,11 +202,10 @@ async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, arg
             }
             const taskOverridesLines = [];
             if (Object.keys(overrides).length > 0) {
-                const leftPadding = `${output_1.output.X_PADDING}       `;
                 taskOverridesLines.push('');
-                taskOverridesLines.push(`${leftPadding}${output_1.output.dim.red('With additional flags:')}`);
+                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)(leftPadding, flag, value)))
+                    .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);
@@ -216,8 +213,8 @@ async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, arg
                 output_1.output.applyNxPrefix('red', output_1.output.colors.red(text) + output_1.output.dim(` (${timeTakenText})`)),
                 ...taskOverridesLines,
                 '',
-                `   ${output_1.output.colors.red(figures.cross)}    ${totalFailedTasks}${`/${totalCompletedTasks}`} failed`,
-                `   ${output_1.output.dim(figures.tick)}    ${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`,
+                `${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');
         }

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

@@ -9,9 +9,7 @@ class EmptyTerminalOutputLifeCycle {
             cacheStatus === 'failure' ||
             cacheStatus === 'skipped') {
             const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-            output_1.output.logCommand(args.join(' '), cacheStatus);
-            output_1.output.addNewline();
-            process.stdout.write(terminalOutput);
+            output_1.output.logCommandOutput(args.join(' '), cacheStatus, terminalOutput);
         }
     }
 }

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

@@ -61,9 +61,7 @@ class InvokeRunnerTerminalOutputLifeCycle {
     }
     printTaskTerminalOutput(task, cacheStatus, terminalOutput) {
         const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-        output_1.output.logCommand(args.join(' '), cacheStatus);
-        output_1.output.addNewline();
-        process.stdout.write(terminalOutput);
+        output_1.output.logCommandOutput(args.join(' '), cacheStatus, terminalOutput);
     }
 }
 exports.InvokeRunnerTerminalOutputLifeCycle = InvokeRunnerTerminalOutputLifeCycle;

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

@@ -27,7 +27,7 @@ class StaticRunManyTerminalOutputLifeCycle {
             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}`);
+        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:')}`);
@@ -93,9 +93,7 @@ class StaticRunManyTerminalOutputLifeCycle {
     }
     printTaskTerminalOutput(task, cacheStatus, terminalOutput) {
         const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-        output_1.output.logCommand(args.join(' '), cacheStatus);
-        output_1.output.addNewline();
-        process.stdout.write(terminalOutput);
+        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

@@ -19,6 +19,7 @@ export declare class StaticRunOneTerminalOutputLifeCycle implements LifeCycle {
     constructor(initiatingProject: string, projectNames: string[], tasks: Task[], args: {
         targets?: string[];
         configuration?: string;
+        verbose?: boolean;
     });
     startCommand(): void;
     endCommand(): void;

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

@@ -78,13 +78,19 @@ class StaticRunOneTerminalOutputLifeCycle {
         }
     }
     printTaskTerminalOutput(task, status, terminalOutput) {
-        if (status === 'success' ||
+        const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+        if (this.args.verbose ||
+            status === 'success' ||
             status === 'failure' ||
             task.target.project === this.initiatingProject) {
-            const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-            output_1.output.logCommand(args.join(' '), status);
-            output_1.output.addNewline();
-            process.stdout.write(terminalOutput);
+            output_1.output.logCommandOutput(args.join(' '), status, terminalOutput);
+        }
+        else {
+            /**
+             * Do not show the terminal output in the case where it is not the initiating project and verbose is not set,
+             * but still print the command that was run and its status (so that cache hits can still be traced).
+             */
+            output_1.output.logCommandOutput(args.join(' '), status, '');
         }
     }
 }

package/src/tasks-runner/life-cycles/view-logs-utils.js

@@ -7,7 +7,7 @@ const output_1 = require("../../utils/output");
 const VIEW_LOGS_MESSAGE = `Hint: Try "nx view-logs" to get structured, searchable errors logs in your browser.`;
 function viewLogsFooterRows(failedTasks) {
     if (failedTasks >= 2 && !(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
-        return [``, output_1.output.dim(`${output_1.output.X_PADDING} ${VIEW_LOGS_MESSAGE}`)];
+        return [``, output_1.output.dim(` ${VIEW_LOGS_MESSAGE}`)];
     }
     else {
         return [];

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

@@ -0,0 +1,49 @@
+/**
+ * Node IPC is specific to Node, but when spawning child processes in Rust, it won't have IPC.
+ *
+ * Thus, this is a wrapper which is spawned by Rust, which will create a Node IPC channel and pipe it to a ZeroMQ Channel
+ *
+ * Main Nx Process
+ *   * Calls Rust Fork Function
+ *     * `node fork.js`
+ *     * Create a Rust - Node.js Agnostic Channel aka Pseudo IPC Channel
+ *     * This returns RustChildProcess
+ *         * RustChildProcess.onMessage(msg => ());
+ *         * pseudo_ipc_channel.on_message() => tx.send(msg);
+ *   * Node.js Fork Wrapper (fork.js)
+ *     * fork(run-command.js) with `inherit` and `ipc`
+ *         * This will create a Node IPC Channel
+ *     * channel = getPseudoIpcChannel(process.env.NX_IPC_CHANNEL_ID)
+ *     * forkChildProcess.on('message', writeToPseudoIpcChannel)
+ */
+/// <reference types="node" />
+import { Serializable } from 'child_process';
+export interface PseudoIPCMessage {
+    type: 'TO_CHILDREN_FROM_PARENT' | 'TO_PARENT_FROM_CHILDREN' | 'CHILD_READY';
+    id: string | undefined;
+    message: Serializable;
+}
+export declare class PseudoIPCServer {
+    private path;
+    private sockets;
+    private server;
+    private childMessages;
+    constructor(path: string);
+    init(): Promise<void>;
+    private childReadyMap;
+    waitForChildReady(childId: string): Promise<void>;
+    private registerChildMessages;
+    sendMessageToChildren(message: Serializable): void;
+    sendMessageToChild(id: string, message: Serializable): void;
+    onMessageFromChildren(onMessage: (message: Serializable) => void, onClose?: () => void, onError?: (err: Error) => void): void;
+    close(): void;
+}
+export declare class PseudoIPCClient {
+    private path;
+    private socket;
+    constructor(path: string);
+    sendMessageToParent(message: Serializable): void;
+    notifyChildIsReady(id: string): void;
+    onMessageFromParent(forkId: string, onMessage: (message: Serializable) => void, onClose?: () => void, onError?: (err: Error) => void): this;
+    close(): void;
+}

package/src/tasks-runner/pseudo-ipc.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * Node IPC is specific to Node, but when spawning child processes in Rust, it won't have IPC.
+ *
+ * Thus, this is a wrapper which is spawned by Rust, which will create a Node IPC channel and pipe it to a ZeroMQ Channel
+ *
+ * Main Nx Process
+ *   * Calls Rust Fork Function
+ *     * `node fork.js`
+ *     * Create a Rust - Node.js Agnostic Channel aka Pseudo IPC Channel
+ *     * This returns RustChildProcess
+ *         * RustChildProcess.onMessage(msg => ());
+ *         * pseudo_ipc_channel.on_message() => tx.send(msg);
+ *   * Node.js Fork Wrapper (fork.js)
+ *     * fork(run-command.js) with `inherit` and `ipc`
+ *         * This will create a Node IPC Channel
+ *     * channel = getPseudoIpcChannel(process.env.NX_IPC_CHANNEL_ID)
+ *     * forkChildProcess.on('message', writeToPseudoIpcChannel)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PseudoIPCClient = exports.PseudoIPCServer = void 0;
+const net_1 = require("net");
+const consume_messages_from_socket_1 = require("../utils/consume-messages-from-socket");
+class PseudoIPCServer {
+    constructor(path) {
+        this.path = path;
+        this.sockets = new Set();
+        this.childMessages = [];
+        this.childReadyMap = new Map();
+    }
+    init() {
+        return new Promise((res) => {
+            this.server = new net_1.Server((socket) => {
+                this.sockets.add(socket);
+                this.registerChildMessages(socket);
+                socket.on('close', () => {
+                    this.sockets.delete(socket);
+                });
+            });
+            this.server.listen(this.path, () => {
+                res();
+            });
+        });
+    }
+    async waitForChildReady(childId) {
+        return new Promise((res) => {
+            this.childReadyMap.set(childId, res);
+        });
+    }
+    registerChildMessages(socket) {
+        socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(async (rawMessage) => {
+            const { type, message } = JSON.parse(rawMessage);
+            if (type === 'TO_PARENT_FROM_CHILDREN') {
+                for (const childMessage of this.childMessages) {
+                    childMessage.onMessage(message);
+                }
+            }
+            else if (type === 'CHILD_READY') {
+                const childId = message;
+                if (this.childReadyMap.has(childId)) {
+                    this.childReadyMap.get(childId)();
+                }
+            }
+        }));
+        socket.on('close', () => {
+            for (const childMessage of this.childMessages) {
+                childMessage.onClose?.();
+            }
+        });
+        socket.on('error', (err) => {
+            for (const childMessage of this.childMessages) {
+                childMessage.onError?.(err);
+            }
+        });
+    }
+    sendMessageToChildren(message) {
+        this.sockets.forEach((socket) => {
+            socket.write(JSON.stringify({ type: 'TO_CHILDREN_FROM_PARENT', message }));
+            // send EOT to indicate that the message has been fully written
+            socket.write(String.fromCodePoint(4));
+        });
+    }
+    sendMessageToChild(id, message) {
+        this.sockets.forEach((socket) => {
+            socket.write(JSON.stringify({ type: 'TO_CHILDREN_FROM_PARENT', id, message }));
+            socket.write(String.fromCodePoint(4));
+        });
+    }
+    onMessageFromChildren(onMessage, onClose = () => { }, onError = (err) => { }) {
+        this.childMessages.push({
+            onMessage,
+            onClose,
+            onError,
+        });
+    }
+    close() {
+        this.server?.close();
+        this.sockets.forEach((s) => s.destroy());
+    }
+}
+exports.PseudoIPCServer = PseudoIPCServer;
+class PseudoIPCClient {
+    constructor(path) {
+        this.path = path;
+        this.socket = (0, net_1.connect)(this.path);
+    }
+    sendMessageToParent(message) {
+        this.socket.write(JSON.stringify({ type: 'TO_PARENT_FROM_CHILDREN', message }));
+        // send EOT to indicate that the message has been fully written
+        this.socket.write(String.fromCodePoint(4));
+    }
+    notifyChildIsReady(id) {
+        this.socket.write(JSON.stringify({
+            type: 'CHILD_READY',
+            message: id,
+        }));
+        // send EOT to indicate that the message has been fully written
+        this.socket.write(String.fromCodePoint(4));
+    }
+    onMessageFromParent(forkId, onMessage, onClose = () => { }, onError = (err) => { }) {
+        this.socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(async (rawMessage) => {
+            const { id, type, message } = JSON.parse(rawMessage);
+            if (type === 'TO_CHILDREN_FROM_PARENT') {
+                if (id && id === forkId) {
+                    onMessage(message);
+                }
+                else if (id === undefined) {
+                    onMessage(message);
+                }
+            }
+        }));
+        this.socket.on('close', onClose);
+        this.socket.on('error', onError);
+        return this;
+    }
+    close() {
+        this.socket?.destroy();
+    }
+}
+exports.PseudoIPCClient = PseudoIPCClient;

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

@@ -0,0 +1,43 @@
+/// <reference types="node" />
+import { ChildProcess, RustPseudoTerminal } from '../native';
+import { PseudoIPCServer } from './pseudo-ipc';
+import { Serializable } from 'child_process';
+export declare function getPseudoTerminal(skipSupportCheck?: boolean): PseudoTerminal;
+export declare class PseudoTerminal {
+    private rustPseudoTerminal;
+    private pseudoIPCPath;
+    private pseudoIPC;
+    private initialized;
+    static isSupported(): boolean;
+    constructor(rustPseudoTerminal: RustPseudoTerminal);
+    init(): Promise<void>;
+    runCommand(command: string, { cwd, jsEnv, quiet, }?: {
+        cwd?: string;
+        jsEnv?: Record<string, string>;
+        quiet?: boolean;
+    }): PseudoTtyProcess;
+    fork(id: string, script: string, { cwd, jsEnv, quiet, }: {
+        cwd?: string;
+        jsEnv?: Record<string, string>;
+        quiet?: boolean;
+    }): Promise<PseudoTtyProcessWithSend>;
+    sendMessageToChildren(message: Serializable): void;
+    onMessageFromChildren(callback: (message: Serializable) => void): void;
+    private setupProcessListeners;
+    private shutdownPseudoIPC;
+}
+export declare class PseudoTtyProcess {
+    private childProcess;
+    isAlive: boolean;
+    exitCallbacks: any[];
+    constructor(childProcess: ChildProcess);
+    onExit(callback: (code: number) => void): void;
+    onOutput(callback: (message: string) => void): void;
+    kill(): void;
+}
+export declare class PseudoTtyProcessWithSend extends PseudoTtyProcess {
+    private id;
+    private pseudoIpc;
+    constructor(_childProcess: ChildProcess, id: string, pseudoIpc: PseudoIPCServer);
+    send(message: Serializable): void;
+}