nx 21.0.0-canary.20250206-8bd0bcd → 21.0.0-canary.20250416-caa26a7

package/src/tasks-runner/task-orchestrator.js

@@ -1,23 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskOrchestrator = void 0;
+exports.getThreadCount = getThreadCount;
 const events_1 = require("events");
-const perf_hooks_1 = require("perf_hooks");
-const path_1 = require("path");
 const fs_1 = require("fs");
+const path_1 = require("path");
+const perf_hooks_1 = require("perf_hooks");
 const run_commands_impl_1 = require("../executors/run-commands/run-commands.impl");
-const forked_process_task_runner_1 = require("./forked-process-task-runner");
-const cache_1 = require("./cache");
-const utils_1 = require("./utils");
-const tasks_schedule_1 = require("./tasks-schedule");
 const hash_task_1 = require("../hasher/hash-task");
-const task_env_1 = require("./task-env");
-const workspace_root_1 = require("../utils/workspace-root");
+const native_1 = require("../native");
+const db_connection_1 = require("../utils/db-connection");
 const output_1 = require("../utils/output");
 const params_1 = require("../utils/params");
+const workspace_root_1 = require("../utils/workspace-root");
+const cache_1 = require("./cache");
+const forked_process_task_runner_1 = require("./forked-process-task-runner");
+const is_tui_enabled_1 = require("./is-tui-enabled");
+const pseudo_terminal_1 = require("./pseudo-terminal");
+const noop_child_process_1 = require("./running-tasks/noop-child-process");
+const task_env_1 = require("./task-env");
+const tasks_schedule_1 = require("./tasks-schedule");
+const utils_1 = require("./utils");
 class TaskOrchestrator {
     // endregion internal state
-    constructor(hasher, initiatingProject, projectGraph, taskGraph, nxJson, options, bail, daemon, outputStyle) {
+    constructor(hasher, initiatingProject, projectGraph, taskGraph, nxJson, options, bail, daemon, outputStyle, taskGraphForHashing = taskGraph) {
         this.hasher = hasher;
         this.initiatingProject = initiatingProject;
         this.projectGraph = projectGraph;
@@ -27,9 +33,12 @@ class TaskOrchestrator {
         this.bail = bail;
         this.daemon = daemon;
         this.outputStyle = outputStyle;
+        this.taskGraphForHashing = taskGraphForHashing;
         this.taskDetails = (0, hash_task_1.getTaskDetails)();
         this.cache = (0, cache_1.getCache)(this.options);
-        this.forkedProcessTaskRunner = new forked_process_task_runner_1.ForkedProcessTaskRunner(this.options);
+        this.tuiEnabled = (0, is_tui_enabled_1.isTuiEnabled)(this.nxJson);
+        this.forkedProcessTaskRunner = new forked_process_task_runner_1.ForkedProcessTaskRunner(this.options, this.tuiEnabled);
+        this.runningTasksService = new native_1.RunningTasksService((0, db_connection_1.getDbConnection)());
         this.tasksSchedule = new tasks_schedule_1.TasksSchedule(this.projectGraph, this.taskGraph, this.options);
         // region internal state
         this.batchEnv = (0, task_env_1.getEnvVariablesForBatchProcess)(this.options.skipNxCache, this.options.captureStderr);
@@ -40,28 +49,47 @@ class TaskOrchestrator {
         this.waitingForTasks = [];
         this.groups = [];
         this.bailed = false;
+        this.runningContinuousTasks = new Map();
+        this.cleaningUp = false;
     }
-    async run() {
+    async init() {
         // Init the ForkedProcessTaskRunner, TasksSchedule, and Cache
         await Promise.all([
             this.forkedProcessTaskRunner.init(),
             this.tasksSchedule.init(),
             'init' in this.cache ? this.cache.init() : null,
         ]);
+    }
+    async run() {
+        await this.init();
         // initial scheduling
         await this.tasksSchedule.scheduleNextTasks();
         perf_hooks_1.performance.mark('task-execution:start');
+        const threadCount = getThreadCount(this.options, this.taskGraph);
         const threads = [];
-        process.stdout.setMaxListeners(this.options.parallel + events_1.defaultMaxListeners);
-        process.stderr.setMaxListeners(this.options.parallel + events_1.defaultMaxListeners);
+        process.stdout.setMaxListeners(threadCount + events_1.defaultMaxListeners);
+        process.stderr.setMaxListeners(threadCount + events_1.defaultMaxListeners);
         // initial seeding of the queue
-        for (let i = 0; i < this.options.parallel; ++i) {
+        for (let i = 0; i < threadCount; ++i) {
             threads.push(this.executeNextBatchOfTasksUsingTaskSchedule());
         }
-        await Promise.all(threads);
+        await Promise.race([
+            Promise.all(threads),
+            ...(this.tuiEnabled
+                ? [
+                    new Promise((resolve) => {
+                        this.options.lifeCycle.registerForcedShutdownCallback(() => {
+                            // The user force quit the TUI with ctrl+c, so proceed onto cleanup
+                            resolve(undefined);
+                        });
+                    }),
+                ]
+                : []),
+        ]);
         perf_hooks_1.performance.mark('task-execution:end');
         perf_hooks_1.performance.measure('task-execution', 'task-execution:start', 'task-execution:end');
         this.cache.removeOldCacheRecords();
+        await this.cleanup();
         return this.completedTasks;
     }
     async executeNextBatchOfTasksUsingTaskSchedule() {
@@ -82,7 +110,12 @@ class TaskOrchestrator {
         const task = this.tasksSchedule.nextTask();
         if (task) {
             const groupId = this.closeGroup();
-            await this.applyFromCacheOrRunTask(doNotSkipCache, task, groupId);
+            if (task.continuous) {
+                await this.startContinuousTask(task, groupId);
+            }
+            else {
+                await this.applyFromCacheOrRunTask(doNotSkipCache, task, groupId);
+            }
             this.openGroup(groupId);
             return this.executeNextBatchOfTasksUsingTaskSchedule();
         }
@@ -90,11 +123,11 @@ class TaskOrchestrator {
         return new Promise((res) => this.waitingForTasks.push(res)).then(() => this.executeNextBatchOfTasksUsingTaskSchedule());
     }
     // region Processing Scheduled Tasks
-    async processScheduledTask(taskId) {
+    async processTask(taskId) {
         const task = this.taskGraph.tasks[taskId];
         const taskSpecificEnv = (0, task_env_1.getTaskSpecificEnv)(task);
         if (!task.hash) {
-            await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, taskSpecificEnv, this.taskDetails);
+            await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraphForHashing, task, taskSpecificEnv, this.taskDetails);
         }
         await this.options.lifeCycle.scheduleTask(task);
         return taskSpecificEnv;
@@ -102,7 +135,7 @@ class TaskOrchestrator {
     async processScheduledBatch(batch) {
         await Promise.all(Object.values(batch.taskGraph.tasks).map(async (task) => {
             if (!task.hash) {
-                await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, this.batchEnv, this.taskDetails);
+                await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraphForHashing, task, this.batchEnv, this.taskDetails);
             }
             await this.options.lifeCycle.scheduleTask(task);
         }));
@@ -115,7 +148,7 @@ class TaskOrchestrator {
         for (const taskId of scheduledTasks) {
             // Task is already handled or being handled
             if (!this.processedTasks.has(taskId)) {
-                this.processedTasks.set(taskId, this.processScheduledTask(taskId));
+                this.processedTasks.set(taskId, this.processTask(taskId));
             }
         }
     }
@@ -131,7 +164,12 @@ class TaskOrchestrator {
         if (!cachedResult || cachedResult.code !== 0)
             return null;
         const outputs = task.outputs;
-        const shouldCopyOutputsFromCache = !!outputs.length &&
+        const shouldCopyOutputsFromCache = 
+        // No output files to restore
+        !!outputs.length &&
+            // Remote caches are restored to output dirs when applied and using db cache
+            (!cachedResult.remote || !(0, cache_1.dbCacheEnabled)(this.nxJson)) &&
+            // Output files have not been touched since last run
             (await this.shouldCopyOutputsFromCache(outputs, task.hash));
         if (shouldCopyOutputsFromCache) {
             await this.cache.copyFilesFromCache(task.hash, cachedResult, outputs);
@@ -143,6 +181,7 @@ class TaskOrchestrator {
                 : 'local-cache-kept-existing';
         this.options.lifeCycle.printTaskTerminalOutput(task, status, cachedResult.terminalOutput);
         return {
+            code: cachedResult.code,
             task,
             status,
         };
@@ -166,6 +205,7 @@ class TaskOrchestrator {
             results.push(...batchResults);
         }
         await this.postRunSteps(tasks, results, doNotSkipCache, { groupId });
+        this.forkedProcessTaskRunner.cleanUpBatchProcesses();
         const tasksCompleted = taskEntries.filter(([taskId]) => this.completedTasks[taskId]);
         // Batch is still not done, run it again
         if (tasksCompleted.length !== taskEntries.length) {
@@ -177,7 +217,8 @@ class TaskOrchestrator {
     }
     async runBatch(batch, env) {
         try {
-            const results = await this.forkedProcessTaskRunner.forkProcessForBatch(batch, this.taskGraph, env);
+            const batchProcess = await this.forkedProcessTaskRunner.forkProcessForBatch(batch, this.projectGraph, this.taskGraph, env);
+            const results = await batchProcess.getResults();
             const batchResultEntries = Object.entries(results);
             return batchResultEntries.map(([taskId, result]) => ({
                 ...result,
@@ -217,88 +258,112 @@ class TaskOrchestrator {
         let results = doNotSkipCache ? await this.applyCachedResults([task]) : [];
         // the task wasn't cached
         if (results.length === 0) {
-            const shouldPrefix = streamOutput && process.env.NX_PREFIX_OUTPUT === 'true';
-            const targetConfiguration = (0, utils_1.getTargetConfigurationForTask)(task, this.projectGraph);
-            if (process.env.NX_RUN_COMMANDS_DIRECTLY !== 'false' &&
-                targetConfiguration.executor === 'nx:run-commands' &&
-                !shouldPrefix) {
-                try {
-                    const { schema } = (0, utils_1.getExecutorForTask)(task, this.projectGraph);
-                    const isRunOne = this.initiatingProject != null;
-                    const combinedOptions = (0, params_1.combineOptionsForExecutor)(task.overrides, task.target.configuration ??
-                        targetConfiguration.defaultConfiguration, targetConfiguration, schema, task.target.project, (0, path_1.relative)(task.projectRoot ?? workspace_root_1.workspaceRoot, process.cwd()), process.env.NX_VERBOSE_LOGGING === 'true');
-                    if (combinedOptions.env) {
-                        env = {
-                            ...env,
-                            ...combinedOptions.env,
-                        };
-                    }
-                    if (streamOutput) {
-                        const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-                        output_1.output.logCommand(args.join(' '));
-                    }
-                    const { success, terminalOutput } = await (0, run_commands_impl_1.default)({
-                        ...combinedOptions,
-                        env,
-                        usePty: isRunOne && !this.tasksSchedule.hasTasks(),
-                        streamOutput,
-                    }, {
-                        root: workspace_root_1.workspaceRoot, // only root is needed in runCommandsImpl
-                    });
-                    const status = success ? 'success' : 'failure';
-                    if (!streamOutput) {
-                        this.options.lifeCycle.printTaskTerminalOutput(task, status, terminalOutput);
-                    }
-                    (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
-                    results.push({
-                        task,
-                        status,
-                        terminalOutput,
-                    });
+            const childProcess = await this.runTask(task, streamOutput, env, temporaryOutputPath, pipeOutput);
+            const { code, terminalOutput } = await childProcess.getResults();
+            results.push({
+                task,
+                code,
+                status: code === 0 ? 'success' : 'failure',
+                terminalOutput,
+            });
+        }
+        await this.postRunSteps([task], results, doNotSkipCache, { groupId });
+        return results[0];
+    }
+    async runTask(task, streamOutput, env, temporaryOutputPath, pipeOutput) {
+        const shouldPrefix = streamOutput && process.env.NX_PREFIX_OUTPUT === 'true';
+        const targetConfiguration = (0, utils_1.getTargetConfigurationForTask)(task, this.projectGraph);
+        if (process.env.NX_RUN_COMMANDS_DIRECTLY !== 'false' &&
+            targetConfiguration.executor === 'nx:run-commands' &&
+            !shouldPrefix) {
+            try {
+                const { schema } = (0, utils_1.getExecutorForTask)(task, this.projectGraph);
+                const combinedOptions = (0, params_1.combineOptionsForExecutor)(task.overrides, task.target.configuration ?? targetConfiguration.defaultConfiguration, targetConfiguration, schema, task.target.project, (0, path_1.relative)(task.projectRoot ?? workspace_root_1.workspaceRoot, process.cwd()), process.env.NX_VERBOSE_LOGGING === 'true');
+                if (combinedOptions.env) {
+                    env = {
+                        ...env,
+                        ...combinedOptions.env,
+                    };
+                }
+                if (streamOutput) {
+                    const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+                    output_1.output.logCommand(args.join(' '));
+                }
+                const runCommandsOptions = {
+                    ...combinedOptions,
+                    env,
+                    usePty: this.tuiEnabled ||
+                        (!this.tasksSchedule.hasTasks() &&
+                            this.runningContinuousTasks.size === 0),
+                    streamOutput,
+                };
+                const runningTask = await (0, run_commands_impl_1.runCommands)(runCommandsOptions, {
+                    root: workspace_root_1.workspaceRoot, // only root is needed in runCommands
+                });
+                if (this.tuiEnabled && runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
+                    // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
+                    this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
                 }
-                catch (e) {
-                    if (process.env.NX_VERBOSE_LOGGING === 'true') {
-                        console.error(e);
+                if (!streamOutput) {
+                    if (runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
+                        // TODO: shouldn't this be checking if the task is continuous before writing anything to disk or calling printTaskTerminalOutput?
+                        let terminalOutput = '';
+                        runningTask.onOutput((data) => {
+                            terminalOutput += data;
+                        });
+                        runningTask.onExit((code) => {
+                            this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
+                            (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
+                        });
                     }
                     else {
-                        console.error(e.message);
+                        runningTask.onExit((code, terminalOutput) => {
+                            this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
+                            (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
+                        });
                     }
-                    const terminalOutput = e.stack ?? e.message ?? '';
-                    (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
-                    results.push({
-                        task,
-                        status: 'failure',
-                        terminalOutput,
-                    });
                 }
+                return runningTask;
             }
-            else if (targetConfiguration.executor === 'nx:noop') {
-                (0, fs_1.writeFileSync)(temporaryOutputPath, '');
-                results.push({
-                    task,
-                    status: 'success',
-                    terminalOutput: '',
-                });
-            }
-            else {
-                // cache prep
-                const { code, terminalOutput } = await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
-                results.push({
-                    task,
-                    status: code === 0 ? 'success' : 'failure',
+            catch (e) {
+                if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                    console.error(e);
+                }
+                else {
+                    console.error(e.message);
+                }
+                const terminalOutput = e.stack ?? e.message ?? '';
+                (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
+                return new noop_child_process_1.NoopChildProcess({
+                    code: 1,
                     terminalOutput,
                 });
             }
         }
-        await this.postRunSteps([task], results, doNotSkipCache, { groupId });
+        else if (targetConfiguration.executor === 'nx:noop') {
+            (0, fs_1.writeFileSync)(temporaryOutputPath, '');
+            return new noop_child_process_1.NoopChildProcess({
+                code: 0,
+                terminalOutput: '',
+            });
+        }
+        else {
+            // cache prep
+            const runningTask = await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
+            if (this.tuiEnabled && runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
+                // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
+                this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+            }
+            return runningTask;
+        }
     }
     async runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput) {
         try {
             const usePtyFork = process.env.NX_NATIVE_COMMAND_RUNNER !== 'false';
-            // Disable the pseudo terminal if this is a run-many
-            const disablePseudoTerminal = !this.initiatingProject;
+            // Disable the pseudo terminal if this is a run-many or when running a continuous task as part of a run-one
+            const disablePseudoTerminal = !this.tuiEnabled && (!this.initiatingProject || task.continuous);
             // execution
-            const { code, terminalOutput } = usePtyFork
+            const childProcess = usePtyFork
                 ? await this.forkedProcessTaskRunner.forkProcess(task, {
                     temporaryOutputPath,
                     streamOutput,
@@ -314,19 +379,62 @@ class TaskOrchestrator {
                     taskGraph: this.taskGraph,
                     env,
                 });
-            return {
-                code,
-                terminalOutput,
-            };
+            return childProcess;
         }
         catch (e) {
             if (process.env.NX_VERBOSE_LOGGING === 'true') {
                 console.error(e);
             }
-            return {
+            return new noop_child_process_1.NoopChildProcess({
                 code: 1,
-            };
+                terminalOutput: undefined,
+            });
+        }
+    }
+    async startContinuousTask(task, groupId) {
+        if (this.runningTasksService.getRunningTasks([task.id]).length) {
+            await this.preRunSteps([task], { groupId });
+            if (this.tuiEnabled) {
+                this.options.lifeCycle.setTaskStatus(task.id, 8 /* NativeTaskStatus.Shared */);
+            }
+            // task is already running by another process, we schedule the next tasks
+            // and release the threads
+            await this.scheduleNextTasksAndReleaseThreads();
+            // wait for the running task to finish
+            do {
+                console.log(`Waiting for ${task.id} in another nx process`);
+                await new Promise((resolve) => setTimeout(resolve, 100));
+            } while (this.runningTasksService.getRunningTasks([task.id]).length);
+            return;
+        }
+        const taskSpecificEnv = await this.processedTasks.get(task.id);
+        await this.preRunSteps([task], { groupId });
+        const pipeOutput = await this.pipeOutputCapture(task);
+        // obtain metadata
+        const temporaryOutputPath = this.cache.temporaryOutputPath(task);
+        const streamOutput = this.outputStyle === 'static'
+            ? false
+            : (0, utils_1.shouldStreamOutput)(task, this.initiatingProject);
+        let env = pipeOutput
+            ? (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, process.env.FORCE_COLOR === undefined
+                ? 'true'
+                : process.env.FORCE_COLOR, this.options.skipNxCache, this.options.captureStderr, null, null)
+            : (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, undefined, this.options.skipNxCache, this.options.captureStderr, temporaryOutputPath, streamOutput);
+        const childProcess = await this.runTask(task, streamOutput, env, temporaryOutputPath, pipeOutput);
+        this.runningTasksService.addRunningTask(task.id);
+        this.runningContinuousTasks.set(task.id, childProcess);
+        childProcess.onExit(() => {
+            this.runningTasksService.removeRunningTask(task.id);
+        });
+        if (this.initiatingProject === task.target.project &&
+            this.options.targets.length === 1 &&
+            this.options.targets[0] === task.target.target) {
+            await childProcess.getResults();
+        }
+        else {
+            await this.scheduleNextTasksAndReleaseThreads();
         }
+        return childProcess;
     }
     // endregion Single Task
     // region Lifecycle
@@ -387,6 +495,9 @@ class TaskOrchestrator {
                 status,
             };
         }));
+        await this.scheduleNextTasksAndReleaseThreads();
+    }
+    async scheduleNextTasksAndReleaseThreads() {
         await this.tasksSchedule.scheduleNextTasks();
         // release blocked threads
         this.waitingForTasks.forEach((f) => f(null));
@@ -458,5 +569,36 @@ class TaskOrchestrator {
             return this.daemon.recordOutputsHash(task.outputs, task.hash);
         }
     }
+    // endregion utils
+    async cleanup() {
+        this.cleaningUp = true;
+        await Promise.all(Array.from(this.runningContinuousTasks).map(async ([taskId, t]) => {
+            try {
+                return t.kill();
+            }
+            catch (e) {
+                console.error(`Unable to terminate ${taskId}\nError:`, e);
+            }
+            finally {
+                this.runningTasksService.removeRunningTask(taskId);
+            }
+        }));
+    }
 }
 exports.TaskOrchestrator = TaskOrchestrator;
+function getThreadCount(options, taskGraph) {
+    if (options['parallel'] === 'false' ||
+        options['parallel'] === false) {
+        options['parallel'] = 1;
+    }
+    else if (options['parallel'] === 'true' ||
+        options['parallel'] === true ||
+        options['parallel'] === undefined ||
+        options['parallel'] === '') {
+        options['parallel'] = Number(options['maxParallel'] || 3);
+    }
+    const maxParallel = options['parallel'] +
+        Object.values(taskGraph.tasks).filter((t) => t.continuous).length;
+    const totalTasks = Object.keys(taskGraph.tasks).length;
+    return Math.min(maxParallel, totalTasks);
+}

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

@@ -147,11 +147,14 @@ class TasksSchedule {
                 {
                     tasks: {},
                     dependencies: {},
+                    continuousDependencies: {},
                     roots: [],
                 });
         batch.tasks[task.id] = task;
         batch.dependencies[task.id] =
             this.notScheduledTaskGraph.dependencies[task.id];
+        batch.continuousDependencies[task.id] =
+            this.notScheduledTaskGraph.continuousDependencies[task.id];
         if (isRoot) {
             batch.roots.push(task.id);
         }
@@ -168,8 +171,9 @@ class TasksSchedule {
     }
     canBeScheduled(taskId) {
         const hasDependenciesCompleted = this.taskGraph.dependencies[taskId].every((id) => this.completedTasks.has(id));
+        const hasContinuousDependenciesStarted = this.taskGraph.continuousDependencies[taskId].every((id) => this.runningTasks.has(id));
         // if dependencies have not completed, cannot schedule
-        if (!hasDependenciesCompleted) {
+        if (!hasDependenciesCompleted || !hasContinuousDependenciesStarted) {
             return false;
         }
         // if there are no running tasks, can schedule anything

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

@@ -1,7 +1,7 @@
-import { Task, TaskGraph } from '../config/task-graph';
+import { CustomHasher, ExecutorConfig } from '../config/misc-interfaces';
 import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { Task, TaskGraph } from '../config/task-graph';
 import { TargetConfiguration, TargetDependencyConfig } from '../config/workspace-json-project-json';
-import { CustomHasher, ExecutorConfig } from '../config/misc-interfaces';
 export type NormalizedTargetDependencyConfig = TargetDependencyConfig & {
     projects: string[];
 };
@@ -37,14 +37,6 @@ export declare function getExecutorForTask(task: Task, projectGraph: ProjectGrap
 };
 export declare function getCustomHasher(task: Task, projectGraph: ProjectGraph): CustomHasher | null;
 export declare function removeTasksFromTaskGraph(graph: TaskGraph, ids: string[]): TaskGraph;
-export declare function removeIdsFromGraph<T>(graph: {
-    roots: string[];
-    dependencies: Record<string, string[]>;
-}, ids: string[], mapWithIds: Record<string, T>): {
-    mapWithIds: Record<string, T>;
-    roots: string[];
-    dependencies: Record<string, string[]>;
-};
 export declare function calculateReverseDeps(taskGraph: TaskGraph): Record<string, string[]>;
 export declare function getCliPath(): string;
 export declare function getPrintableCommandArgsForTask(task: Task): string[];

package/src/tasks-runner/utils.js

@@ -17,7 +17,6 @@ exports.getExecutorNameForTask = getExecutorNameForTask;
 exports.getExecutorForTask = getExecutorForTask;
 exports.getCustomHasher = getCustomHasher;
 exports.removeTasksFromTaskGraph = removeTasksFromTaskGraph;
-exports.removeIdsFromGraph = removeIdsFromGraph;
 exports.calculateReverseDeps = calculateReverseDeps;
 exports.getCliPath = getCliPath;
 exports.getPrintableCommandArgsForTask = getPrintableCommandArgsForTask;
@@ -25,19 +24,20 @@ exports.getSerializedArgsForTask = getSerializedArgsForTask;
 exports.shouldStreamOutput = shouldStreamOutput;
 exports.isCacheableTask = isCacheableTask;
 exports.unparse = unparse;
-const path_1 = require("path");
-const posix_1 = require("path/posix");
-const workspace_root_1 = require("../utils/workspace-root");
-const path_2 = require("../utils/path");
-const fileutils_1 = require("../utils/fileutils");
-const serialize_overrides_into_command_line_1 = require("../utils/serialize-overrides-into-command-line");
-const split_target_1 = require("../utils/split-target");
+const minimatch_1 = require("minimatch");
+const node_path_1 = require("node:path");
+const posix_1 = require("node:path/posix");
 const executor_utils_1 = require("../command-line/run/executor-utils");
+const native_1 = require("../native");
 const project_graph_1 = require("../project-graph/project-graph");
+const fileutils_1 = require("../utils/fileutils");
 const find_matching_projects_1 = require("../utils/find-matching-projects");
-const minimatch_1 = require("minimatch");
 const globs_1 = require("../utils/globs");
-const native_1 = require("../native");
+const path_1 = require("../utils/path");
+const serialize_overrides_into_command_line_1 = require("../utils/serialize-overrides-into-command-line");
+const split_target_1 = require("../utils/split-target");
+const workspace_root_1 = require("../utils/workspace-root");
+const is_tui_enabled_1 = require("./is-tui-enabled");
 function getDependencyConfigs({ project, target }, extraTargetDependencies, projectGraph, allTargetNames) {
     const dependencyConfigs = (projectGraph.nodes[project].data?.targets[target]?.dependsOn ??
         // This is passed into `run-command` from programmatic invocations
@@ -194,10 +194,10 @@ function transformLegacyOutputs(projectRoot, outputs) {
             : [false, output];
         const relativePath = (0, fileutils_1.isRelativePath)(outputPath)
             ? output
-            : (0, path_1.relative)(projectRoot, outputPath);
+            : (0, node_path_1.relative)(projectRoot, outputPath);
         const isWithinProject = !relativePath.startsWith('..');
         return ((isNegated ? '!' : '') +
-            (0, path_2.joinPathFragments)(isWithinProject ? '{projectRoot}' : '{workspaceRoot}', isWithinProject ? relativePath : outputPath));
+            (0, path_1.joinPathFragments)(isWithinProject ? '{projectRoot}' : '{workspaceRoot}', isWithinProject ? relativePath : outputPath));
     });
 }
 /**
@@ -302,27 +302,31 @@ function getCustomHasher(task, projectGraph) {
     return factory ? factory() : null;
 }
 function removeTasksFromTaskGraph(graph, ids) {
-    const newGraph = removeIdsFromGraph(graph, ids, graph.tasks);
+    const newGraph = removeIdsFromTaskGraph(graph, ids, graph.tasks);
     return {
         dependencies: newGraph.dependencies,
+        continuousDependencies: newGraph.continuousDependencies,
         roots: newGraph.roots,
         tasks: newGraph.mapWithIds,
     };
 }
-function removeIdsFromGraph(graph, ids, mapWithIds) {
+function removeIdsFromTaskGraph(graph, ids, mapWithIds) {
     const filteredMapWithIds = {};
     const dependencies = {};
+    const continuousDependencies = {};
     const removedSet = new Set(ids);
     for (let id of Object.keys(mapWithIds)) {
         if (!removedSet.has(id)) {
             filteredMapWithIds[id] = mapWithIds[id];
             dependencies[id] = graph.dependencies[id].filter((depId) => !removedSet.has(depId));
+            continuousDependencies[id] = graph.continuousDependencies[id].filter((depId) => !removedSet.has(depId));
         }
     }
     return {
         mapWithIds: filteredMapWithIds,
         dependencies: dependencies,
-        roots: Object.keys(dependencies).filter((k) => dependencies[k].length === 0),
+        continuousDependencies,
+        roots: Object.keys(filteredMapWithIds).filter((k) => dependencies[k].length === 0 && continuousDependencies[k].length === 0),
     };
 }
 function calculateReverseDeps(taskGraph) {
@@ -335,6 +339,11 @@ function calculateReverseDeps(taskGraph) {
             reverseTaskDeps[d].push(taskId);
         });
     });
+    Object.keys(taskGraph.continuousDependencies).forEach((taskId) => {
+        taskGraph.continuousDependencies[taskId].forEach((d) => {
+            reverseTaskDeps[d].push(taskId);
+        });
+    });
     return reverseTaskDeps;
 }
 function getCliPath() {
@@ -360,6 +369,9 @@ function getSerializedArgsForTask(task, isVerbose) {
     ];
 }
 function shouldStreamOutput(task, initiatingProject) {
+    // For now, disable streaming output on the JS side when running the TUI
+    if ((0, is_tui_enabled_1.isTuiEnabled)())
+        return false;
     if (process.env.NX_STREAM_OUTPUT === 'true')
         return true;
     if (longRunningTask(task))

package/src/utils/child-process.d.ts

@@ -1,11 +1,15 @@
 import { type ExecOptions, type ExecSyncOptions } from 'child_process';
+import { PackageManagerCommands } from './package-manager';
 import { ChildProcess } from '../native';
+export declare function getRunNxBaseCommand(packageManagerCommand?: PackageManagerCommands, cwd?: string): string;
 export declare function runNxSync(cmd: string, options?: ExecSyncOptions & {
     cwd?: string;
+    packageManagerCommand?: PackageManagerCommands;
 }): void;
 export declare function runNxAsync(cmd: string, options?: ExecOptions & {
     cwd?: string;
     silent?: boolean;
+    packageManagerCommand?: PackageManagerCommands;
 }): Promise<void>;
 export declare class PseudoTtyProcess {
     private childProcess;