nx 21.0.0-beta.0 → 21.0.0-beta.2

package/src/tasks-runner/cache.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cache = exports.DbCache = void 0;
 exports.dbCacheEnabled = dbCacheEnabled;
 exports.getCache = getCache;
+exports.parseMaxCacheSize = parseMaxCacheSize;
+exports.formatCacheSize = formatCacheSize;
 const workspace_root_1 = require("../utils/workspace-root");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
@@ -68,7 +70,10 @@ function getCache(options) {
 class DbCache {
     constructor(options) {
         this.options = options;
-        this.cache = new native_1.NxCache(workspace_root_1.workspaceRoot, cache_directory_1.cacheDir, (0, db_connection_1.getDbConnection)());
+        this.nxJson = (0, nx_json_1.readNxJson)();
+        this.cache = new native_1.NxCache(workspace_root_1.workspaceRoot, cache_directory_1.cacheDir, (0, db_connection_1.getDbConnection)(), undefined, this.nxJson.maxCacheSize !== undefined
+            ? parseMaxCacheSize(this.nxJson.maxCacheSize)
+            : (0, native_1.getDefaultMaxCacheSize)(cache_directory_1.cacheDir));
         this.isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
     }
     async init() {
@@ -83,6 +88,7 @@ class DbCache {
         if (res) {
             return {
                 ...res,
+                terminalOutput: res.terminalOutput ?? '',
                 remote: false,
             };
         }
@@ -91,9 +97,10 @@ class DbCache {
             // attempt remote cache
             const res = await this.remoteCache.retrieve(task.hash, this.cache.cacheDirectory);
             if (res) {
-                this.applyRemoteCacheResults(task.hash, res);
+                this.applyRemoteCacheResults(task.hash, res, task.outputs);
                 return {
                     ...res,
+                    terminalOutput: res.terminalOutput ?? '',
                     remote: true,
                 };
             }
@@ -105,8 +112,11 @@ class DbCache {
             return null;
         }
     }
-    applyRemoteCacheResults(hash, res) {
-        return this.cache.applyRemoteCacheResults(hash, res);
+    getUsedCacheSpace() {
+        return this.cache.getCacheSize();
+    }
+    applyRemoteCacheResults(hash, res, outputs) {
+        return this.cache.applyRemoteCacheResults(hash, res, outputs);
     }
     async put(task, terminalOutput, outputs, code) {
         return tryAndRetry(async () => {
@@ -155,26 +165,49 @@ class DbCache {
             }
         }
         else {
-            return ((await this.getPowerpackS3Cache()) ??
-                (await this.getPowerpackSharedCache()) ??
-                (await this.getPowerpackGcsCache()) ??
-                (await this.getPowerpackAzureCache()) ??
+            return ((await this.getS3Cache()) ??
+                (await this.getSharedCache()) ??
+                (await this.getGcsCache()) ??
+                (await this.getAzureCache()) ??
+                this.getHttpCache() ??
                 null);
         }
     }
-    getPowerpackS3Cache() {
-        return this.getPowerpackCache('@nx/powerpack-s3-cache');
-    }
-    getPowerpackSharedCache() {
-        return this.getPowerpackCache('@nx/powerpack-shared-fs-cache');
-    }
-    getPowerpackGcsCache() {
-        return this.getPowerpackCache('@nx/powerpack-gcs-cache');
-    }
-    getPowerpackAzureCache() {
-        return this.getPowerpackCache('@nx/powerpack-azure-cache');
+    async getS3Cache() {
+        const cache = await this.resolveRemoteCache('@nx/s3-cache');
+        if (cache)
+            return cache;
+        return this.resolveRemoteCache('@nx/powerpack-s3-cache');
+    }
+    async getSharedCache() {
+        const cache = await this.resolveRemoteCache('@nx/shared-fs-cache');
+        if (cache)
+            return cache;
+        return this.resolveRemoteCache('@nx/powerpack-shared-fs-cache');
+    }
+    async getGcsCache() {
+        const cache = await this.resolveRemoteCache('@nx/gcs-cache');
+        if (cache)
+            return cache;
+        return this.resolveRemoteCache('@nx/powerpack-gcs-cache');
+    }
+    async getAzureCache() {
+        const cache = await this.resolveRemoteCache('@nx/azure-cache');
+        if (cache)
+            return cache;
+        return this.resolveRemoteCache('@nx/powerpack-azure-cache');
+    }
+    getHttpCache() {
+        if (process.env.NX_SELF_HOSTED_REMOTE_CACHE_SERVER) {
+            if (native_1.IS_WASM) {
+                logger_1.logger.warn('The HTTP remote cache is not yet supported in the wasm build of Nx.');
+                return null;
+            }
+            return new native_1.HttpRemoteCache();
+        }
+        return null;
     }
-    async getPowerpackCache(pkg) {
+    async resolveRemoteCache(pkg) {
         let getRemoteCache = null;
         try {
             getRemoteCache = (await Promise.resolve(`${this.resolvePackage(pkg)}`).then(s => require(s))).getRemoteCache;
@@ -455,3 +488,54 @@ function tryAndRetry(fn) {
     };
     return _try();
 }
+/**
+ * Converts a string representation of a max cache size to a number.
+ *
+ * e.g. '1GB' -> 1024 * 1024 * 1024
+ *      '1MB' -> 1024 * 1024
+ *      '1KB' -> 1024
+ *
+ * @param maxCacheSize Max cache size as specified in nx.json
+ */
+function parseMaxCacheSize(maxCacheSize) {
+    if (maxCacheSize === null || maxCacheSize === undefined) {
+        return undefined;
+    }
+    let regexResult = maxCacheSize
+        // Covers folks who accidentally specify as a number rather than a string
+        .toString()
+        // Match a number followed by an optional unit (KB, MB, GB), with optional whitespace between the number and unit
+        .match(/^(?<size>[\d|.]+)\s?((?<unit>[KMG]?B)?)$/);
+    if (!regexResult) {
+        throw new Error(`Invalid max cache size specified in nx.json: ${maxCacheSize}. Must be a number followed by an optional unit (KB, MB, GB)`);
+    }
+    let sizeString = regexResult.groups.size;
+    let unit = regexResult.groups.unit;
+    if ([...sizeString].filter((c) => c === '.').length > 1) {
+        throw new Error(`Invalid max cache size specified in nx.json: ${maxCacheSize} (multiple decimal points in size)`);
+    }
+    let size = parseFloat(sizeString);
+    if (isNaN(size)) {
+        throw new Error(`Invalid max cache size specified in nx.json: ${maxCacheSize} (${sizeString} is not a number)`);
+    }
+    switch (unit) {
+        case 'KB':
+            return size * 1024;
+        case 'MB':
+            return size * 1024 * 1024;
+        case 'GB':
+            return size * 1024 * 1024 * 1024;
+        default:
+            return size;
+    }
+}
+function formatCacheSize(maxCacheSize, decimals = 2) {
+    const exponents = ['B', 'KB', 'MB', 'GB'];
+    let exponent = 0;
+    let size = maxCacheSize;
+    while (size >= 1024 && exponent < exponents.length - 1) {
+        size /= 1024;
+        exponent++;
+    }
+    return `${size.toFixed(decimals)} ${exponents[exponent]}`;
+}

package/src/tasks-runner/create-task-graph.d.ts

@@ -24,7 +24,6 @@ export declare class ProcessTasks {
     private createDummyTask;
     createTask(id: string, project: ProjectGraphProjectNode, target: string, resolvedConfiguration: string | undefined, overrides: Object): Task;
     resolveConfiguration(project: ProjectGraphProjectNode, target: string, configuration: string | undefined): string;
-    getId(project: string, target: string, configuration: string | undefined): string;
 }
 export declare function createTaskGraph(projectGraph: ProjectGraph, extraTargetDependencies: TargetDependencies, projectNames: string[], targets: string[], configuration: string | undefined, overrides: Object, excludeTaskDependencies?: boolean): TaskGraph;
 export declare function mapTargetDefaultsToDependencies(defaults: TargetDefaults | undefined): TargetDependencies;
@@ -41,3 +40,4 @@ export declare function filterDummyTasks(dependencies: {
 export declare function getNonDummyDeps(currentTask: string, dependencies: {
     [k: string]: string[];
 }, cycles?: Set<string>, seen?: Set<string>): string[];
+export declare function createTaskId(project: string, target: string, configuration: string | undefined): string;

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

@@ -5,6 +5,7 @@ exports.createTaskGraph = createTaskGraph;
 exports.mapTargetDefaultsToDependencies = mapTargetDefaultsToDependencies;
 exports.filterDummyTasks = filterDummyTasks;
 exports.getNonDummyDeps = getNonDummyDeps;
+exports.createTaskId = createTaskId;
 const utils_1 = require("./utils");
 const project_graph_utils_1 = require("../utils/project-graph-utils");
 const output_1 = require("../utils/output");
@@ -33,7 +34,7 @@ class ProcessTasks {
                 const project = this.projectGraph.nodes[projectName];
                 if (targets.length === 1 || project.data.targets[target]) {
                     const resolvedConfiguration = this.resolveConfiguration(project, target, configuration);
-                    const id = this.getId(projectName, target, resolvedConfiguration);
+                    const id = createTaskId(projectName, target, resolvedConfiguration);
                     const task = this.createTask(id, project, target, resolvedConfiguration, overrides);
                     this.tasks[task.id] = task;
                     this.dependencies[task.id] = [];
@@ -120,7 +121,7 @@ class ProcessTasks {
         const selfProject = this.projectGraph.nodes[projectName];
         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);
+            const selfTaskId = createTaskId(selfProject.name, dependencyConfig.target, resolvedConfiguration);
             if (!this.tasks[selfTaskId]) {
                 const newTask = this.createTask(selfTaskId, selfProject, dependencyConfig.target, resolvedConfiguration, taskOverrides);
                 this.tasks[selfTaskId] = newTask;
@@ -149,7 +150,7 @@ class ProcessTasks {
                 continue;
             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 depTargetId = createTaskId(depProject.name, dependencyConfig.target, resolvedConfiguration);
                 const depTargetConfiguration = this.projectGraph.nodes[depProject.name].data.targets[dependencyConfig.target];
                 if (task.id !== depTargetId) {
                     if (depTargetConfiguration.continuous) {
@@ -169,7 +170,7 @@ class ProcessTasks {
             }
             else {
                 // Create a dummy task for task.target.project... which simulates if depProject had dependencyConfig.target
-                const dummyId = this.getId(depProject.name, task.target.project +
+                const dummyId = createTaskId(depProject.name, task.target.project +
                     '__' +
                     dependencyConfig.target +
                     DUMMY_TASK_TARGET, undefined);
@@ -218,13 +219,6 @@ class ProcessTasks {
             ? configuration
             : defaultConfiguration;
     }
-    getId(project, target, configuration) {
-        let id = `${project}:${target}`;
-        if (configuration) {
-            id += `:${configuration}`;
-        }
-        return id;
-    }
 }
 exports.ProcessTasks = ProcessTasks;
 function createTaskGraph(projectGraph, extraTargetDependencies, projectNames, targets, configuration, overrides, excludeTaskDependencies = false) {
@@ -299,3 +293,10 @@ function getNonDummyDeps(currentTask, dependencies, cycles, seen = new Set()) {
         return [currentTask];
     }
 }
+function createTaskId(project, target, configuration) {
+    let id = `${project}:${target}`;
+    if (configuration) {
+        id += `:${configuration}`;
+    }
+    return id;
+}

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

@@ -54,26 +54,17 @@ class RemoteCacheV2 {
 }
 exports.RemoteCacheV2 = RemoteCacheV2;
 const defaultTasksRunner = async (tasks, options, context) => {
-    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);
-    }
-    await options.lifeCycle.startCommand();
+    const threadCount = (0, task_orchestrator_1.getThreadCount)(options, context.taskGraph);
+    await options.lifeCycle.startCommand(threadCount);
     try {
-        return await runAllTasks(tasks, options, context);
+        return await runAllTasks(options, context);
     }
     finally {
         await options.lifeCycle.endCommand();
     }
 };
 exports.defaultTasksRunner = defaultTasksRunner;
-async function runAllTasks(tasks, options, context) {
+async function runAllTasks(options, context) {
     const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.projectGraph, context.taskGraph, context.nxJson, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.outputStyle);
     return orchestrator.run();
 }

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

@@ -2,17 +2,19 @@ import { DefaultTasksRunnerOptions } from './default-tasks-runner';
 import { Batch } from './tasks-schedule';
 import { Task, TaskGraph } from '../config/task-graph';
 import { PseudoTtyProcess } from './pseudo-terminal';
+import { ProjectGraph } from '../config/project-graph';
 import { BatchProcess } from './running-tasks/batch-process';
 import { RunningTask } from './running-tasks/running-task';
 export declare class ForkedProcessTaskRunner {
     private readonly options;
+    private readonly tuiEnabled;
     cliPath: string;
     private readonly verbose;
     private processes;
-    private pseudoTerminal;
-    constructor(options: DefaultTasksRunnerOptions);
+    private pseudoTerminals;
+    constructor(options: DefaultTasksRunnerOptions, tuiEnabled: boolean);
     init(): Promise<void>;
-    forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }: Batch, fullTaskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<BatchProcess>;
+    forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }: Batch, projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<BatchProcess>;
     forkProcessLegacy(task: Task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }: {
         temporaryOutputPath: string;
         streamOutput: boolean;
@@ -28,6 +30,7 @@ export declare class ForkedProcessTaskRunner {
         env: NodeJS.ProcessEnv;
         disablePseudoTerminal: boolean;
     }): Promise<RunningTask | PseudoTtyProcess>;
+    private createPseudoTerminal;
     private forkProcessWithPseudoTerminal;
     private forkProcessWithPrefixAndNotTTY;
     private forkProcessDirectOutputCapture;

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

@@ -12,26 +12,23 @@ 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 native_1 = require("../native");
 const forkScript = (0, path_1.join)(__dirname, './fork.js');
 const workerPath = (0, path_1.join)(__dirname, './batch/run-batch.js');
 class ForkedProcessTaskRunner {
-    constructor(options) {
+    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.pseudoTerminal = pseudo_terminal_1.PseudoTerminal.isSupported()
-            ? (0, pseudo_terminal_1.getPseudoTerminal)()
-            : null;
+        this.pseudoTerminals = new Set();
     }
     async init() {
-        if (this.pseudoTerminal) {
-            await this.pseudoTerminal.init();
-        }
         this.setupProcessEventListeners();
     }
     // TODO: vsavkin delegate terminal output printing
-    async forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }, fullTaskGraph, env) {
+    async forkProcessForBatch({ 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)}`);
@@ -53,6 +50,7 @@ class ForkedProcessTaskRunner {
         cp.send({
             type: batch_messages_1.BatchMessageType.RunTasks,
             executorName,
+            projectGraph,
             batchTaskGraph,
             fullTaskGraph,
         });
@@ -74,14 +72,15 @@ class ForkedProcessTaskRunner {
             });
     }
     async forkProcess(task, { temporaryOutputPath, streamOutput, taskGraph, env, disablePseudoTerminal, }) {
-        const shouldPrefix = streamOutput && process.env.NX_PREFIX_OUTPUT === 'true';
+        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 (!this.pseudoTerminal ||
-            disablePseudoTerminal ||
-            !streamOutput ||
-            shouldPrefix) {
-            return this.forkProcessWithPrefixAndNotTTY(task, {
+        if (pseudo_terminal_1.PseudoTerminal.isSupported() &&
+            !disablePseudoTerminal &&
+            (this.tuiEnabled || (streamOutput && !shouldPrefix))) {
+            return this.forkProcessWithPseudoTerminal(task, {
                 temporaryOutputPath,
                 streamOutput,
                 taskGraph,
@@ -89,7 +88,7 @@ class ForkedProcessTaskRunner {
             });
         }
         else {
-            return this.forkProcessWithPseudoTerminal(task, {
+            return this.forkProcessWithPrefixAndNotTTY(task, {
                 temporaryOutputPath,
                 streamOutput,
                 taskGraph,
@@ -97,13 +96,19 @@ class ForkedProcessTaskRunner {
             });
         }
     }
+    async createPseudoTerminal() {
+        const terminal = new pseudo_terminal_1.PseudoTerminal(new native_1.RustPseudoTerminal());
+        await terminal.init();
+        terminal.onMessageFromChildren((message) => {
+            process.send(message);
+        });
+        return terminal;
+    }
     async forkProcessWithPseudoTerminal(task, { temporaryOutputPath, streamOutput, taskGraph, env, }) {
-        const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-        if (streamOutput) {
-            output_1.output.logCommand(args.join(' '));
-        }
         const childId = task.id;
-        const p = await this.pseudoTerminal.fork(childId, forkScript, {
+        const pseudoTerminal = await this.createPseudoTerminal();
+        this.pseudoTerminals.add(pseudoTerminal);
+        const p = await pseudoTerminal.fork(childId, forkScript, {
             cwd: process.cwd(),
             execArgv: process.execArgv,
             jsEnv: env,
@@ -124,6 +129,7 @@ class ForkedProcessTaskRunner {
             if (code > 128) {
                 process.exit(code);
             }
+            this.pseudoTerminals.delete(pseudoTerminal);
             this.processes.delete(p);
             this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
         });
@@ -215,16 +221,11 @@ class ForkedProcessTaskRunner {
         (0, fs_1.writeFileSync)(outputPath, content);
     }
     setupProcessEventListeners() {
-        if (this.pseudoTerminal) {
-            this.pseudoTerminal.onMessageFromChildren((message) => {
-                process.send(message);
-            });
-        }
         // When the nx process gets a message, it will be sent into the task's process
         process.on('message', (message) => {
-            if (this.pseudoTerminal) {
-                this.pseudoTerminal.sendMessageToChildren(message);
-            }
+            this.pseudoTerminals.forEach((p) => {
+                p.sendMessageToChildren(message);
+            });
             this.processes.forEach((p) => {
                 if ('send' in p) {
                     p.send(message);

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

@@ -1,6 +1,13 @@
 import { NxArgs } from '../utils/command-line-utils';
 import { Task, TaskGraph } from '../config/task-graph';
-import { TaskResult } from './life-cycle';
+import { LifeCycle, TaskResult } from './life-cycle';
+import type { ProjectGraph } from '../config/project-graph';
+import type { NxJsonConfiguration } from '../config/nx-json';
+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[];
@@ -11,3 +18,10 @@ export declare function initTasksRunner(nxArgs: NxArgs): Promise<{
         taskResults: Record<string, TaskResult>;
     }>;
 }>;
+export declare function runDiscreteTasks(tasks: Task[], projectGraph: ProjectGraph, taskGraphForHashing: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Promise<{
+    task: Task;
+    code: number;
+    status: import("./tasks-runner").TaskStatus;
+    terminalOutput?: string;
+}>[]>;
+export declare function runContinuousTasks(tasks: Task[], projectGraph: ProjectGraph, taskGraphForHashing: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Record<string, Promise<RunningTask>>>;

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

@@ -1,17 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initTasksRunner = initTasksRunner;
-const configuration_1 = require("../config/configuration");
+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, configuration_1.readNxJson)();
+    const nxJson = (0, nx_json_1.readNxJson)();
     if (nxArgs.verbose) {
         process.env.NX_VERBOSE_LOGGING = 'true';
     }
@@ -61,3 +72,45 @@ async function initTasksRunner(nxArgs) {
         },
     };
 }
+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 orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, projectGraph, taskGraph, nxJson, { ...options, parallel: tasks.length, lifeCycle: compositedLifeCycle }, false, client_1.daemonClient, undefined, taskGraphForHashing);
+    await orchestrator.init();
+    await Promise.all(tasks.map((task) => orchestrator.processTask(task.id)));
+    return orchestrator;
+}
+async function runDiscreteTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle);
+    return tasks.map((task, index) => orchestrator.applyFromCacheOrRunTask(true, task, index));
+}
+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,2 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+export declare function isTuiEnabled(nxJson?: NxJsonConfiguration): any;

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTuiEnabled = isTuiEnabled;
+const devkit_internals_1 = require("../devkit-internals");
+let tuiEnabled = undefined;
+function isTuiEnabled(nxJson) {
+    if (tuiEnabled !== undefined) {
+        return tuiEnabled;
+    }
+    // If the current terminal/environment is not capable of displaying the TUI, we don't run it
+    const isWindows = process.platform === 'win32';
+    const isCapable = process.stderr.isTTY && isUnicodeSupported();
+    // Windows is not working well right now, temporarily disable it on Windows even if it has been specified as enabled
+    // TODO(@JamesHenry): Remove this check once Windows issues are fixed.
+    if (!isCapable || isWindows) {
+        tuiEnabled = false;
+        process.env.NX_TUI = 'false';
+        return tuiEnabled;
+    }
+    // The environment variable takes precedence over the nx.json config
+    if (typeof process.env.NX_TUI === 'string') {
+        tuiEnabled = process.env.NX_TUI === 'true' ? true : false;
+        return tuiEnabled;
+    }
+    // Only read from disk if nx.json config is not already provided (and we have not been able to determine tuiEnabled based on the above checks)
+    if (!nxJson) {
+        nxJson = (0, devkit_internals_1.readNxJsonFromDisk)();
+    }
+    // Respect user config
+    if (typeof nxJson.tui?.enabled === 'boolean') {
+        tuiEnabled = Boolean(nxJson.tui?.enabled);
+    }
+    else {
+        // Default to enabling the TUI if the system is capable of displaying it
+        tuiEnabled = true;
+    }
+    // Also set the environment variable for consistency and ease of checking on the rust side, for example
+    process.env.NX_TUI = tuiEnabled.toString();
+    return tuiEnabled;
+}
+// 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

@@ -1,5 +1,6 @@
-import { TaskStatus } from './tasks-runner';
 import { Task } from '../config/task-graph';
+import { ExternalObject, TaskStatus as NativeTaskStatus } from '../native';
+import { TaskStatus } from './tasks-runner';
 /**
  * The result of a completed {@link Task}
  */
@@ -17,7 +18,7 @@ export interface TaskMetadata {
     groupId: number;
 }
 export interface LifeCycle {
-    startCommand?(): void | Promise<void>;
+    startCommand?(parallel?: number): void | Promise<void>;
     endCommand?(): void | Promise<void>;
     scheduleTask?(task: Task): void | Promise<void>;
     /**
@@ -35,11 +36,14 @@ export interface LifeCycle {
     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]>): Promise<void>;
+    setTaskStatus?(taskId: string, status: NativeTaskStatus): void;
+    registerForcedShutdownCallback?(callback: () => void): void;
 }
 export declare class CompositeLifeCycle implements LifeCycle {
     private readonly lifeCycles;
     constructor(lifeCycles: LifeCycle[]);
-    startCommand(): Promise<void>;
+    startCommand(parallel?: number): Promise<void>;
     endCommand(): Promise<void>;
     scheduleTask(task: Task): Promise<void>;
     startTask(task: Task): void;
@@ -47,4 +51,7 @@ export declare class CompositeLifeCycle implements LifeCycle {
     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]>): Promise<void>;
+    setTaskStatus(taskId: string, status: NativeTaskStatus): void;
+    registerForcedShutdownCallback(callback: () => void): void;
 }