@depup/nx 22.5.4-depup.0

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

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForkedProcessTaskRunner = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const exit_codes_1 = require("../utils/exit-codes");
+const output_1 = require("../utils/output");
+const strip_indents_1 = require("../utils/strip-indents");
+const batch_messages_1 = require("./batch/batch-messages");
+const process_metrics_service_1 = require("./process-metrics-service");
+const pseudo_terminal_1 = require("./pseudo-terminal");
+const batch_process_1 = require("./running-tasks/batch-process");
+const node_child_process_1 = require("./running-tasks/node-child-process");
+const task_io_service_1 = require("./task-io-service");
+const utils_1 = require("./utils");
+const forkScript = (0, path_1.join)(__dirname, './fork.js');
+const workerPath = (0, path_1.join)(__dirname, './batch/run-batch.js');
+class ForkedProcessTaskRunner {
+    constructor(options, tuiEnabled) {
+        this.options = options;
+        this.tuiEnabled = tuiEnabled;
+        this.cliPath = (0, utils_1.getCliPath)();
+        this.verbose = process.env.NX_VERBOSE_LOGGING === 'true';
+        this.processes = new Set();
+        this.finishedProcesses = new Set();
+        this.pseudoTerminals = new Set();
+    }
+    async init() {
+        this.setupProcessEventListeners();
+    }
+    // TODO: vsavkin delegate terminal output printing
+    async forkProcessForBatch({ id: batchId, executorName, taskGraph: batchTaskGraph }, projectGraph, fullTaskGraph, env) {
+        const count = Object.keys(batchTaskGraph.tasks).length;
+        if (count > 1) {
+            output_1.output.logSingleLine(`Running ${output_1.output.bold(count)} ${output_1.output.bold('tasks')} with ${output_1.output.bold(executorName)}`);
+        }
+        else {
+            const args = (0, utils_1.getPrintableCommandArgsForTask)(Object.values(batchTaskGraph.tasks)[0]);
+            output_1.output.logCommand(args.join(' '));
+        }
+        const p = (0, child_process_1.fork)(workerPath, {
+            stdio: ['inherit', 'pipe', 'pipe', 'ipc'],
+            env: {
+                ...env,
+                NX_FORKED_TASK_EXECUTOR: 'true',
+            },
+        });
+        // Register batch worker process with all tasks
+        if (p.pid) {
+            const taskIds = Object.keys(batchTaskGraph.tasks);
+            (0, process_metrics_service_1.getProcessMetricsService)().registerBatch(batchId, taskIds, p.pid);
+        }
+        const cp = new batch_process_1.BatchProcess(p, executorName);
+        this.processes.add(cp);
+        cp.onExit(() => {
+            this.processes.delete(cp);
+        });
+        // Start the tasks
+        cp.send({
+            type: batch_messages_1.BatchMessageType.RunTasks,
+            executorName,
+            projectGraph,
+            batchTaskGraph,
+            fullTaskGraph,
+        });
+        return cp;
+    }
+    cleanUpBatchProcesses() {
+        if (this.finishedProcesses.size > 0) {
+            this.finishedProcesses.forEach((p) => {
+                p.kill();
+            });
+            this.finishedProcesses.clear();
+        }
+    }
+    async forkProcessLegacy(task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }) {
+        return pipeOutput
+            ? this.forkProcessWithPrefixAndNotTTY(task, {
+                temporaryOutputPath,
+                streamOutput,
+                taskGraph,
+                env,
+            })
+            : this.forkProcessDirectOutputCapture(task, {
+                temporaryOutputPath,
+                streamOutput,
+                taskGraph,
+                env,
+            });
+    }
+    async forkProcess(task, { temporaryOutputPath, streamOutput, taskGraph, env, disablePseudoTerminal, }) {
+        const shouldPrefix = streamOutput &&
+            process.env.NX_PREFIX_OUTPUT === 'true' &&
+            !this.tuiEnabled;
+        // streamOutput would be false if we are running multiple targets
+        // there's no point in running the commands in a pty if we are not streaming the output
+        if (pseudo_terminal_1.PseudoTerminal.isSupported() &&
+            !disablePseudoTerminal &&
+            (this.tuiEnabled || (streamOutput && !shouldPrefix))) {
+            // Use pseudo-terminal for interactive tasks that can support user input
+            return this.forkProcessWithPseudoTerminal(task, {
+                temporaryOutputPath,
+                streamOutput,
+                taskGraph,
+                env,
+            });
+        }
+        else {
+            // Use non-interactive process with piped output
+            // Tradeoff: These tasks cannot support interactivity but can still provide
+            // progressive output to the TUI if it's enabled
+            return this.forkProcessWithPrefixAndNotTTY(task, {
+                temporaryOutputPath,
+                streamOutput,
+                taskGraph,
+                env,
+            });
+        }
+    }
+    async createPseudoTerminal() {
+        // Use the helper to ensure shutdown callbacks are registered
+        const terminal = (0, pseudo_terminal_1.createPseudoTerminal)(true);
+        await terminal.init();
+        terminal.onMessageFromChildren((message) => {
+            process.send(message);
+        });
+        return terminal;
+    }
+    async forkProcessWithPseudoTerminal(task, { temporaryOutputPath, streamOutput, taskGraph, env, }) {
+        const childId = task.id;
+        const pseudoTerminal = await this.createPseudoTerminal();
+        this.pseudoTerminals.add(pseudoTerminal);
+        const p = await pseudoTerminal.fork(childId, forkScript, {
+            cwd: process.cwd(),
+            execArgv: process.execArgv,
+            jsEnv: {
+                ...env,
+                NX_FORKED_TASK_EXECUTOR: 'true',
+            },
+            quiet: !streamOutput,
+            commandLabel: `nx run ${task.id}`,
+        });
+        // Register forked process for metrics collection
+        const pid = p.getPid();
+        if (pid) {
+            (0, task_io_service_1.registerTaskProcessStart)(task.id, pid);
+        }
+        p.send({
+            targetDescription: task.target,
+            overrides: task.overrides,
+            taskGraph,
+            isVerbose: this.verbose,
+        });
+        this.processes.add(p);
+        p.onExit((code, terminalOutput) => {
+            if (!this.tuiEnabled && code > 128) {
+                process.exit(code);
+            }
+            this.pseudoTerminals.delete(pseudoTerminal);
+            this.processes.delete(p);
+            if (!streamOutput) {
+                this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
+            }
+            this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
+        });
+        return p;
+    }
+    forkProcessWithPrefixAndNotTTY(task, { streamOutput, temporaryOutputPath, taskGraph, env, }) {
+        try {
+            const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+            if (streamOutput) {
+                output_1.output.logCommand(args.join(' '));
+            }
+            const p = (0, child_process_1.fork)(this.cliPath, {
+                stdio: ['inherit', 'pipe', 'pipe', 'ipc'],
+                env: {
+                    ...env,
+                    NX_FORKED_TASK_EXECUTOR: 'true',
+                },
+            });
+            // Register forked process for metrics collection
+            if (p.pid) {
+                (0, task_io_service_1.registerTaskProcessStart)(task.id, p.pid);
+            }
+            // Send message to run the executor
+            p.send({
+                targetDescription: task.target,
+                overrides: task.overrides,
+                taskGraph,
+                isVerbose: this.verbose,
+            });
+            const cp = new node_child_process_1.NodeChildProcessWithNonDirectOutput(p, {
+                streamOutput,
+                prefix: task.target.project,
+            });
+            this.processes.add(cp);
+            cp.onExit((code, terminalOutput) => {
+                this.processes.delete(cp);
+                if (!streamOutput) {
+                    this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
+                }
+                this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
+            });
+            return cp;
+        }
+        catch (e) {
+            console.error(e);
+            throw e;
+        }
+    }
+    forkProcessDirectOutputCapture(task, { streamOutput, temporaryOutputPath, taskGraph, env, }) {
+        try {
+            const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+            if (streamOutput) {
+                output_1.output.logCommand(args.join(' '));
+            }
+            const p = (0, child_process_1.fork)(this.cliPath, {
+                stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+                env: {
+                    ...env,
+                    NX_FORKED_TASK_EXECUTOR: 'true',
+                },
+            });
+            // Register forked process for metrics collection
+            if (p.pid) {
+                (0, task_io_service_1.registerTaskProcessStart)(task.id, p.pid);
+            }
+            const cp = new node_child_process_1.NodeChildProcessWithDirectOutput(p, temporaryOutputPath);
+            this.processes.add(cp);
+            // Send message to run the executor
+            p.send({
+                targetDescription: task.target,
+                overrides: task.overrides,
+                taskGraph,
+                isVerbose: this.verbose,
+            });
+            cp.onExit((code, signal) => {
+                this.processes.delete(cp);
+                // we didn't print any output as we were running the command
+                // print all the collected output
+                try {
+                    const terminalOutput = cp.getTerminalOutput();
+                    if (!streamOutput) {
+                        this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
+                    }
+                }
+                catch (e) {
+                    console.log((0, strip_indents_1.stripIndents) `
+              Unable to print terminal output for Task "${task.id}".
+              Task failed with Exit Code ${code} and Signal "${signal}".
+
+              Received error message:
+              ${e.message}
+            `);
+                }
+            });
+            return cp;
+        }
+        catch (e) {
+            console.error(e);
+            throw e;
+        }
+    }
+    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) => {
+                p.sendMessageToChildren(message);
+            });
+            this.processes.forEach((p) => {
+                if ('connected' in p && p.connected && 'send' in p) {
+                    p.send(message);
+                }
+            });
+        };
+        // When the nx process gets a message, it will be sent into the task's process
+        process.on('message', messageHandler);
+        // Terminate any task processes on exit
+        process.once('exit', () => {
+            this.cleanup();
+            process.off('message', messageHandler);
+        });
+        process.once('SIGINT', () => {
+            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', () => {
+            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', () => {
+            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
+        });
+    }
+}
+exports.ForkedProcessTaskRunner = ForkedProcessTaskRunner;

package/src/tasks-runner/init-tasks-runner.d.ts

@@ -0,0 +1,23 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+import { NxArgs } from '../utils/command-line-utils';
+import { Task, TaskGraph } from '../config/task-graph';
+import { LifeCycle, TaskResult } from './life-cycle';
+import type { ProjectGraph } from '../config/project-graph';
+import { RunningTask } from './running-tasks/running-task';
+/**
+ * This function is deprecated. Do not use this
+ * @deprecated This function is deprecated. Do not use this
+ */
+export declare function initTasksRunner(nxArgs: NxArgs): Promise<{
+    invoke: (opts: {
+        tasks: Task[];
+        parallel: number;
+    }) => Promise<{
+        status: NodeJS.Process["exitCode"];
+        taskGraph: TaskGraph;
+        taskResults: Record<string, TaskResult>;
+    }>;
+}>;
+export declare function runDiscreteTasks(tasks: Task[], projectGraph: ProjectGraph, taskGraphForHashing: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Array<Promise<TaskResult[]>>>;
+export declare function runContinuousTasks(tasks: Task[], projectGraph: ProjectGraph, taskGraphForHashing: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Record<string, Promise<RunningTask>>>;
+//# sourceMappingURL=init-tasks-runner.d.ts.map

package/src/tasks-runner/init-tasks-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-tasks-runner.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/tasks-runner/init-tasks-runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAErD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAWvD,OAAO,EAAsB,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAGzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAE5D,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAG3D;;;GAGG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM;mBAS3B;QACnB,KAAK,EAAE,IAAI,EAAE,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;KAClB,KAAG,OAAO,CAAC;QACV,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QACnC,SAAS,EAAE,SAAS,CAAC;QACrB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;KACzC,CAAC;GAoDL;AAqED,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,IAAI,EAAE,EACb,YAAY,EAAE,YAAY,EAC1B,mBAAmB,EAAE,SAAS,EAC9B,MAAM,EAAE,mBAAmB,EAC3B,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,CAsCvC;AAED,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,IAAI,EAAE,EACb,YAAY,EAAE,YAAY,EAC1B,mBAAmB,EAAE,SAAS,EAC9B,MAAM,EAAE,mBAAmB,EAC3B,SAAS,EAAE,SAAS,iDAgBrB"}

package/src/tasks-runner/init-tasks-runner.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initTasksRunner = initTasksRunner;
+exports.runDiscreteTasks = runDiscreteTasks;
+exports.runContinuousTasks = runContinuousTasks;
+const nx_json_1 = require("../config/nx-json");
+const project_graph_1 = require("../project-graph/project-graph");
+const run_command_1 = require("./run-command");
+const invoke_runner_terminal_output_life_cycle_1 = require("./life-cycles/invoke-runner-terminal-output-life-cycle");
+const perf_hooks_1 = require("perf_hooks");
+const utils_1 = require("./utils");
+const dotenv_1 = require("../utils/dotenv");
+const life_cycle_1 = require("./life-cycle");
+const task_orchestrator_1 = require("./task-orchestrator");
+const create_task_hasher_1 = require("../hasher/create-task-hasher");
+const client_1 = require("../daemon/client/client");
+const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
+/**
+ * This function is deprecated. Do not use this
+ * @deprecated This function is deprecated. Do not use this
+ */
+async function initTasksRunner(nxArgs) {
+    perf_hooks_1.performance.mark('init-local');
+    (0, dotenv_1.loadRootEnvFiles)();
+    const nxJson = (0, nx_json_1.readNxJson)();
+    if (nxArgs.verbose) {
+        process.env.NX_VERBOSE_LOGGING = 'true';
+    }
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+    return {
+        invoke: async (opts) => {
+            perf_hooks_1.performance.mark('code-loading:end');
+            // TODO: This polyfills the outputs if someone doesn't pass a task with outputs. Remove this in Nx 20
+            opts.tasks.forEach((t) => {
+                if (!t.outputs) {
+                    t.outputs = (0, utils_1.getOutputs)(projectGraph.nodes, t.target, t.overrides);
+                }
+            });
+            const lifeCycle = new invoke_runner_terminal_output_life_cycle_1.InvokeRunnerTerminalOutputLifeCycle(opts.tasks);
+            const taskGraph = {
+                roots: opts.tasks.map((task) => task.id),
+                tasks: opts.tasks.reduce((acc, task) => {
+                    acc[task.id] = task;
+                    return acc;
+                }, {}),
+                dependencies: opts.tasks.reduce((acc, task) => {
+                    acc[task.id] = [];
+                    return acc;
+                }, {}),
+                continuousDependencies: opts.tasks.reduce((acc, task) => {
+                    acc[task.id] = [];
+                    return acc;
+                }, {}),
+            };
+            const taskResults = await (0, run_command_1.invokeTasksRunner)({
+                tasks: opts.tasks,
+                projectGraph,
+                taskGraph,
+                lifeCycle,
+                nxJson,
+                nxArgs: { ...nxArgs, parallel: opts.parallel },
+                loadDotEnvFiles: true,
+                initiatingProject: null,
+                initiatingTasks: [],
+            });
+            return {
+                status: Object.values(taskResults).some((taskResult) => taskResult.status === 'failure' || taskResult.status === 'skipped')
+                    ? 1
+                    : 0,
+                taskGraph,
+                taskResults,
+            };
+        },
+    };
+}
+async function createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
+    (0, dotenv_1.loadRootEnvFiles)();
+    const invokeRunnerTerminalLifecycle = new invoke_runner_terminal_output_life_cycle_1.InvokeRunnerTerminalOutputLifeCycle(tasks);
+    const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
+    const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
+        ...(0, run_command_1.constructLifeCycles)(invokeRunnerTerminalLifecycle),
+        taskResultsLifecycle,
+        lifeCycle,
+    ]);
+    const { runnerOptions: options } = (0, run_command_1.getRunner)({}, nxJson);
+    let hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, options);
+    const taskGraph = {
+        roots: tasks.map((task) => task.id),
+        tasks: tasks.reduce((acc, task) => {
+            acc[task.id] = task;
+            return acc;
+        }, {}),
+        dependencies: tasks.reduce((acc, task) => {
+            acc[task.id] = [];
+            return acc;
+        }, {}),
+        continuousDependencies: tasks.reduce((acc, task) => {
+            acc[task.id] = [];
+            return acc;
+        }, {}),
+    };
+    const nxArgs = {
+        ...options,
+        parallel: tasks.length,
+        lifeCycle: compositedLifeCycle,
+    };
+    (0, run_command_1.setEnvVarsBasedOnArgs)(nxArgs, true);
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, tasks, projectGraph, taskGraph, nxJson, nxArgs, false, client_1.daemonClient, undefined, taskGraphForHashing);
+    await orchestrator.init();
+    orchestrator.processAllScheduledTasks();
+    return orchestrator;
+}
+async function runDiscreteTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle);
+    let groupId = 0;
+    let nextBatch = orchestrator.nextBatch();
+    let batchResults = [];
+    /**
+     * Set of task ids that were part of batches
+     */
+    const batchTasks = new Set();
+    while (nextBatch) {
+        for (const task in nextBatch.taskGraph.tasks) {
+            batchTasks.add(task);
+        }
+        batchResults.push(orchestrator.applyFromCacheOrRunBatch(true, nextBatch, groupId++));
+        nextBatch = orchestrator.nextBatch();
+    }
+    const taskResults = tasks
+        // Filter out tasks which were not part of batches
+        .filter((task) => !batchTasks.has(task.id))
+        .map((task) => orchestrator
+        .applyFromCacheOrRunTask(true, task, groupId++)
+        .then((r) => [r]));
+    return [...batchResults, ...taskResults];
+}
+async function runContinuousTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle);
+    return tasks.reduce((current, task, index) => {
+        current[task.id] = orchestrator.startContinuousTask(task, index);
+        return current;
+    }, {});
+}

package/src/tasks-runner/is-tui-enabled.d.ts

@@ -0,0 +1,19 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+import { NxArgs } from '../utils/command-line-utils';
+export declare const ORIGINAL_TUI_ENV_VALUE: string;
+/**
+ * @returns If tui is enabled
+ */
+export declare function isTuiEnabled(): boolean;
+/**
+ * Determines if the TUI should be enabled for the current environment.
+ *
+ * **Note:** This function should almost never be called directly. Instead, use the `isTuiEnabled` function.
+ *
+ * @param nxJson `nx.json`
+ * @param nxArgs CLI Flags passed into Nx
+ * @param skipCapabilityCheck Mainly used for unit tests.
+ * @returns `true` if the TUI should be enabled, `false` otherwise.
+ */
+export declare function shouldUseTui(nxJson: NxJsonConfiguration, nxArgs: NxArgs, skipCapabilityCheck?: boolean): boolean;
+//# sourceMappingURL=is-tui-enabled.d.ts.map

package/src/tasks-runner/is-tui-enabled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-tui-enabled.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/tasks-runner/is-tui-enabled.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAIrD,eAAO,MAAM,sBAAsB,QAAqB,CAAC;AAEzD;;GAEG;AACH,wBAAgB,YAAY,YAE3B;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,mBAAmB,EAC3B,MAAM,EAAE,MAAM,EACd,mBAAmB,UAAsD,WAgE1E"}

package/src/tasks-runner/is-tui-enabled.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORIGINAL_TUI_ENV_VALUE = void 0;
+exports.isTuiEnabled = isTuiEnabled;
+exports.shouldUseTui = shouldUseTui;
+const native_1 = require("../native");
+const is_ci_1 = require("../utils/is-ci");
+const logger_1 = require("../utils/logger");
+exports.ORIGINAL_TUI_ENV_VALUE = process.env.NX_TUI;
+/**
+ * @returns If tui is enabled
+ */
+function isTuiEnabled() {
+    return process.env.NX_TUI === 'true';
+}
+/**
+ * Determines if the TUI should be enabled for the current environment.
+ *
+ * **Note:** This function should almost never be called directly. Instead, use the `isTuiEnabled` function.
+ *
+ * @param nxJson `nx.json`
+ * @param nxArgs CLI Flags passed into Nx
+ * @param skipCapabilityCheck Mainly used for unit tests.
+ * @returns `true` if the TUI should be enabled, `false` otherwise.
+ */
+function shouldUseTui(nxJson, nxArgs, skipCapabilityCheck = process.env.NX_TUI_SKIP_CAPABILITY_CHECK === 'true') {
+    // If the current terminal/environment is not capable of displaying the TUI, we don't run it
+    const hasValidSize = process.stdout.columns > 0 && process.stdout.rows > 0;
+    const isCapable = skipCapabilityCheck ||
+        (process.stderr.isTTY && isUnicodeSupported() && hasValidSize);
+    if (typeof nxArgs.tui === 'boolean') {
+        if (nxArgs.tui && !isCapable) {
+            logger_1.logger.warn('Nx Terminal UI was not enabled as it is not supported in this environment.');
+            return false;
+        }
+        return nxArgs.tui;
+    }
+    if (!isCapable) {
+        return false;
+    }
+    if (['static', 'stream', 'stream-without-prefixes', 'dynamic-legacy'].includes(nxArgs.outputStyle)) {
+        // If the user has specified a non-TUI output style, we disable the TUI
+        return false;
+    }
+    if (nxArgs.outputStyle === 'dynamic' || nxArgs.outputStyle === 'tui') {
+        return true;
+    }
+    // The environment variable takes precedence over the nx.json config, but
+    // are lower priority than the CLI args as they are less likely to change
+    // between runs, whereas the CLI args are specified by the user for each run.
+    if (typeof process.env.NX_TUI === 'string') {
+        return process.env.NX_TUI === 'true';
+    }
+    // BELOW THIS LINE ARE "repo specific" checks, instead of "user specific" checks.
+    // "user specific" checks are specified by the current user rather than the repo
+    // settings which are applied for all users of the repo... so they are more specific
+    // and take priority.
+    if (
+    // Interactive TUI doesn't make sense on CI
+    (0, is_ci_1.isCI)() ||
+        // Interactive TUI doesn't make sense in an AI agent context
+        (0, native_1.isAiAgent)() ||
+        // WASM needs further testing
+        native_1.IS_WASM) {
+        return false;
+    }
+    // Respect user config
+    if (typeof nxJson.tui?.enabled === 'boolean') {
+        return Boolean(nxJson.tui?.enabled);
+    }
+    // Default to enabling the TUI if the system is capable of displaying it
+    return true;
+}
+// Credit to https://github.com/sindresorhus/is-unicode-supported/blob/e0373335038856c63034c8eef6ac43ee3827a601/index.js
+function isUnicodeSupported() {
+    const { env } = process;
+    const { TERM, TERM_PROGRAM } = env;
+    if (process.platform !== 'win32') {
+        return TERM !== 'linux'; // Linux console (kernel)
+    }
+    return (Boolean(env.WT_SESSION) || // Windows Terminal
+        Boolean(env.TERMINUS_SUBLIME) || // Terminus (<0.2.27)
+        env.ConEmuTask === '{cmd::Cmder}' || // ConEmu and cmder
+        TERM_PROGRAM === 'Terminus-Sublime' ||
+        TERM_PROGRAM === 'vscode' ||
+        TERM === 'xterm-256color' ||
+        TERM === 'alacritty' ||
+        TERM === 'rxvt-unicode' ||
+        TERM === 'rxvt-unicode-256color' ||
+        env.TERMINAL_EMULATOR === 'JetBrains-JediTerm');
+}

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

@@ -0,0 +1,70 @@
+import { Task } from '../config/task-graph';
+import { BatchInfo, BatchStatus, ExternalObject, TaskStatus as NativeTaskStatus } from '../native';
+import { TaskStatus } from './tasks-runner';
+/**
+ * The result of a completed {@link Task}
+ */
+export interface TaskResult {
+    task: Task;
+    status: TaskStatus;
+    code: number;
+    terminalOutput?: string;
+}
+/**
+ * A map of {@link TaskResult} keyed by the ID of the completed {@link Task}s
+ */
+export type TaskResults = Record<string, TaskResult>;
+export interface TaskMetadata {
+    groupId: number;
+}
+export interface LifeCycle {
+    startCommand?(parallel?: number): void | Promise<void>;
+    endCommand?(): void | Promise<void>;
+    scheduleTask?(task: Task): void | Promise<void>;
+    /**
+     * @deprecated use startTasks
+     *
+     * startTask won't be supported after Nx 14 is released.
+     */
+    startTask?(task: Task): void;
+    /**
+     * @deprecated use endTasks
+     *
+     * endTask won't be supported after Nx 14 is released.
+     */
+    endTask?(task: Task, code: number): void;
+    startTasks?(task: Task[], metadata: TaskMetadata): void | Promise<void>;
+    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, isPtyTask: boolean): void;
+    setTaskStatus?(taskId: string, status: NativeTaskStatus): void;
+    registerForcedShutdownCallback?(callback: () => void): void;
+    setEstimatedTaskTimings?(timings: Record<string, number>): void;
+    registerRunningBatch?(batchId: string, batchInfo: BatchInfo): void;
+    appendBatchOutput?(batchId: string, output: string): void;
+    setBatchStatus?(batchId: string, status: BatchStatus): void;
+}
+export declare class CompositeLifeCycle implements LifeCycle {
+    private readonly lifeCycles;
+    constructor(lifeCycles: LifeCycle[]);
+    startCommand(parallel?: number): Promise<void>;
+    endCommand(): Promise<void>;
+    scheduleTask(task: Task): Promise<void>;
+    startTask(task: Task): void;
+    endTask(task: Task, code: number): void;
+    startTasks(tasks: Task[], metadata: TaskMetadata): Promise<void>;
+    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, isPtyTask: boolean): void;
+    setTaskStatus(taskId: string, status: NativeTaskStatus): void;
+    registerForcedShutdownCallback(callback: () => void): void;
+    setEstimatedTaskTimings(timings: Record<string, number>): void;
+    registerRunningBatch(batchId: string, batchInfo: BatchInfo): void;
+    appendBatchOutput(batchId: string, output: string): void;
+    setBatchStatus(batchId: string, status: BatchStatus): void;
+}
+//# sourceMappingURL=life-cycle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"life-cycle.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/tasks-runner/life-cycle.ts"],"names":[],"mappings":"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"}