@ohos-ports/nx 23.2.1-beta.0 → 23.3.0-beta.0

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

@@ -0,0 +1,603 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeriallyRunningTasks = exports.ParallelRunningTasks = void 0;
+exports.runSingleCommandWithPseudoTerminal = runSingleCommandWithPseudoTerminal;
+const tslib_1 = require("tslib");
+const pc = tslib_1.__importStar(require("picocolors"));
+const child_process_1 = require("child_process");
+const npm_run_path_1 = require("npm-run-path");
+const path_1 = require("path");
+const native_1 = require("../../native");
+const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
+const task_env_1 = require("../../tasks-runner/task-env");
+const task_io_service_1 = require("../../tasks-runner/task-io-service");
+const exit_codes_1 = require("../../utils/exit-codes");
+const output_1 = require("../../utils/output");
+/**
+ * The one place this file puts task output on the terminal.
+ *
+ * Deliberately write-only: recording a chunk and printing it are separate steps
+ * whose ORDER matters at some call sites - the data handlers notify output
+ * listeners between the two - so a helper that bundled them would silently
+ * reorder the terminal write relative to those listeners. What is worth
+ * funnelling is the write itself, because it carries an invariant: anything
+ * reaching the terminal has to go through `cliOutput` or
+ * {@link CLIOutput.atLineStart} goes stale, and `addColorAndPrefix` splits on
+ * newlines without ever appending one, so these chunks routinely end mid-line.
+ */
+function streamChunk(chunk, streamOutput, target = process.stdout) {
+    if (streamOutput) {
+        output_1.output.writeTaskOutputChunk(chunk, target);
+    }
+}
+/**
+ * The non-zero-exit warning, emitted from three call sites that each keep their
+ * output in a different accumulator. Deliberately has no trailing newline, so
+ * whatever prints next has to account for the cursor being mid-line.
+ */
+function commandExitedNonZeroWarning(command) {
+    return `Warning: command "${command}" exited with non-zero status code`;
+}
+class ParallelRunningTasks {
+    constructor(options, context, task) {
+        this.exitCallbacks = [];
+        this.outputCallbacks = [];
+        // Memoized exit so late getResults()/onExit() callers don't hang.
+        this.exited = false;
+        this.exitCode = 0;
+        this.exitTerminalOutput = '';
+        this.childProcesses = options.commands.map((commandConfig) => new RunningNodeProcess(commandConfig, options.color, calculateCwd(options.cwd, context), options.env ?? {}, options.readyWhenStatus, options.streamOutput, options.envFile, task));
+        this.readyWhenStatus = options.readyWhenStatus;
+        this.streamOutput = options.streamOutput;
+        this.run();
+    }
+    async getResults() {
+        if (this.exited) {
+            return { code: this.exitCode, terminalOutput: this.exitTerminalOutput };
+        }
+        return new Promise((res) => {
+            this.onExit((code, terminalOutput) => {
+                res({ code, terminalOutput });
+            });
+        });
+    }
+    onOutput(cb) {
+        this.outputCallbacks.push(cb);
+    }
+    onExit(cb) {
+        if (this.exited) {
+            cb(this.exitCode, this.exitTerminalOutput);
+            return;
+        }
+        this.exitCallbacks.push(cb);
+    }
+    send(message) {
+        for (const childProcess of this.childProcesses) {
+            childProcess.send(message);
+        }
+    }
+    async kill(signal) {
+        await Promise.allSettled(this.childProcesses.map((p) => p.kill(signal)));
+    }
+    emitExit(code, terminalOutput) {
+        if (this.exited)
+            return;
+        this.exited = true;
+        this.exitCode = code;
+        this.exitTerminalOutput = terminalOutput;
+        for (const cb of this.exitCallbacks) {
+            cb(code, terminalOutput);
+        }
+    }
+    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,
+                        result: { code, terminalOutput },
+                    });
+                });
+            })));
+            if (code !== 0) {
+                const warning = commandExitedNonZeroWarning(childProcess.command);
+                terminalOutput += warning;
+                streamChunk(warning, this.streamOutput, process.stderr);
+            }
+            this.emitExit(code, terminalOutput);
+        }
+        else {
+            const runningProcesses = new Set();
+            let hasFailure = false;
+            let failureDetails = null;
+            const terminalOutputs = new Map();
+            await Promise.allSettled(this.childProcesses.map(async (childProcess) => {
+                runningProcesses.add(childProcess);
+                childProcess.onOutput((terminalOutput) => {
+                    for (const cb of this.outputCallbacks) {
+                        cb(terminalOutput);
+                    }
+                });
+                const { code, terminalOutput } = await childProcess.getResults();
+                terminalOutputs.set(childProcess, terminalOutput);
+                if (code !== 0 && !hasFailure) {
+                    hasFailure = true;
+                    failureDetails = { childProcess, code, terminalOutput };
+                    // Immediately terminate all other running processes
+                    this.terminateRemainingProcesses(runningProcesses, childProcess);
+                }
+                runningProcesses.delete(childProcess);
+            }));
+            let terminalOutput = Array.from(terminalOutputs.values()).join('\r\n');
+            if (hasFailure && failureDetails) {
+                // Add failure message
+                const warning = commandExitedNonZeroWarning(failureDetails.childProcess.command);
+                terminalOutput += warning;
+                streamChunk(warning, this.streamOutput, process.stderr);
+                this.emitExit(1, terminalOutput);
+            }
+            else {
+                this.emitExit(0, terminalOutput);
+            }
+        }
+    }
+    terminateRemainingProcesses(runningProcesses, failedProcess) {
+        const processesToTerminate = [...runningProcesses].filter((p) => p !== failedProcess);
+        for (const process of processesToTerminate) {
+            runningProcesses.delete(process);
+            process.kill('SIGTERM').catch(() => { });
+        }
+    }
+}
+exports.ParallelRunningTasks = ParallelRunningTasks;
+class SeriallyRunningTasks {
+    constructor(options, context, tuiEnabled, task) {
+        this.tuiEnabled = tuiEnabled;
+        this.task = task;
+        this.terminalOutputChunks = [];
+        this.currentProcess = null;
+        this.exitCallbacks = [];
+        this.code = 0;
+        this.outputCallbacks = [];
+        // Memoized exit so late getResults()/onExit() callers don't hang.
+        this.exited = false;
+        this.exitTerminalOutput = '';
+        this.run(options, context)
+            .catch((e) => {
+            this.error = e;
+        })
+            .finally(() => {
+            const terminalOutput = this.terminalOutputChunks.join('');
+            this.terminalOutputChunks = [];
+            this.emitExit(terminalOutput);
+        });
+    }
+    emitExit(terminalOutput) {
+        if (this.exited)
+            return;
+        this.exited = true;
+        this.exitTerminalOutput = terminalOutput;
+        for (const cb of this.exitCallbacks) {
+            cb(this.code, terminalOutput);
+        }
+    }
+    getResults() {
+        if (this.exited) {
+            if (this.error) {
+                return Promise.reject(this.error);
+            }
+            return Promise.resolve({
+                code: this.code,
+                terminalOutput: this.exitTerminalOutput,
+            });
+        }
+        return new Promise((res, rej) => {
+            this.onExit((code, terminalOutput) => {
+                if (this.error) {
+                    rej(this.error);
+                }
+                else {
+                    res({ code, terminalOutput });
+                }
+            });
+        });
+    }
+    onExit(cb) {
+        if (this.exited) {
+            cb(this.code, this.exitTerminalOutput);
+            return;
+        }
+        this.exitCallbacks.push(cb);
+    }
+    onOutput(cb) {
+        this.outputCallbacks.push(cb);
+    }
+    send(message) {
+        throw new Error('Not implemented');
+    }
+    kill(signal) {
+        return this.currentProcess?.kill(signal);
+    }
+    async run(options, context) {
+        for (const c of options.commands) {
+            const childProcess = await this.createProcess(c, options.color, calculateCwd(options.cwd, context), options.processEnv ?? options.env ?? {}, this.task, 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.terminalOutputChunks.push(terminalOutput);
+            this.code = code;
+            if (code !== 0) {
+                const warning = commandExitedNonZeroWarning(c.command);
+                streamChunk(warning, options.streamOutput, process.stderr);
+                this.terminalOutputChunks.push(warning);
+                // Stop running commands
+                break;
+            }
+        }
+    }
+    async createProcess(commandConfig, color, cwd, env, task, usePty = true, streamOutput = true, tty, 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 (process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
+            !commandConfig.prefix &&
+            usePty &&
+            pseudo_terminal_1.PseudoTerminal.isSupported()) {
+            const pseudoTerminal = (0, pseudo_terminal_1.createPseudoTerminal)();
+            registerProcessListener(this, pseudoTerminal);
+            const pseudoTtyProcess = await createProcessWithPseudoTty(pseudoTerminal, commandConfig, color, cwd, env, streamOutput, tty, envFile);
+            // Register process for metrics collection (direct run-commands execution)
+            // Skip registration if we're in a forked executor - the fork wrapper already registered
+            const pid = pseudoTtyProcess.getPid();
+            if (pid && !process.env.NX_FORKED_TASK_EXECUTOR) {
+                (0, task_io_service_1.registerTaskProcessStart)(task, pid);
+            }
+            return pseudoTtyProcess;
+        }
+        return new RunningNodeProcess(commandConfig, color, cwd, env, [], streamOutput, envFile, task);
+    }
+}
+exports.SeriallyRunningTasks = SeriallyRunningTasks;
+class RunningNodeProcess {
+    /** This class's writes, funnelled through {@link streamChunk}. */
+    stream(chunk, target = process.stdout) {
+        streamChunk(chunk, this.streamOutput, target);
+    }
+    constructor(commandConfig, color, cwd, env, readyWhenStatus, streamOutput = true, envFile, task) {
+        this.readyWhenStatus = readyWhenStatus;
+        this.streamOutput = streamOutput;
+        this.task = task;
+        this.terminalOutputChunks = [];
+        this.exitCallbacks = [];
+        this.outputCallbacks = [];
+        this.killPromise = null;
+        // Memoized exit so late getResults()/onExit() callers don't hang.
+        this.exited = false;
+        this.exitCode = 0;
+        this.exitTerminalOutput = '';
+        env = processEnv(color, cwd, env, envFile);
+        this.command = commandConfig.command;
+        const header = pc.dim('> ') + commandConfig.command + '\r\n\r\n';
+        this.terminalOutputChunks.push(header);
+        this.stream(header);
+        this.childProcess = (0, child_process_1.spawn)(commandConfig.command, [], {
+            shell: true,
+            detached: process.platform !== 'win32',
+            env,
+            cwd,
+            windowsHide: true,
+            stdio: ['inherit', 'pipe', 'pipe'],
+        });
+        this.closedPromise = new Promise((resolve) => {
+            this.childProcess.on('close', resolve);
+        });
+        this.childProcess.stdout?.setEncoding('utf8');
+        this.childProcess.stderr?.setEncoding('utf8');
+        // Register process for metrics collection
+        // Skip registration if we're in a forked executor - the fork wrapper already registered
+        if (this.childProcess.pid && !process.env.NX_FORKED_TASK_EXECUTOR) {
+            (0, task_io_service_1.registerTaskProcessStart)(this.task, this.childProcess.pid);
+        }
+        this.addListeners(commandConfig);
+    }
+    getResults() {
+        if (this.exited) {
+            return Promise.resolve({
+                code: this.exitCode,
+                terminalOutput: this.exitTerminalOutput,
+            });
+        }
+        return new Promise((res) => {
+            this.onExit((code, terminalOutput) => {
+                res({ code, terminalOutput });
+            });
+        });
+    }
+    onOutput(cb) {
+        this.outputCallbacks.push(cb);
+    }
+    onExit(cb) {
+        if (this.exited) {
+            cb(this.exitCode, this.exitTerminalOutput);
+            return;
+        }
+        this.exitCallbacks.push(cb);
+    }
+    send(message) {
+        this.childProcess.send(message);
+    }
+    emitExit(code, terminalOutput) {
+        if (this.exited)
+            return;
+        this.exited = true;
+        this.exitCode = code;
+        this.exitTerminalOutput = terminalOutput;
+        for (const cb of this.exitCallbacks) {
+            cb(code, terminalOutput);
+        }
+    }
+    kill(signal) {
+        if (this.killPromise)
+            return this.killPromise;
+        if (!this.childProcess.pid)
+            return Promise.resolve();
+        // Cache the promise so concurrent callers (e.g. cleanup() after a
+        // fire-and-forget kill from cleanUpUnneededContinuousTasks) await the
+        // same in-progress operation instead of no-oping.
+        this.killPromise = (0, native_1.killProcessTreeGraceful)(this.childProcess.pid, signal).then(() => 
+        // Wait for stdio drain and close events before the orchestrator
+        // tears down the event loop via process.exit().
+        Promise.race([
+            this.closedPromise,
+            new Promise((resolve) => setTimeout(resolve, 1000)),
+        ]));
+        return this.killPromise;
+    }
+    triggerOutputListeners(output) {
+        for (const cb of this.outputCallbacks) {
+            cb(output);
+        }
+    }
+    addListeners(commandConfig) {
+        // Named handlers so they can be removed when the child exits.
+        // Otherwise each RunningNodeProcess leaks process listeners; with
+        // many run-commands tasks this triggers MaxListenersExceededWarning.
+        const isForked = !!process.env.NX_FORKED_TASK_EXECUTOR;
+        const onProcessExit = () => {
+            if (this.childProcess.pid && !this.killPromise) {
+                (0, native_1.killProcessTree)(this.childProcess.pid);
+            }
+        };
+        const onSigInt = () => {
+            this.kill('SIGTERM');
+        };
+        const onSigTerm = () => {
+            this.kill('SIGTERM');
+        };
+        const onSigHup = () => {
+            this.kill('SIGTERM');
+        };
+        const removeProcessListeners = () => {
+            process.removeListener('exit', onProcessExit);
+            if (isForked) {
+                process.removeListener('SIGINT', onSigInt);
+                process.removeListener('SIGTERM', onSigTerm);
+                process.removeListener('SIGHUP', onSigHup);
+            }
+        };
+        this.childProcess.stdout.setEncoding('utf8');
+        this.childProcess.stderr.setEncoding('utf8');
+        this.childProcess.stdout.on('data', (data) => {
+            const output = addColorAndPrefix(data, commandConfig);
+            this.terminalOutputChunks.push(output);
+            this.triggerOutputListeners(output);
+            this.stream(output);
+            if (this.readyWhenStatus.length && isReady(this.readyWhenStatus, data)) {
+                for (const cb of this.exitCallbacks) {
+                    cb(0, this.terminalOutputChunks.join(''));
+                }
+            }
+        });
+        this.childProcess.stderr.on('data', (err) => {
+            const output = addColorAndPrefix(err, commandConfig);
+            this.terminalOutputChunks.push(output);
+            this.triggerOutputListeners(output);
+            this.stream(output, process.stderr);
+            if (this.readyWhenStatus.length && isReady(this.readyWhenStatus, err)) {
+                for (const cb of this.exitCallbacks) {
+                    cb(1, this.terminalOutputChunks.join(''));
+                }
+            }
+        });
+        this.childProcess.on('error', (err) => {
+            const output = addColorAndPrefix(err.toString(), commandConfig);
+            this.terminalOutputChunks.push(output);
+            this.stream(output, process.stderr);
+            const terminalOutput = this.terminalOutputChunks.join('');
+            this.terminalOutputChunks = [];
+            removeProcessListeners();
+            this.emitExit(1, terminalOutput);
+        });
+        this.childProcess.on('exit', (code, signal) => {
+            if (code === null) {
+                code = (0, exit_codes_1.signalToCode)(signal);
+            }
+            removeProcessListeners();
+            const terminalOutput = this.terminalOutputChunks.join('');
+            this.terminalOutputChunks = [];
+            if (!this.readyWhenStatus.length || isReady(this.readyWhenStatus)) {
+                this.emitExit(code, terminalOutput);
+            }
+            else if (code !== 0) {
+                // Process crashed before readyWhen matched; surface the failure so
+                // awaiters unblock. A clean exit (code 0) is left as-is — a parallel
+                // companion command may still produce the readyWhen output.
+                this.emitExit(code, terminalOutput);
+            }
+        });
+        // Terminate any task processes on exit (sync, last resort).
+        // Skip if graceful kill is already in progress — it tracks cleanup
+        // subprocesses and we must not interfere with them.
+        process.on('exit', onProcessExit);
+        // In the direct path, detached children don't get OS SIGINT (own process
+        // group via setsid); the orchestrator's cleanup() sends SIGTERM via
+        // killProcessTreeGraceful. Signal handlers here are only needed in the
+        // forked path where there's no orchestrator to dispatch signals.
+        if (isForked) {
+            process.on('SIGINT', onSigInt);
+            process.on('SIGTERM', onSigTerm);
+            process.on('SIGHUP', onSigHup);
+        }
+    }
+}
+async function runSingleCommandWithPseudoTerminal(normalized, context, task) {
+    const pseudoTerminal = (0, pseudo_terminal_1.createPseudoTerminal)();
+    const pseudoTtyProcess = await createProcessWithPseudoTty(pseudoTerminal, normalized.commands[0], normalized.color, calculateCwd(normalized.cwd, context), normalized.env, normalized.streamOutput, pseudoTerminal ? normalized.isTTY : false, normalized.envFile);
+    // Register process for metrics collection (direct run-commands execution)
+    // Skip registration if we're in a forked executor - the fork wrapper already registered
+    const pid = pseudoTtyProcess.getPid();
+    if (pid && !process.env.NX_FORKED_TASK_EXECUTOR) {
+        (0, task_io_service_1.registerTaskProcessStart)(task, pid);
+    }
+    registerProcessListener(pseudoTtyProcess, pseudoTerminal);
+    return pseudoTtyProcess;
+}
+async function createProcessWithPseudoTty(pseudoTerminal, commandConfig, color, cwd, env, streamOutput = true, tty, envFile) {
+    return pseudoTerminal.runCommand(commandConfig.command, {
+        cwd,
+        jsEnv: processEnv(color, cwd, env, envFile),
+        quiet: !streamOutput,
+        tty,
+    });
+}
+function addColorAndPrefix(out, config) {
+    if (config.prefix) {
+        out = out
+            .split('\n')
+            .map((l) => {
+            let prefixText = config.prefix;
+            if (config.prefixColor && pc[config.prefixColor]) {
+                prefixText = pc[config.prefixColor](prefixText);
+            }
+            prefixText = pc.bold(prefixText);
+            return l.trim().length > 0 ? `${prefixText} ${l}` : l;
+        })
+            .join('\n');
+    }
+    if (config.color && pc[config.color]) {
+        out = pc[config.color](out);
+    }
+    if (config.bgColor && pc[config.bgColor]) {
+        out = pc[config.bgColor](out);
+    }
+    return out;
+}
+function calculateCwd(cwd, context) {
+    if (!cwd)
+        return context.root;
+    if ((0, path_1.isAbsolute)(cwd))
+        return cwd;
+    return (0, path_1.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}`;
+    }
+    // Don't leak NX_PREFIX_OUTPUT to child processes — the parent
+    // task-orchestrator handles prefixing, not the spawned commands.
+    delete res.NX_PREFIX_OUTPUT;
+    return res;
+}
+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);
+}
+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;
+    }
+}
+let registered = false;
+function registerProcessListener(runningTask, pseudoTerminal) {
+    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);
+        }
+        if ('send' in runningTask) {
+            runningTask.send(message);
+        }
+    });
+    // Terminate any task processes on exit (sync, last resort).
+    // The per-child exit handlers and PseudoTerminal.shutdown() use the
+    // sync killProcessTree for this path. We call kill() here as a
+    // best-effort fallback — it returns a Promise but on 'exit' only
+    // synchronous work runs, so the initial signal is sent but the
+    // grace period won't be awaited. That's acceptable: 'exit' is the
+    // last resort after SIGINT/SIGTERM handlers have already had their
+    // chance to do graceful shutdown.
+    process.on('exit', () => {
+        runningTask.kill();
+    });
+    // In the direct path, the orchestrator handles signal dispatch to children.
+    // These handlers are only needed in the forked path where there's no
+    // orchestrator.
+    if (process.env.NX_FORKED_TASK_EXECUTOR) {
+        process.on('SIGINT', () => {
+            Promise.resolve(runningTask.kill('SIGTERM')).finally(() => {
+                process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
+            });
+        });
+        process.on('SIGTERM', () => {
+            runningTask.kill('SIGTERM');
+        });
+        process.on('SIGHUP', () => {
+            runningTask.kill('SIGTERM');
+        });
+    }
+}