nx 20.5.0-canary.20250201-05e0679 → 21.0.0-beta.0

package/src/tasks-runner/create-task-graph.js

@@ -17,6 +17,7 @@ class ProcessTasks {
         this.seen = new Set();
         this.tasks = {};
         this.dependencies = {};
+        this.continuousDependencies = {};
         const allTargetNames = new Set();
         for (const projectName in projectGraph.nodes) {
             const project = projectGraph.nodes[projectName];
@@ -36,6 +37,7 @@ class ProcessTasks {
                     const task = this.createTask(id, project, target, resolvedConfiguration, overrides);
                     this.tasks[task.id] = task;
                     this.dependencies[task.id] = [];
+                    this.continuousDependencies[task.id] = [];
                 }
             }
         }
@@ -50,11 +52,15 @@ class ProcessTasks {
                 if (!initialTasks[t]) {
                     delete this.tasks[t];
                     delete this.dependencies[t];
+                    delete this.continuousDependencies[t];
                 }
             }
             for (let d of Object.keys(this.dependencies)) {
                 this.dependencies[d] = this.dependencies[d].filter((dd) => !!initialTasks[dd]);
             }
+            for (let d of Object.keys(this.continuousDependencies)) {
+                this.continuousDependencies[d] = this.continuousDependencies[d].filter((dd) => !!initialTasks[dd]);
+            }
         }
         filterDummyTasks(this.dependencies);
         for (const taskId of Object.keys(this.dependencies)) {
@@ -64,7 +70,16 @@ class ProcessTasks {
                 ];
             }
         }
-        return Object.keys(this.dependencies).filter((d) => this.dependencies[d].length === 0);
+        filterDummyTasks(this.continuousDependencies);
+        for (const taskId of Object.keys(this.continuousDependencies)) {
+            if (this.continuousDependencies[taskId].length > 0) {
+                this.continuousDependencies[taskId] = [
+                    ...new Set(this.continuousDependencies[taskId].filter((d) => d !== taskId)).values(),
+                ];
+            }
+        }
+        return Object.keys(this.tasks).filter((d) => this.dependencies[d].length === 0 &&
+            this.continuousDependencies[d].length === 0);
     }
     processTask(task, projectUsedToDeriveDependencies, configuration, overrides) {
         const seenKey = `${task.id}-${projectUsedToDeriveDependencies}`;
@@ -106,15 +121,21 @@ class ProcessTasks {
         if ((0, project_graph_utils_1.projectHasTarget)(selfProject, dependencyConfig.target)) {
             const resolvedConfiguration = this.resolveConfiguration(selfProject, dependencyConfig.target, configuration);
             const selfTaskId = this.getId(selfProject.name, dependencyConfig.target, resolvedConfiguration);
-            if (task.id !== selfTaskId) {
-                this.dependencies[task.id].push(selfTaskId);
-            }
             if (!this.tasks[selfTaskId]) {
                 const newTask = this.createTask(selfTaskId, selfProject, dependencyConfig.target, resolvedConfiguration, taskOverrides);
                 this.tasks[selfTaskId] = newTask;
                 this.dependencies[selfTaskId] = [];
+                this.continuousDependencies[selfTaskId] = [];
                 this.processTask(newTask, newTask.target.project, configuration, overrides);
             }
+            if (task.id !== selfTaskId) {
+                if (this.tasks[selfTaskId].continuous) {
+                    this.continuousDependencies[task.id].push(selfTaskId);
+                }
+                else {
+                    this.dependencies[task.id].push(selfTaskId);
+                }
+            }
         }
     }
     processTasksForDependencies(projectUsedToDeriveDependencies, dependencyConfig, configuration, task, taskOverrides, overrides) {
@@ -129,13 +150,20 @@ class ProcessTasks {
             if ((0, project_graph_utils_1.projectHasTarget)(depProject, dependencyConfig.target)) {
                 const resolvedConfiguration = this.resolveConfiguration(depProject, dependencyConfig.target, configuration);
                 const depTargetId = this.getId(depProject.name, dependencyConfig.target, resolvedConfiguration);
+                const depTargetConfiguration = this.projectGraph.nodes[depProject.name].data.targets[dependencyConfig.target];
                 if (task.id !== depTargetId) {
-                    this.dependencies[task.id].push(depTargetId);
+                    if (depTargetConfiguration.continuous) {
+                        this.continuousDependencies[task.id].push(depTargetId);
+                    }
+                    else {
+                        this.dependencies[task.id].push(depTargetId);
+                    }
                 }
                 if (!this.tasks[depTargetId]) {
                     const newTask = this.createTask(depTargetId, depProject, dependencyConfig.target, resolvedConfiguration, taskOverrides);
                     this.tasks[depTargetId] = newTask;
                     this.dependencies[depTargetId] = [];
+                    this.continuousDependencies[depTargetId] = [];
                     this.processTask(newTask, newTask.target.project, configuration, overrides);
                 }
             }
@@ -147,6 +175,7 @@ class ProcessTasks {
                     DUMMY_TASK_TARGET, undefined);
                 this.dependencies[task.id].push(dummyId);
                 this.dependencies[dummyId] ??= [];
+                this.continuousDependencies[dummyId] ??= [];
                 const noopTask = this.createDummyTask(dummyId, task);
                 this.processTask(noopTask, depProject.name, configuration, overrides);
             }
@@ -179,6 +208,7 @@ class ProcessTasks {
             outputs: (0, utils_1.getOutputs)(this.projectGraph.nodes, qualifiedTarget, interpolatedOverrides),
             cache: project.data.targets[target].cache,
             parallelism: project.data.targets[target].parallelism ?? true,
+            continuous: project.data.targets[target].continuous ?? false,
         };
     }
     resolveConfiguration(project, target, configuration) {
@@ -204,6 +234,7 @@ function createTaskGraph(projectGraph, extraTargetDependencies, projectNames, ta
         roots,
         tasks: p.tasks,
         dependencies: p.dependencies,
+        continuousDependencies: p.continuousDependencies,
     };
 }
 function mapTargetDefaultsToDependencies(defaults) {

package/src/tasks-runner/forked-process-task-runner.d.ts

@@ -1,7 +1,9 @@
 import { DefaultTasksRunnerOptions } from './default-tasks-runner';
 import { Batch } from './tasks-schedule';
-import { BatchResults } from './batch/batch-messages';
 import { Task, TaskGraph } from '../config/task-graph';
+import { PseudoTtyProcess } from './pseudo-terminal';
+import { BatchProcess } from './running-tasks/batch-process';
+import { RunningTask } from './running-tasks/running-task';
 export declare class ForkedProcessTaskRunner {
     private readonly options;
     cliPath: string;
@@ -10,17 +12,14 @@ export declare class ForkedProcessTaskRunner {
     private pseudoTerminal;
     constructor(options: DefaultTasksRunnerOptions);
     init(): Promise<void>;
-    forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }: Batch, fullTaskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<BatchResults>;
+    forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }: Batch, fullTaskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<BatchProcess>;
     forkProcessLegacy(task: Task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }: {
         temporaryOutputPath: string;
         streamOutput: boolean;
         pipeOutput: boolean;
         taskGraph: TaskGraph;
         env: NodeJS.ProcessEnv;
-    }): Promise<{
-        code: number;
-        terminalOutput: string;
-    }>;
+    }): Promise<RunningTask>;
     forkProcess(task: Task, { temporaryOutputPath, streamOutput, taskGraph, env, disablePseudoTerminal, }: {
         temporaryOutputPath: string;
         streamOutput: boolean;
@@ -28,15 +27,10 @@ export declare class ForkedProcessTaskRunner {
         taskGraph: TaskGraph;
         env: NodeJS.ProcessEnv;
         disablePseudoTerminal: boolean;
-    }): Promise<{
-        code: number;
-        terminalOutput: string;
-    }>;
+    }): Promise<RunningTask | PseudoTtyProcess>;
     private forkProcessWithPseudoTerminal;
-    private forkProcessPipeOutputCapture;
     private forkProcessWithPrefixAndNotTTY;
     private forkProcessDirectOutputCapture;
-    private readTerminalOutput;
     private writeTerminalOutput;
     private setupProcessEventListeners;
 }

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

@@ -3,15 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ForkedProcessTaskRunner = void 0;
 const fs_1 = require("fs");
 const child_process_1 = require("child_process");
-const chalk = require("chalk");
 const output_1 = require("../utils/output");
 const utils_1 = require("./utils");
 const path_1 = require("path");
 const batch_messages_1 = require("./batch/batch-messages");
 const strip_indents_1 = require("../utils/strip-indents");
-const stream_1 = require("stream");
 const pseudo_terminal_1 = require("./pseudo-terminal");
 const exit_codes_1 = require("../utils/exit-codes");
+const node_child_process_1 = require("./running-tasks/node-child-process");
+const batch_process_1 = require("./running-tasks/batch-process");
 const forkScript = (0, path_1.join)(__dirname, './fork.js');
 const workerPath = (0, path_1.join)(__dirname, './batch/run-batch.js');
 class ForkedProcessTaskRunner {
@@ -31,76 +31,42 @@ class ForkedProcessTaskRunner {
         this.setupProcessEventListeners();
     }
     // TODO: vsavkin delegate terminal output printing
-    forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }, fullTaskGraph, env) {
-        return new Promise((res, rej) => {
-            try {
-                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', 'inherit', 'inherit', 'ipc'],
-                    env,
-                });
-                this.processes.add(p);
-                p.once('exit', (code, signal) => {
-                    this.processes.delete(p);
-                    if (code === null)
-                        code = (0, exit_codes_1.signalToCode)(signal);
-                    if (code !== 0) {
-                        const results = {};
-                        for (const rootTaskId of batchTaskGraph.roots) {
-                            results[rootTaskId] = {
-                                success: false,
-                                terminalOutput: '',
-                            };
-                        }
-                        rej(new Error(`"${executorName}" exited unexpectedly with code: ${code}`));
-                    }
-                });
-                p.on('message', (message) => {
-                    switch (message.type) {
-                        case batch_messages_1.BatchMessageType.CompleteBatchExecution: {
-                            res(message.results);
-                            break;
-                        }
-                        case batch_messages_1.BatchMessageType.RunTasks: {
-                            break;
-                        }
-                        default: {
-                            // Re-emit any non-batch messages from the task process
-                            if (process.send) {
-                                process.send(message);
-                            }
-                        }
-                    }
-                });
-                // Start the tasks
-                p.send({
-                    type: batch_messages_1.BatchMessageType.RunTasks,
-                    executorName,
-                    batchTaskGraph,
-                    fullTaskGraph,
-                });
-            }
-            catch (e) {
-                rej(e);
-            }
+    async forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }, 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', 'inherit', 'inherit', 'ipc'],
+            env,
+        });
+        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,
+            batchTaskGraph,
+            fullTaskGraph,
         });
+        return cp;
     }
     async forkProcessLegacy(task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }) {
         return pipeOutput
-            ? await this.forkProcessPipeOutputCapture(task, {
+            ? this.forkProcessWithPrefixAndNotTTY(task, {
                 temporaryOutputPath,
                 streamOutput,
                 taskGraph,
                 env,
             })
-            : await this.forkProcessDirectOutputCapture(task, {
+            : this.forkProcessDirectOutputCapture(task, {
                 temporaryOutputPath,
                 streamOutput,
                 taskGraph,
@@ -154,158 +120,96 @@ class ForkedProcessTaskRunner {
         p.onOutput((msg) => {
             terminalOutput += msg;
         });
-        return new Promise((res) => {
-            p.onExit((code) => {
-                // If the exit code is greater than 128, it's a special exit code for a signal
-                if (code >= 128) {
-                    process.exit(code);
-                }
-                this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
-                res({
-                    code,
-                    terminalOutput,
-                });
-            });
-        });
-    }
-    forkProcessPipeOutputCapture(task, { streamOutput, temporaryOutputPath, taskGraph, env, }) {
-        return this.forkProcessWithPrefixAndNotTTY(task, {
-            streamOutput,
-            temporaryOutputPath,
-            taskGraph,
-            env,
+        p.onExit((code) => {
+            if (code > 128) {
+                process.exit(code);
+            }
+            this.processes.delete(p);
+            this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
         });
+        return p;
     }
     forkProcessWithPrefixAndNotTTY(task, { streamOutput, temporaryOutputPath, taskGraph, env, }) {
-        return new Promise((res, rej) => {
-            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,
-                });
-                this.processes.add(p);
-                // Re-emit any messages from the task process
-                p.on('message', (message) => {
-                    if (process.send) {
-                        process.send(message);
-                    }
-                });
-                // Send message to run the executor
-                p.send({
-                    targetDescription: task.target,
-                    overrides: task.overrides,
-                    taskGraph,
-                    isVerbose: this.verbose,
-                });
-                if (streamOutput) {
-                    if (process.env.NX_PREFIX_OUTPUT === 'true') {
-                        const color = getColor(task.target.project);
-                        const prefixText = `${task.target.project}:`;
-                        p.stdout
-                            .pipe(logClearLineToPrefixTransformer(color.bold(prefixText) + ' '))
-                            .pipe(addPrefixTransformer(color.bold(prefixText)))
-                            .pipe(process.stdout);
-                        p.stderr
-                            .pipe(logClearLineToPrefixTransformer(color(prefixText) + ' '))
-                            .pipe(addPrefixTransformer(color(prefixText)))
-                            .pipe(process.stderr);
-                    }
-                    else {
-                        p.stdout.pipe(addPrefixTransformer()).pipe(process.stdout);
-                        p.stderr.pipe(addPrefixTransformer()).pipe(process.stderr);
-                    }
+        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,
+            });
+            // 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);
                 }
-                let outWithErr = [];
-                p.stdout.on('data', (chunk) => {
-                    outWithErr.push(chunk.toString());
-                });
-                p.stderr.on('data', (chunk) => {
-                    outWithErr.push(chunk.toString());
-                });
-                p.on('exit', (code, signal) => {
-                    this.processes.delete(p);
-                    if (code === null)
-                        code = (0, exit_codes_1.signalToCode)(signal);
-                    // we didn't print any output as we were running the command
-                    // print all the collected output|
-                    const terminalOutput = outWithErr.join('');
+                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,
+            });
+            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);
                     }
-                    this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
-                    res({ code, terminalOutput });
-                });
-            }
-            catch (e) {
-                console.error(e);
-                rej(e);
-            }
-        });
-    }
-    forkProcessDirectOutputCapture(task, { streamOutput, temporaryOutputPath, taskGraph, env, }) {
-        return new Promise((res, rej) => {
-            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,
-                });
-                this.processes.add(p);
-                // Re-emit any messages from the task process
-                p.on('message', (message) => {
-                    if (process.send) {
-                        process.send(message);
-                    }
-                });
-                // Send message to run the executor
-                p.send({
-                    targetDescription: task.target,
-                    overrides: task.overrides,
-                    taskGraph,
-                    isVerbose: this.verbose,
-                });
-                p.on('exit', (code, signal) => {
-                    if (code === null)
-                        code = (0, exit_codes_1.signalToCode)(signal);
-                    // we didn't print any output as we were running the command
-                    // print all the collected output
-                    let terminalOutput = '';
-                    try {
-                        terminalOutput = this.readTerminalOutput(temporaryOutputPath);
-                        if (!streamOutput) {
-                            this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
-                        }
-                    }
-                    catch (e) {
-                        console.log((0, strip_indents_1.stripIndents) `
+                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}
             `);
-                    }
-                    res({
-                        code,
-                        terminalOutput,
-                    });
-                });
-            }
-            catch (e) {
-                console.error(e);
-                rej(e);
-            }
-        });
-    }
-    readTerminalOutput(outputPath) {
-        return (0, fs_1.readFileSync)(outputPath).toString();
+                }
+            });
+            return cp;
+        }
+        catch (e) {
+            console.error(e);
+            throw e;
+        }
     }
     writeTerminalOutput(outputPath, content) {
         (0, fs_1.writeFileSync)(outputPath, content);
@@ -318,12 +222,11 @@ class ForkedProcessTaskRunner {
         }
         // 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 (this.pseudoTerminal) {
                 this.pseudoTerminal.sendMessageToChildren(message);
             }
             this.processes.forEach((p) => {
-                if ('connected' in p && p.connected) {
+                if ('send' in p) {
                     p.send(message);
                 }
             });
@@ -331,34 +234,26 @@ class ForkedProcessTaskRunner {
         // Terminate any task processes on exit
         process.on('exit', () => {
             this.processes.forEach((p) => {
-                if ('connected' in p ? p.connected : p.isAlive) {
-                    p.kill();
-                }
+                p.kill();
             });
         });
         process.on('SIGINT', () => {
             this.processes.forEach((p) => {
-                if ('connected' in p ? p.connected : p.isAlive) {
-                    p.kill('SIGTERM');
-                }
+                p.kill('SIGTERM');
             });
             // we exit here because we don't need to write anything to cache.
             process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
         });
         process.on('SIGTERM', () => {
             this.processes.forEach((p) => {
-                if ('connected' in p ? p.connected : p.isAlive) {
-                    p.kill('SIGTERM');
-                }
+                p.kill('SIGTERM');
             });
             // no exit here because we expect child processes to terminate which
             // will store results to the cache and will terminate this process
         });
         process.on('SIGHUP', () => {
             this.processes.forEach((p) => {
-                if ('connected' in p ? p.connected : p.isAlive) {
-                    p.kill('SIGTERM');
-                }
+                p.kill('SIGTERM');
             });
             // no exit here because we expect child processes to terminate which
             // will store results to the cache and will terminate this process
@@ -366,51 +261,3 @@ class ForkedProcessTaskRunner {
     }
 }
 exports.ForkedProcessTaskRunner = ForkedProcessTaskRunner;
-const colors = [
-    chalk.green,
-    chalk.greenBright,
-    chalk.red,
-    chalk.redBright,
-    chalk.cyan,
-    chalk.cyanBright,
-    chalk.yellow,
-    chalk.yellowBright,
-    chalk.magenta,
-    chalk.magentaBright,
-];
-function getColor(projectName) {
-    let code = 0;
-    for (let i = 0; i < projectName.length; ++i) {
-        code += projectName.charCodeAt(i);
-    }
-    const colorIndex = code % colors.length;
-    return colors[colorIndex];
-}
-/**
- * Prevents terminal escape sequence from clearing line prefix.
- */
-function logClearLineToPrefixTransformer(prefix) {
-    let prevChunk = null;
-    return new stream_1.Transform({
-        transform(chunk, _encoding, callback) {
-            if (prevChunk && prevChunk.toString() === '\x1b[2K') {
-                chunk = chunk.toString().replace(/\x1b\[1G/g, (m) => m + prefix);
-            }
-            this.push(chunk);
-            prevChunk = chunk;
-            callback();
-        },
-    });
-}
-function addPrefixTransformer(prefix) {
-    const newLineSeparator = process.platform.startsWith('win') ? '\r\n' : '\n';
-    return new stream_1.Transform({
-        transform(chunk, _encoding, callback) {
-            const list = chunk.toString().split(/\r\n|[\n\v\f\r\x85\u2028\u2029]/g);
-            list
-                .filter(Boolean)
-                .forEach((m) => this.push(prefix ? prefix + ' ' + m + newLineSeparator : m + newLineSeparator));
-            callback();
-        },
-    });
-}

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

@@ -36,6 +36,10 @@ async function initTasksRunner(nxArgs) {
                     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,

package/src/tasks-runner/pseudo-terminal.d.ts

@@ -31,8 +31,14 @@ export declare class PseudoTerminal {
 export declare class PseudoTtyProcess {
     private childProcess;
     isAlive: boolean;
-    exitCallbacks: any[];
+    private exitCallbacks;
+    private outputCallbacks;
+    private terminalOutput;
     constructor(childProcess: ChildProcess);
+    getResults(): Promise<{
+        code: number;
+        terminalOutput: string;
+    }>;
     onExit(callback: (code: number) => void): void;
     onOutput(callback: (message: string) => void): void;
     kill(): void;