nx 21.0.0-beta.6 → 21.0.0-beta.7

package/src/executors/run-commands/run-commands.impl.d.ts

@@ -1,5 +1,4 @@
 import { ExecutorContext } from '../../config/misc-interfaces';
-import { PseudoTtyProcess } from '../../tasks-runner/pseudo-terminal';
 import { ParallelRunningTasks, SeriallyRunningTasks } from './running-tasks';
 export declare const LARGE_BUFFER: number;
 export type Json = {
@@ -55,5 +54,5 @@ export default function (options: RunCommandsOptions, context: ExecutorContext):
     success: boolean;
     terminalOutput: string;
 }>;
-export declare function runCommands(options: RunCommandsOptions, context: ExecutorContext): Promise<PseudoTtyProcess | ParallelRunningTasks | SeriallyRunningTasks>;
+export declare function runCommands(options: RunCommandsOptions, context: ExecutorContext): Promise<import("../../tasks-runner/pseudo-terminal").PseudoTtyProcess | ParallelRunningTasks | SeriallyRunningTasks>;
 export declare function interpolateArgsIntoCommand(command: string, opts: Pick<NormalizedRunCommandsOptions, 'args' | 'parsedArgs' | '__unparsed__' | 'unknownOptions' | 'unparsedCommandArgs'>, forwardAllArgs: boolean): string;

package/src/executors/run-commands/run-commands.impl.js

@@ -57,7 +57,7 @@ async function runCommands(options, context) {
         const runningTask = isSingleCommandAndCanUsePseudoTerminal
             ? await (0, running_tasks_1.runSingleCommandWithPseudoTerminal)(normalized, context)
             : options.parallel
-                ? new running_tasks_1.ParallelRunningTasks(normalized, context, tuiEnabled)
+                ? new running_tasks_1.ParallelRunningTasks(normalized, context)
                 : new running_tasks_1.SeriallyRunningTasks(normalized, context, tuiEnabled);
         return runningTask;
     }

package/src/executors/run-commands/running-tasks.d.ts

@@ -4,16 +4,17 @@ import { PseudoTtyProcess } from '../../tasks-runner/pseudo-terminal';
 import { RunningTask } from '../../tasks-runner/running-tasks/running-task';
 import { NormalizedRunCommandsOptions } from './run-commands.impl';
 export declare class ParallelRunningTasks implements RunningTask {
-    private readonly tuiEnabled;
     private readonly childProcesses;
     private readyWhenStatus;
     private readonly streamOutput;
     private exitCallbacks;
-    constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext, tuiEnabled: boolean);
+    private outputCallbacks;
+    constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext);
     getResults(): Promise<{
         code: number;
         terminalOutput: string;
     }>;
+    onOutput(cb: (terminalOutput: string) => void): void;
     onExit(cb: (code: number, terminalOutput: string) => void): void;
     send(message: Serializable): void;
     kill(signal?: NodeJS.Signals | number): Promise<void>;
@@ -26,12 +27,14 @@ export declare class SeriallyRunningTasks implements RunningTask {
     private exitCallbacks;
     private code;
     private error;
+    private outputCallbacks;
     constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext, tuiEnabled: boolean);
     getResults(): Promise<{
         code: number;
         terminalOutput: string;
     }>;
     onExit(cb: (code: number, terminalOutput: string) => void): void;
+    onOutput(cb: (terminalOutput: string) => void): void;
     send(message: Serializable): void;
     kill(signal?: NodeJS.Signals | number): void | Promise<void>;
     private run;

package/src/executors/run-commands/running-tasks.js

@@ -12,9 +12,9 @@ const task_env_1 = require("../../tasks-runner/task-env");
 const exit_codes_1 = require("../../utils/exit-codes");
 const run_commands_impl_1 = require("./run-commands.impl");
 class ParallelRunningTasks {
-    constructor(options, context, tuiEnabled) {
-        this.tuiEnabled = tuiEnabled;
+    constructor(options, context) {
         this.exitCallbacks = [];
+        this.outputCallbacks = [];
         this.childProcesses = options.commands.map((commandConfig) => new RunningNodeProcess(commandConfig, options.color, calculateCwd(options.cwd, context), options.env ?? {}, options.readyWhenStatus, options.streamOutput, options.envFile));
         this.readyWhenStatus = options.readyWhenStatus;
         this.streamOutput = options.streamOutput;
@@ -27,6 +27,9 @@ class ParallelRunningTasks {
             });
         });
     }
+    onOutput(cb) {
+        this.outputCallbacks.push(cb);
+    }
     onExit(cb) {
         this.exitCallbacks.push(cb);
     }
@@ -48,6 +51,11 @@ class ParallelRunningTasks {
     async run() {
         if (this.readyWhenStatus.length) {
             let { childProcess, result: { code, terminalOutput }, } = await Promise.race(this.childProcesses.map((childProcess) => new Promise((res) => {
+                childProcess.onOutput((terminalOutput) => {
+                    for (const cb of this.outputCallbacks) {
+                        cb(terminalOutput);
+                    }
+                });
                 childProcess.onExit((code, terminalOutput) => {
                     res({
                         childProcess,
@@ -67,10 +75,18 @@ class ParallelRunningTasks {
             }
         }
         else {
-            const results = await Promise.all(this.childProcesses.map((childProcess) => childProcess.getResults().then((result) => ({
-                childProcess,
-                result,
-            }))));
+            const results = await Promise.all(this.childProcesses.map(async (childProcess) => {
+                childProcess.onOutput((terminalOutput) => {
+                    for (const cb of this.outputCallbacks) {
+                        cb(terminalOutput);
+                    }
+                });
+                const result = await childProcess.getResults();
+                return {
+                    childProcess,
+                    result,
+                };
+            }));
             let terminalOutput = results
                 .map((r) => r.result.terminalOutput)
                 .join('\r\n');
@@ -103,6 +119,7 @@ class SeriallyRunningTasks {
         this.currentProcess = null;
         this.exitCallbacks = [];
         this.code = 0;
+        this.outputCallbacks = [];
         this.run(options, context)
             .catch((e) => {
             this.error = e;
@@ -128,6 +145,9 @@ class SeriallyRunningTasks {
     onExit(cb) {
         this.exitCallbacks.push(cb);
     }
+    onOutput(cb) {
+        this.outputCallbacks.push(cb);
+    }
     send(message) {
         throw new Error('Not implemented');
     }
@@ -138,6 +158,11 @@ class SeriallyRunningTasks {
         for (const c of options.commands) {
             const childProcess = await this.createProcess(c, options.color, calculateCwd(options.cwd, context), options.processEnv ?? options.env ?? {}, options.usePty, options.streamOutput, options.tty, options.envFile);
             this.currentProcess = childProcess;
+            childProcess.onOutput((output) => {
+                for (const cb of this.outputCallbacks) {
+                    cb(output);
+                }
+            });
             let { code, terminalOutput } = await childProcess.getResults();
             this.terminalOutput += terminalOutput;
             this.code = code;
@@ -173,6 +198,7 @@ class RunningNodeProcess {
         this.readyWhenStatus = readyWhenStatus;
         this.terminalOutput = '';
         this.exitCallbacks = [];
+        this.outputCallbacks = [];
         env = processEnv(color, cwd, env, envFile);
         this.command = commandConfig.command;
         this.terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
@@ -194,6 +220,9 @@ class RunningNodeProcess {
             });
         });
     }
+    onOutput(cb) {
+        this.outputCallbacks.push(cb);
+    }
     onExit(cb) {
         this.exitCallbacks.push(cb);
     }
@@ -212,10 +241,16 @@ class RunningNodeProcess {
             });
         });
     }
+    triggerOutputListeners(output) {
+        for (const cb of this.outputCallbacks) {
+            cb(output);
+        }
+    }
     addListeners(commandConfig, streamOutput) {
         this.childProcess.stdout.on('data', (data) => {
             const output = addColorAndPrefix(data, commandConfig);
             this.terminalOutput += output;
+            this.triggerOutputListeners(output);
             if (streamOutput) {
                 process.stdout.write(output);
             }
@@ -229,6 +264,7 @@ class RunningNodeProcess {
         this.childProcess.stderr.on('data', (err) => {
             const output = addColorAndPrefix(err, commandConfig);
             this.terminalOutput += output;
+            this.triggerOutputListeners(output);
             if (streamOutput) {
                 process.stderr.write(output);
             }

package/src/native/index.d.ts

@@ -17,6 +17,8 @@ export declare class AppLifeCycle {
   endCommand(): void
   __init(doneCallback: () => any): void
   registerRunningTask(taskId: string, parserAndWriter: ExternalObject<[ParserArc, WriterArc]>): void
+  registerRunningTaskWithEmptyParser(taskId: string): void
+  appendTaskOutput(taskId: string, output: string): void
   setTaskStatus(taskId: string, status: TaskStatus): void
   registerForcedShutdownCallback(forcedShutdownCallback: () => any): void
   __setCloudMessage(message: string): Promise<void>

package/src/tasks-runner/life-cycle.d.ts

@@ -37,6 +37,8 @@ export interface LifeCycle {
     endTasks?(taskResults: TaskResult[], metadata: TaskMetadata): void | Promise<void>;
     printTaskTerminalOutput?(task: Task, status: TaskStatus, output: string): void;
     registerRunningTask?(taskId: string, parserAndWriter: ExternalObject<[any, any]>): void;
+    registerRunningTaskWithEmptyParser?(taskId: string): void;
+    appendTaskOutput?(taskId: string, output: string): void;
     setTaskStatus?(taskId: string, status: NativeTaskStatus): void;
     registerForcedShutdownCallback?(callback: () => void): void;
 }
@@ -52,6 +54,8 @@ export declare class CompositeLifeCycle implements LifeCycle {
     endTasks(taskResults: TaskResult[], metadata: TaskMetadata): Promise<void>;
     printTaskTerminalOutput(task: Task, status: TaskStatus, output: string): void;
     registerRunningTask(taskId: string, parserAndWriter: ExternalObject<[any, any]>): void;
+    registerRunningTaskWithEmptyParser(taskId: string): void;
+    appendTaskOutput(taskId: string, output: string): void;
     setTaskStatus(taskId: string, status: NativeTaskStatus): void;
     registerForcedShutdownCallback(callback: () => void): void;
 }

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

@@ -74,6 +74,20 @@ class CompositeLifeCycle {
             }
         }
     }
+    registerRunningTaskWithEmptyParser(taskId) {
+        for (let l of this.lifeCycles) {
+            if (l.registerRunningTaskWithEmptyParser) {
+                l.registerRunningTaskWithEmptyParser(taskId);
+            }
+        }
+    }
+    appendTaskOutput(taskId, output) {
+        for (let l of this.lifeCycles) {
+            if (l.appendTaskOutput) {
+                l.appendTaskOutput(taskId, output);
+            }
+        }
+    }
     setTaskStatus(taskId, status) {
         for (let l of this.lifeCycles) {
             if (l.setTaskStatus) {

package/src/tasks-runner/running-tasks/running-task.d.ts

@@ -6,5 +6,6 @@ export declare abstract class RunningTask {
     }>;
     abstract onExit(cb: (code: number) => void): void;
     abstract kill(signal?: NodeJS.Signals | number): Promise<void> | void;
+    abstract onOutput?(cb: (output: string) => void): void;
     abstract send?(message: Serializable): void;
 }

package/src/tasks-runner/task-orchestrator.js

@@ -302,9 +302,17 @@ class TaskOrchestrator {
                 const runningTask = await (0, run_commands_impl_1.runCommands)(runCommandsOptions, {
                     root: workspace_root_1.workspaceRoot, // only root is needed in runCommands
                 });
-                if (this.tuiEnabled && runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
-                    // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
-                    this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+                if (this.tuiEnabled) {
+                    if (runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
+                        // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
+                        this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+                    }
+                    else {
+                        this.options.lifeCycle.registerRunningTaskWithEmptyParser(task.id);
+                        runningTask.onOutput((output) => {
+                            this.options.lifeCycle.appendTaskOutput(task.id, output);
+                        });
+                    }
                 }
                 if (!streamOutput) {
                     if (runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
@@ -352,9 +360,17 @@ class TaskOrchestrator {
         else {
             // cache prep
             const runningTask = await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
-            if (this.tuiEnabled && runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
-                // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
-                this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+            if (this.tuiEnabled) {
+                if (runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
+                    // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
+                    this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+                }
+                else if ('onOutput' in runningTask) {
+                    this.options.lifeCycle.registerRunningTaskWithEmptyParser(task.id);
+                    runningTask.onOutput((output) => {
+                        this.options.lifeCycle.appendTaskOutput(task.id, output);
+                    });
+                }
             }
             return runningTask;
         }

package/src/tasks-runner/utils.js

@@ -374,6 +374,8 @@ function shouldStreamOutput(task, initiatingProject) {
         return false;
     if (process.env.NX_STREAM_OUTPUT === 'true')
         return true;
+    if (process.env.NX_STREAM_OUTPUT === 'false')
+        return false;
     if (longRunningTask(task))
         return true;
     if (task.target.project === initiatingProject)