nx 21.0.0 → 21.0.2

package/src/core/graph/styles.js

@@ -1 +1 @@
-"use strict";(self.webpackChunk=self.webpackChunk||[]).push([[869],{5663:()=>{}},s=>{var e;e=5663,s(s.s=e)}]);
+"use strict";(self.webpackChunk=self.webpackChunk||[]).push([[869],{2259:()=>{}},s=>{var e;e=2259,s(s.s=e)}]);

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

@@ -231,7 +231,7 @@ class RunningNodeProcess {
     }
     kill(signal) {
         return new Promise((res, rej) => {
-            if (process.platform === 'win32' || process.platform === 'darwin') {
+            if (process.platform === 'win32') {
                 if (this.childProcess.kill(signal)) {
                     res();
                 }

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

@@ -5,6 +5,7 @@ const child_process_1 = require("child_process");
 const path = require("path");
 const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
 const package_manager_1 = require("../../utils/package-manager");
+const exit_codes_1 = require("../../utils/exit-codes");
 async function default_1(options, context) {
     const pm = (0, package_manager_1.getPackageManagerCommand)();
     try {
@@ -38,11 +39,12 @@ function nodeProcess(command, cwd, env) {
         windowsHide: false,
     });
 }
+let cp;
 async function ptyProcess(command, cwd, env) {
     const terminal = (0, pseudo_terminal_1.createPseudoTerminal)();
     await terminal.init();
     return new Promise((res, rej) => {
-        const cp = terminal.runCommand(command, { cwd, jsEnv: env });
+        cp = terminal.runCommand(command, { cwd, jsEnv: env });
         cp.onExit((code) => {
             if (code === 0) {
                 res();
@@ -56,3 +58,16 @@ async function ptyProcess(command, cwd, env) {
         });
     });
 }
+// TODO: This only works because pseudo terminal registers signal handlers first but we need a service to handle this
+process.on('SIGHUP', () => {
+    cp.kill('SIGHUP');
+    process.exit((0, exit_codes_1.signalToCode)('SIGHUP'));
+});
+process.on('SIGTERM', () => {
+    cp.kill('SIGTERM');
+    process.exit((0, exit_codes_1.signalToCode)('SIGTERM'));
+});
+process.on('SIGINT', () => {
+    cp.kill('SIGINT');
+    process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
+});

package/src/native/index.d.ts

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

package/src/tasks-runner/forked-process-task-runner.d.ts

@@ -37,5 +37,6 @@ export declare class ForkedProcessTaskRunner {
     private forkProcessWithPrefixAndNotTTY;
     private forkProcessDirectOutputCapture;
     private writeTerminalOutput;
+    cleanup(signal?: NodeJS.Signals): void;
     private setupProcessEventListeners;
 }

package/src/tasks-runner/forked-process-task-runner.js

@@ -136,7 +136,7 @@ class ForkedProcessTaskRunner {
             terminalOutput += msg;
         });
         p.onExit((code) => {
-            if (code > 128) {
+            if (!this.tuiEnabled && code > 128) {
                 process.exit(code);
             }
             this.pseudoTerminals.delete(pseudoTerminal);
@@ -233,6 +233,12 @@ class ForkedProcessTaskRunner {
     writeTerminalOutput(outputPath, content) {
         (0, fs_1.writeFileSync)(outputPath, content);
     }
+    cleanup(signal) {
+        this.processes.forEach((p) => {
+            p.kill(signal);
+        });
+        this.cleanUpBatchProcesses();
+    }
     setupProcessEventListeners() {
         const messageHandler = (message) => {
             this.pseudoTerminals.forEach((p) => {
@@ -246,29 +252,26 @@ class ForkedProcessTaskRunner {
         };
         // When the nx process gets a message, it will be sent into the task's process
         process.on('message', messageHandler);
-        const cleanUp = (signal) => {
-            this.processes.forEach((p) => {
-                p.kill(signal);
-            });
-            process.off('message', messageHandler);
-            this.cleanUpBatchProcesses();
-        };
         // Terminate any task processes on exit
         process.once('exit', () => {
-            cleanUp();
+            this.cleanup();
+            process.off('message', messageHandler);
         });
         process.once('SIGINT', () => {
-            cleanUp('SIGTERM');
+            this.cleanup('SIGTERM');
+            process.off('message', messageHandler);
             // we exit here because we don't need to write anything to cache.
             process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
         });
         process.once('SIGTERM', () => {
-            cleanUp('SIGTERM');
+            this.cleanup('SIGTERM');
+            process.off('message', messageHandler);
             // no exit here because we expect child processes to terminate which
             // will store results to the cache and will terminate this process
         });
         process.once('SIGHUP', () => {
-            cleanUp('SIGTERM');
+            this.cleanup('SIGTERM');
+            process.off('message', messageHandler);
             // no exit here because we expect child processes to terminate which
             // will store results to the cache and will terminate this process
         });

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

@@ -38,7 +38,7 @@ export interface LifeCycle {
     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;
+    appendTaskOutput?(taskId: string, output: string, isPtyTask: boolean): void;
     setTaskStatus?(taskId: string, status: NativeTaskStatus): void;
     registerForcedShutdownCallback?(callback: () => void): void;
 }
@@ -55,7 +55,7 @@ export declare class CompositeLifeCycle implements LifeCycle {
     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;
+    appendTaskOutput(taskId: string, output: string, isPtyTask: boolean): void;
     setTaskStatus(taskId: string, status: NativeTaskStatus): void;
     registerForcedShutdownCallback(callback: () => void): void;
 }

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

@@ -81,10 +81,10 @@ class CompositeLifeCycle {
             }
         }
     }
-    appendTaskOutput(taskId, output) {
+    appendTaskOutput(taskId, output, isPtyTask) {
         for (let l of this.lifeCycles) {
             if (l.appendTaskOutput) {
-                l.appendTaskOutput(taskId, output);
+                l.appendTaskOutput(taskId, output, isPtyTask);
             }
         }
     }

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

@@ -26,15 +26,21 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, taskGraph, args,
     const inProgressTasks = new Set();
     const stoppedTasks = new Set();
     const tasksToTerminalOutputs = {};
-    const taskIdsInOrderOfCompletion = [];
+    const tasksToTaskStatus = {};
+    const taskIdsInTheOrderTheyStart = [];
     lifeCycle.startTasks = (tasks) => {
         for (let t of tasks) {
+            tasksToTerminalOutputs[t.id] ??= '';
+            taskIdsInTheOrderTheyStart.push(t.id);
             inProgressTasks.add(t.id);
         }
     };
-    lifeCycle.printTaskTerminalOutput = (task, taskStatus, terminalOutput) => {
-        taskIdsInOrderOfCompletion.push(task.id);
-        tasksToTerminalOutputs[task.id] = { terminalOutput, taskStatus };
+    lifeCycle.appendTaskOutput = (taskId, output) => {
+        tasksToTerminalOutputs[taskId] += output;
+    };
+    // TODO(@AgentEnder): The following 2 methods should be one but will need more refactoring
+    lifeCycle.printTaskTerminalOutput = (task, taskStatus) => {
+        tasksToTaskStatus[task.id] = taskStatus;
     };
     lifeCycle.setTaskStatus = (taskId, taskStatus) => {
         if (taskStatus === 9 /* NativeTaskStatus.Stopped */) {
@@ -103,8 +109,9 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, taskGraph, args,
         let lines = [];
         // 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];
+        for (const taskId of taskIdsInTheOrderTheyStart) {
+            const taskStatus = tasksToTaskStatus[taskId];
+            const terminalOutput = tasksToTerminalOutputs[taskId];
             output_1.output.logCommandOutput(taskId, taskStatus, terminalOutput);
         }
         lines.push(...output_1.output.getVerticalSeparatorLines(failure ? 'red' : 'green'));
@@ -157,9 +164,16 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, taskGraph, args,
     const printRunManySummary = ({ failure, cancelled, }) => {
         console.log('');
         const lines = [''];
-        for (const taskId of taskIdsInOrderOfCompletion) {
-            const { terminalOutput, taskStatus } = tasksToTerminalOutputs[taskId];
-            if (taskStatus === 'failure') {
+        for (const taskId of taskIdsInTheOrderTheyStart) {
+            const taskStatus = tasksToTaskStatus[taskId];
+            const terminalOutput = tasksToTerminalOutputs[taskId];
+            // Task Status is null?
+            if (!taskStatus) {
+                output_1.output.logCommandOutput(taskId, taskStatus, terminalOutput);
+                output_1.output.addNewline();
+                lines.push(`${LEFT_PAD}${output_1.output.colors.cyan(figures.squareSmallFilled)}${SPACER}${output_1.output.colors.gray('nx run ')}${taskId}`);
+            }
+            else if (taskStatus === 'failure') {
                 output_1.output.logCommandOutput(taskId, taskStatus, terminalOutput);
                 output_1.output.addNewline();
                 lines.push(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${output_1.output.colors.gray('nx run ')}${taskId}`);

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

@@ -333,11 +333,14 @@ class TaskOrchestrator {
                     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());
+                        runningTask.onOutput((output) => {
+                            this.options.lifeCycle.appendTaskOutput(task.id, output, true);
+                        });
                     }
                     else {
                         this.options.lifeCycle.registerRunningTaskWithEmptyParser(task.id);
                         runningTask.onOutput((output) => {
-                            this.options.lifeCycle.appendTaskOutput(task.id, output);
+                            this.options.lifeCycle.appendTaskOutput(task.id, output, false);
                         });
                     }
                 }
@@ -391,11 +394,14 @@ class TaskOrchestrator {
                 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());
+                    runningTask.onOutput((output) => {
+                        this.options.lifeCycle.appendTaskOutput(task.id, output, true);
+                    });
                 }
                 else if ('onOutput' in runningTask) {
                     this.options.lifeCycle.registerRunningTaskWithEmptyParser(task.id);
                     runningTask.onOutput((output) => {
-                        this.options.lifeCycle.appendTaskOutput(task.id, output);
+                        this.options.lifeCycle.appendTaskOutput(task.id, output, false);
                     });
                 }
             }
@@ -645,6 +651,7 @@ class TaskOrchestrator {
     }
     // endregion utils
     async cleanup() {
+        this.forkedProcessTaskRunner.cleanup();
         await Promise.all([
             ...Array.from(this.runningContinuousTasks).map(async ([taskId, t]) => {
                 try {