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

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

@@ -1,603 +0,0 @@
-"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, taskId) {
-        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, taskId));
-        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, taskId) {
-        this.tuiEnabled = tuiEnabled;
-        this.taskId = taskId;
-        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.taskId, 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, taskId, 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)(taskId, pid);
-            }
-            return pseudoTtyProcess;
-        }
-        return new RunningNodeProcess(commandConfig, color, cwd, env, [], streamOutput, envFile, taskId);
-    }
-}
-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, taskId) {
-        this.readyWhenStatus = readyWhenStatus;
-        this.streamOutput = streamOutput;
-        this.taskId = taskId;
-        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)(taskId, 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, taskId) {
-    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)(taskId, 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');
-        });
-    }
-}