nx 21.0.0-canary.20250205-45d5140 → 21.0.0-canary.20250416-caa26a7

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

@@ -2,25 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LARGE_BUFFER = void 0;
 exports.default = default_1;
+exports.runCommands = runCommands;
 exports.interpolateArgsIntoCommand = interpolateArgsIntoCommand;
-const child_process_1 = require("child_process");
-const path = require("path");
 const yargsParser = require("yargs-parser");
-const npm_run_path_1 = require("npm-run-path");
-const chalk = require("chalk");
+const is_tui_enabled_1 = require("../../tasks-runner/is-tui-enabled");
 const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
-const exit_codes_1 = require("../../utils/exit-codes");
-const task_env_1 = require("../../tasks-runner/task-env");
+const running_tasks_1 = require("./running-tasks");
 exports.LARGE_BUFFER = 1024 * 1000000;
-let pseudoTerminal;
-const childProcesses = new Set();
-function loadEnvVarsFile(path, env = {}) {
-    (0, task_env_1.unloadDotEnvFile)(path, env);
-    const result = (0, task_env_1.loadAndExpandDotEnvFile)(path, env);
-    if (result.error) {
-        throw result.error;
-    }
-}
 const propKeys = [
     'command',
     'commands',
@@ -41,7 +29,14 @@ const propKeys = [
     'tty',
 ];
 async function default_1(options, context) {
-    registerProcessListener();
+    const task = await runCommands(options, context);
+    const results = await task.getResults();
+    return {
+        ...results,
+        success: results.code === 0,
+    };
+}
+async function runCommands(options, context) {
     const normalized = normalizeOptions(options);
     if (normalized.readyWhenStatus.length && !normalized.parallel) {
         throw new Error('ERROR: Bad executor config for run-commands - "readyWhen" can only be used when "parallel=true".');
@@ -50,11 +45,21 @@ async function default_1(options, context) {
         !options.parallel) {
         throw new Error('ERROR: Bad executor config for run-commands - "prefix", "prefixColor", "color" and "bgColor" can only be set when "parallel=true".');
     }
+    const isSingleCommand = normalized.commands.length === 1;
+    const usePseudoTerminal = (isSingleCommand || !options.parallel) && pseudo_terminal_1.PseudoTerminal.isSupported();
+    const isSingleCommandAndCanUsePseudoTerminal = isSingleCommand &&
+        usePseudoTerminal &&
+        process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
+        !normalized.commands[0].prefix &&
+        normalized.usePty;
+    const tuiEnabled = (0, is_tui_enabled_1.isTuiEnabled)();
     try {
-        const result = options.parallel
-            ? await runInParallel(normalized, context)
-            : await runSerially(normalized, context);
-        return result;
+        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.SeriallyRunningTasks(normalized, context, tuiEnabled);
+        return runningTask;
     }
     catch (e) {
         if (process.env.NX_VERBOSE_LOGGING === 'true') {
@@ -63,52 +68,6 @@ async function default_1(options, context) {
         throw new Error(`ERROR: Something went wrong in run-commands - ${e.message}`);
     }
 }
-async function runInParallel(options, context) {
-    const procs = options.commands.map((c) => createProcess(null, c, options.readyWhenStatus, options.color, calculateCwd(options.cwd, context), options.env ?? {}, true, options.usePty, options.streamOutput, options.tty, options.envFile).then((result) => ({
-        result,
-        command: c.command,
-    })));
-    let terminalOutput = '';
-    if (options.readyWhenStatus.length) {
-        const r = await Promise.race(procs);
-        terminalOutput += r.result.terminalOutput;
-        if (!r.result.success) {
-            const output = `Warning: command "${r.command}" exited with non-zero status code`;
-            terminalOutput += output;
-            if (options.streamOutput) {
-                process.stderr.write(output);
-            }
-            return { success: false, terminalOutput };
-        }
-        else {
-            return { success: true, terminalOutput };
-        }
-    }
-    else {
-        const r = await Promise.all(procs);
-        terminalOutput += r.map((f) => f.result.terminalOutput).join('');
-        const failed = r.filter((v) => !v.result.success);
-        if (failed.length > 0) {
-            const output = failed
-                .map((f) => `Warning: command "${f.command}" exited with non-zero status code`)
-                .join('\r\n');
-            terminalOutput += output;
-            if (options.streamOutput) {
-                process.stderr.write(output);
-            }
-            return {
-                success: false,
-                terminalOutput,
-            };
-        }
-        else {
-            return {
-                success: true,
-                terminalOutput,
-            };
-        }
-    }
-}
 function normalizeOptions(options) {
     if (options.readyWhen && typeof options.readyWhen === 'string') {
         options.readyWhenStatus = [
@@ -156,167 +115,6 @@ function normalizeOptions(options) {
     });
     return options;
 }
-async function runSerially(options, context) {
-    pseudoTerminal ??= pseudo_terminal_1.PseudoTerminal.isSupported() ? (0, pseudo_terminal_1.getPseudoTerminal)() : null;
-    let terminalOutput = '';
-    for (const c of options.commands) {
-        const result = await createProcess(pseudoTerminal, c, [], options.color, calculateCwd(options.cwd, context), options.processEnv ?? options.env ?? {}, false, options.usePty, options.streamOutput, options.tty, options.envFile);
-        terminalOutput += result.terminalOutput;
-        if (!result.success) {
-            const output = `Warning: command "${c.command}" exited with non-zero status code`;
-            result.terminalOutput += output;
-            if (options.streamOutput) {
-                process.stderr.write(output);
-            }
-            return { success: false, terminalOutput };
-        }
-    }
-    return { success: true, terminalOutput };
-}
-async function createProcess(pseudoTerminal, commandConfig, readyWhenStatus = [], color, cwd, env, isParallel, usePty = true, streamOutput = true, tty, envFile) {
-    env = processEnv(color, cwd, env, envFile);
-    // The rust runCommand is always a tty, so it will not look nice in parallel and if we need prefixes
-    // currently does not work properly in windows
-    if (pseudoTerminal &&
-        process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
-        !commandConfig.prefix &&
-        readyWhenStatus.length === 0 &&
-        !isParallel &&
-        usePty) {
-        let terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
-        if (streamOutput) {
-            process.stdout.write(terminalOutput);
-        }
-        const cp = pseudoTerminal.runCommand(commandConfig.command, {
-            cwd,
-            jsEnv: env,
-            quiet: !streamOutput,
-            tty,
-        });
-        childProcesses.add(cp);
-        return new Promise((res) => {
-            cp.onOutput((output) => {
-                terminalOutput += output;
-            });
-            cp.onExit((code) => {
-                if (code >= 128) {
-                    process.exit(code);
-                }
-                else {
-                    res({ success: code === 0, terminalOutput });
-                }
-            });
-        });
-    }
-    return nodeProcess(commandConfig, cwd, env, readyWhenStatus, streamOutput);
-}
-function nodeProcess(commandConfig, cwd, env, readyWhenStatus, streamOutput = true) {
-    let terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
-    if (streamOutput) {
-        process.stdout.write(terminalOutput);
-    }
-    return new Promise((res) => {
-        const childProcess = (0, child_process_1.exec)(commandConfig.command, {
-            maxBuffer: exports.LARGE_BUFFER,
-            env,
-            cwd,
-            windowsHide: false,
-        });
-        childProcesses.add(childProcess);
-        childProcess.stdout.on('data', (data) => {
-            const output = addColorAndPrefix(data, commandConfig);
-            terminalOutput += output;
-            if (streamOutput) {
-                process.stdout.write(output);
-            }
-            if (readyWhenStatus.length && isReady(readyWhenStatus, data.toString())) {
-                res({ success: true, terminalOutput });
-            }
-        });
-        childProcess.stderr.on('data', (err) => {
-            const output = addColorAndPrefix(err, commandConfig);
-            terminalOutput += output;
-            if (streamOutput) {
-                process.stderr.write(output);
-            }
-            if (readyWhenStatus.length && isReady(readyWhenStatus, err.toString())) {
-                res({ success: true, terminalOutput });
-            }
-        });
-        childProcess.on('error', (err) => {
-            const ouptput = addColorAndPrefix(err.toString(), commandConfig);
-            terminalOutput += ouptput;
-            if (streamOutput) {
-                process.stderr.write(ouptput);
-            }
-            res({ success: false, terminalOutput });
-        });
-        childProcess.on('exit', (code) => {
-            childProcesses.delete(childProcess);
-            if (!readyWhenStatus.length || isReady(readyWhenStatus)) {
-                res({ success: code === 0, terminalOutput });
-            }
-        });
-    });
-}
-function addColorAndPrefix(out, config) {
-    if (config.prefix) {
-        out = out
-            .split('\n')
-            .map((l) => {
-            let prefixText = config.prefix;
-            if (config.prefixColor && chalk[config.prefixColor]) {
-                prefixText = chalk[config.prefixColor](prefixText);
-            }
-            prefixText = chalk.bold(prefixText);
-            return l.trim().length > 0 ? `${prefixText} ${l}` : l;
-        })
-            .join('\n');
-    }
-    if (config.color && chalk[config.color]) {
-        out = chalk[config.color](out);
-    }
-    if (config.bgColor && chalk[config.bgColor]) {
-        out = chalk[config.bgColor](out);
-    }
-    return out;
-}
-function calculateCwd(cwd, context) {
-    if (!cwd)
-        return context.root;
-    if (path.isAbsolute(cwd))
-        return cwd;
-    return path.join(context.root, cwd);
-}
-/**
- * Env variables are processed in the following order:
- * - env option from executor options
- * - env file from envFile option if provided
- * - local env variables
- */
-function processEnv(color, cwd, envOptionFromExecutor, envFile) {
-    let localEnv = (0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd() });
-    localEnv = {
-        ...process.env,
-        ...localEnv,
-    };
-    if (process.env.NX_LOAD_DOT_ENV_FILES !== 'false' && envFile) {
-        loadEnvVarsFile(envFile, localEnv);
-    }
-    let res = {
-        ...localEnv,
-        ...envOptionFromExecutor,
-    };
-    // need to override PATH to make sure we are using the local node_modules
-    if (localEnv.PATH)
-        res.PATH = localEnv.PATH; // UNIX-like
-    if (localEnv.Path)
-        res.Path = localEnv.Path; // Windows
-    if (color) {
-        res.FORCE_COLOR = `${color}`;
-    }
-    return res;
-}
 function interpolateArgsIntoCommand(command, opts, forwardAllArgs) {
     if (command.indexOf('{args.') > -1) {
         const regex = /{args\.([^}]+)}/g;
@@ -403,60 +201,6 @@ function filterPropKeysFromUnParsedOptions(__unparsed__, parseArgs = {}) {
     }
     return parsedOptions;
 }
-let registered = false;
-function registerProcessListener() {
-    if (registered) {
-        return;
-    }
-    registered = true;
-    // When the nx process gets a message, it will be sent into the task's process
-    process.on('message', (message) => {
-        // this.publisher.publish(message.toString());
-        if (pseudoTerminal) {
-            pseudoTerminal.sendMessageToChildren(message);
-        }
-        childProcesses.forEach((p) => {
-            if ('connected' in p && p.connected) {
-                p.send(message);
-            }
-        });
-    });
-    // Terminate any task processes on exit
-    process.on('exit', () => {
-        childProcesses.forEach((p) => {
-            if ('connected' in p ? p.connected : p.isAlive) {
-                p.kill();
-            }
-        });
-    });
-    process.on('SIGINT', () => {
-        childProcesses.forEach((p) => {
-            if ('connected' in p ? p.connected : p.isAlive) {
-                p.kill('SIGTERM');
-            }
-        });
-        // we exit here because we don't need to write anything to cache.
-        process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
-    });
-    process.on('SIGTERM', () => {
-        childProcesses.forEach((p) => {
-            if ('connected' in p ? p.connected : p.isAlive) {
-                p.kill('SIGTERM');
-            }
-        });
-        // no exit here because we expect child processes to terminate which
-        // will store results to the cache and will terminate this process
-    });
-    process.on('SIGHUP', () => {
-        childProcesses.forEach((p) => {
-            if ('connected' in p ? p.connected : p.isAlive) {
-                p.kill('SIGTERM');
-            }
-        });
-        // no exit here because we expect child processes to terminate which
-        // will store results to the cache and will terminate this process
-    });
-}
 function wrapArgIntoQuotesIfNeeded(arg) {
     if (arg.includes('=')) {
         const [key, value] = arg.split('=');
@@ -474,14 +218,3 @@ function wrapArgIntoQuotesIfNeeded(arg) {
         return arg;
     }
 }
-function isReady(readyWhenStatus = [], data) {
-    if (data) {
-        for (const readyWhenElement of readyWhenStatus) {
-            if (data.toString().indexOf(readyWhenElement.stringToMatch) > -1) {
-                readyWhenElement.found = true;
-                break;
-            }
-        }
-    }
-    return readyWhenStatus.every((readyWhenElement) => readyWhenElement.found);
-}

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

@@ -0,0 +1,40 @@
+import { Serializable } from 'child_process';
+import { ExecutorContext } from '../../config/misc-interfaces';
+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);
+    getResults(): Promise<{
+        code: number;
+        terminalOutput: string;
+    }>;
+    onExit(cb: (code: number, terminalOutput: string) => void): void;
+    send(message: Serializable): void;
+    kill(signal?: NodeJS.Signals | number): Promise<void>;
+    private run;
+}
+export declare class SeriallyRunningTasks implements RunningTask {
+    private readonly tuiEnabled;
+    private terminalOutput;
+    private currentProcess;
+    private exitCallbacks;
+    private code;
+    private error;
+    constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext, tuiEnabled: boolean);
+    getResults(): Promise<{
+        code: number;
+        terminalOutput: string;
+    }>;
+    onExit(cb: (code: number, terminalOutput: string) => void): void;
+    send(message: Serializable): void;
+    kill(signal?: NodeJS.Signals | number): void | Promise<void>;
+    private run;
+    private createProcess;
+}
+export declare function runSingleCommandWithPseudoTerminal(normalized: NormalizedRunCommandsOptions, context: ExecutorContext): Promise<PseudoTtyProcess>;