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

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

@@ -0,0 +1,309 @@
+"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 output_1 = require("../utils/output");
+const prune_task_graph_1 = require("./prune-task-graph");
+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, printsOutput = true) {
+        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, printsOutput, batchId);
+        this.processes.add(cp);
+        cp.onExit(() => {
+            this.processes.delete(cp);
+        });
+        // Start the tasks
+        cp.send({
+            type: batch_messages_1.BatchMessageType.RunTasks,
+            executorName,
+            projectGraph,
+            batchTaskGraph: (0, prune_task_graph_1.pruneTaskGraph)(batchTaskGraph),
+            fullTaskGraph: (0, prune_task_graph_1.pruneTaskGraph)(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, pid);
+        }
+        p.send({
+            targetDescription: task.target,
+            overrides: task.overrides,
+            taskGraph: (0, prune_task_graph_1.pruneTaskGraph)(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, p.pid);
+            }
+            // Send message to run the executor
+            p.send({
+                targetDescription: task.target,
+                overrides: task.overrides,
+                taskGraph: (0, prune_task_graph_1.pruneTaskGraph)(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, 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: (0, prune_task_graph_1.pruneTaskGraph)(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);
+    }
+    async cleanup(signal) {
+        await Promise.all([...this.processes].map((p) => p.kill(signal)));
+        this.cleanUpBatchProcesses();
+    }
+    setupProcessEventListeners() {
+        this.processMessageHandler = (message) => {
+            this.pseudoTerminals.forEach((p) => {
+                p.sendMessageToChildren(message);
+            });
+            this.processes.forEach((p) => {
+                if ('connected' in p && p.connected && 'send' in p) {
+                    p.send(message);
+                }
+            });
+        };
+        this.processExitHandler = () => {
+            this.cleanup();
+            process.off('message', this.processMessageHandler);
+        };
+        // When the nx process gets a message, it will be sent into the task's process
+        process.on('message', this.processMessageHandler);
+        // Terminate any task processes on exit (sync, last resort).
+        // cleanup() is async but the initial signal dispatch is synchronous
+        // (killProcessTreeGraceful snapshots and signals before the async
+        // grace period). The grace period won't complete here, but each
+        // child also has its own sync exit handler as a final fallback.
+        process.once('exit', this.processExitHandler);
+        // No SIGINT/SIGTERM/SIGHUP handlers here. The orchestrator's
+        // setupSignalHandlers() owns signal dispatch and calls FPTR.cleanup()
+        // in the direct path; in the forked path the process is detached
+        // and never receives these signals from the OS.
+    }
+    // Long-lived processes (Nx Cloud agents) create a runner per invocation;
+    // without this each instance stays reachable from `process` forever.
+    // Call only after cleanup(): the exit handler is the last-resort child
+    // kill, so it must not be removed while children may still be alive.
+    removeProcessEventListeners() {
+        process.off('message', this.processMessageHandler);
+        process.off('exit', this.processExitHandler);
+    }
+}
+exports.ForkedProcessTaskRunner = ForkedProcessTaskRunner;

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

@@ -0,0 +1,12 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+import { Task, TaskGraph } from '../config/task-graph';
+import { LifeCycle, TaskResult } from './life-cycle';
+import type { UltracacheConfigurations } from '../native';
+import type { ProjectGraph } from '../config/project-graph';
+import { RunningTask } from './running-tasks/running-task';
+export declare function runDiscreteTasks(tasks: Task[], projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle, 
+/** The set to hash from, e.g. from `importUltracacheConfigurations`; omitted hashes natively. */
+ultracacheConfigurations?: UltracacheConfigurations): Promise<Array<Promise<TaskResult[]>>>;
+export declare function runContinuousTasks(tasks: Task[], projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle, 
+/** The set to hash from, e.g. from `importUltracacheConfigurations`; omitted hashes natively. */
+ultracacheConfigurations?: UltracacheConfigurations): Promise<Record<string, Promise<RunningTask>>>;

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

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDiscreteTasks = runDiscreteTasks;
+exports.runContinuousTasks = runContinuousTasks;
+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 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 shared_running_task_1 = require("./running-tasks/shared-running-task");
+const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
+async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations) {
+    (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, fullTaskGraph, nxJson),
+        taskResultsLifecycle,
+        lifeCycle,
+    ]);
+    const { runnerOptions: options } = (0, run_command_1.getRunner)({}, nxJson);
+    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 hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, options, ultracacheConfigurations);
+    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, 
+    // No argv on this path, so the output-style middleware never ran and both
+    // fields are unset - this always renders `static-failures-only`. `nx.json`'s
+    // `outputStyle` does not reach them; it merges under its own name.
+    nxArgs.specifiedOutputStyle, nxArgs.resolvedOutputStyle ?? 'static-failures-only', fullTaskGraph);
+    await orchestrator.init();
+    orchestrator.processAllScheduledTasks();
+    return orchestrator;
+}
+// Nothing awaits the dispose chains below, so an unhandled rejection would take
+// down a long-lived agent process.
+function logDisposeFailure(e) {
+    console.error('Failed to dispose the task orchestrator:', e);
+}
+async function runDiscreteTasks(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, 
+/** The set to hash from, e.g. from `importUltracacheConfigurations`; omitted hashes natively. */
+ultracacheConfigurations) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations);
+    let groupId = 0;
+    let nextBatch = orchestrator.nextBatch();
+    const 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 discreteTasks = tasks.filter((task) => !batchTasks.has(task.id));
+    // Bulk-resolve every discrete task's cache state in one shot —
+    // single SQL call plus parallel remote retrievals. Batches kicked
+    // off above continue running concurrently while we await this.
+    const cacheHits = await orchestrator.resolveCachedTasks(true, discreteTasks, groupId++);
+    const cacheHitsById = new Map(cacheHits.map((h) => [h.task.id, h]));
+    const taskResults = discreteTasks.map(async (task) => {
+        const hit = cacheHitsById.get(task.id);
+        if (hit)
+            return [hit];
+        return [await orchestrator.runTaskDirectly(true, task, groupId++)];
+    });
+    const results = [...batchResults, ...taskResults];
+    // Callers like Nx Cloud agents create an orchestrator per invocation in a
+    // long-lived process; release its process-level listeners once all tasks
+    // settle, otherwise every invocation's orchestrator stays reachable forever.
+    // Not awaited, so callers keep consuming handles as they settle; the forked
+    // runner's exit handler still reaps children until dispose() runs.
+    Promise.allSettled(results)
+        .then(() => orchestrator.dispose())
+        .catch(logDisposeFailure);
+    return results;
+}
+async function runContinuousTasks(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, 
+/** The set to hash from, e.g. from `importUltracacheConfigurations`; omitted hashes natively. */
+ultracacheConfigurations) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations);
+    const runningTasks = tasks.reduce((current, task, index) => {
+        current[task.id] = orchestrator.startContinuousTask(task, index);
+        return current;
+    }, {});
+    // Unlike runDiscreteTasks, this must resolve at task start: callers keep
+    // the RunningTask handles to kill later, so disposal has to be deferred
+    // until every task actually exits.
+    Promise.allSettled(Object.entries(runningTasks).map(async ([taskId, promise]) => {
+        const runningTask = await promise;
+        // A shared task is owned by another nx process; this orchestrator has
+        // no child to protect for it, so disposal does not wait on it.
+        if (runningTask instanceof shared_running_task_1.SharedRunningTask) {
+            return;
+        }
+        await orchestrator.waitForContinuousTaskExit(taskId);
+    }))
+        .then(() => orchestrator.dispose())
+        .catch(logDisposeFailure);
+    return runningTasks;
+}

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

@@ -0,0 +1,18 @@
+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;

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

@@ -0,0 +1,94 @@
+"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");
+const output_1 = require("../utils/output");
+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 ((0, output_1.isStaticOutputStyle)(nxArgs.specifiedOutputStyle) ||
+        ['summary', 'stream', 'stream-without-prefixes', 'dynamic-legacy'].includes(nxArgs.specifiedOutputStyle)) {
+        // If the user has specified a non-TUI output style, we disable the TUI
+        return false;
+    }
+    if (nxArgs.specifiedOutputStyle === 'dynamic' ||
+        nxArgs.specifiedOutputStyle === '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/dist/src/tasks-runner/legacy-depends-on-warning.d.ts

@@ -0,0 +1,18 @@
+import { TargetDependencyConfig } from '../config/workspace-json-project-json';
+type LegacyValue = 'self' | 'dependencies';
+type LegacyEntry = TargetDependencyConfig & {
+    projects: LegacyValue;
+};
+export interface LegacyDependsOnViolation {
+    index: number;
+    originalEntry: LegacyEntry;
+}
+export interface LegacyDependsOnLocation {
+    ownerTarget?: string;
+    index?: number;
+    legacyViolations?: LegacyDependsOnViolation[];
+}
+export declare function warnLegacyDependsOnMagicString(currentProject: string | undefined, dependencyConfig: TargetDependencyConfig, location: LegacyDependsOnLocation | undefined): void;
+export declare function flushLegacyDependsOnViolations(project: string, ownerTarget: string, violations: LegacyDependsOnViolation[], projectRoot: string | undefined): void;
+export declare function __resetForTests(): void;
+export {};