nx 21.0.0-beta.1 → 21.0.0-beta.10

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;

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

@@ -33,7 +33,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 +120,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 +149,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 +169,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 +218,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 +292,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,27 +54,18 @@ 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) {
-    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);
+async function runAllTasks(options, context) {
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.initiatingTasks, context.projectGraph, context.taskGraph, context.nxJson, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.outputStyle);
     return orchestrator.run();
 }
 exports.default = exports.defaultTasksRunner;

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

@@ -2,17 +2,21 @@ 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 finishedProcesses;
+    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>;
+    cleanUpBatchProcesses(): void;
     forkProcessLegacy(task: Task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }: {
         temporaryOutputPath: string;
         streamOutput: boolean;
@@ -28,6 +32,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,24 @@ 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.finishedProcesses = new Set();
+        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,11 +51,20 @@ class ForkedProcessTaskRunner {
         cp.send({
             type: batch_messages_1.BatchMessageType.RunTasks,
             executorName,
+            projectGraph,
             batchTaskGraph,
             fullTaskGraph,
         });
         return cp;
     }
+    cleanUpBatchProcesses() {
+        if (this.finishedProcesses.size > 0) {
+            this.finishedProcesses.forEach((p) => {
+                p.kill();
+            });
+            this.finishedProcesses.clear();
+        }
+    }
     async forkProcessLegacy(task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }) {
         return pipeOutput
             ? this.forkProcessWithPrefixAndNotTTY(task, {
@@ -74,14 +81,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 +97,7 @@ class ForkedProcessTaskRunner {
             });
         }
         else {
-            return this.forkProcessWithPseudoTerminal(task, {
+            return this.forkProcessWithPrefixAndNotTTY(task, {
                 temporaryOutputPath,
                 streamOutput,
                 taskGraph,
@@ -97,13 +105,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,7 +138,11 @@ class ForkedProcessTaskRunner {
             if (code > 128) {
                 process.exit(code);
             }
+            this.pseudoTerminals.delete(pseudoTerminal);
             this.processes.delete(p);
+            if (!streamOutput) {
+                this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
+            }
             this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
         });
         return p;
@@ -215,46 +233,41 @@ class ForkedProcessTaskRunner {
         (0, fs_1.writeFileSync)(outputPath, content);
     }
     setupProcessEventListeners() {
-        if (this.pseudoTerminal) {
-            this.pseudoTerminal.onMessageFromChildren((message) => {
-                process.send(message);
+        const messageHandler = (message) => {
+            this.pseudoTerminals.forEach((p) => {
+                p.sendMessageToChildren(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.processes.forEach((p) => {
-                if ('send' in p) {
+                if ('connected' in p && p.connected && 'send' in p) {
                     p.send(message);
                 }
             });
-        });
-        // Terminate any task processes on exit
-        process.on('exit', () => {
+        };
+        // When the nx process gets a message, it will be sent into the task's process
+        process.on('message', messageHandler);
+        const cleanUp = (signal) => {
             this.processes.forEach((p) => {
-                p.kill();
+                p.kill(signal);
             });
+            process.off('message', messageHandler);
+            this.cleanUpBatchProcesses();
+        };
+        // Terminate any task processes on exit
+        process.once('exit', () => {
+            cleanUp();
         });
-        process.on('SIGINT', () => {
-            this.processes.forEach((p) => {
-                p.kill('SIGTERM');
-            });
+        process.once('SIGINT', () => {
+            cleanUp('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) => {
-                p.kill('SIGTERM');
-            });
+        process.once('SIGTERM', () => {
+            cleanUp('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) => {
-                p.kill('SIGTERM');
-            });
+        process.once('SIGHUP', () => {
+            cleanUp('SIGTERM');
             // no exit here because we expect child processes to terminate which
             // will store results to the cache and will terminate this process
         });

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

@@ -1,6 +1,13 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
 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 { 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';
     }
@@ -50,6 +61,7 @@ async function initTasksRunner(nxArgs) {
                 nxArgs: { ...nxArgs, parallel: opts.parallel },
                 loadDotEnvFiles: true,
                 initiatingProject: null,
+                initiatingTasks: [],
             });
             return {
                 status: Object.values(taskResults).some((taskResult) => taskResult.status === 'failure' || taskResult.status === 'skipped')
@@ -61,3 +73,51 @@ 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 nxArgs = {
+        ...options,
+        parallel: tasks.length,
+        lifeCycle: compositedLifeCycle,
+    };
+    (0, run_command_1.setEnvVarsBasedOnArgs)(nxArgs, true);
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, [], projectGraph, taskGraph, nxJson, nxArgs, false, client_1.daemonClient, undefined, taskGraphForHashing);
+    await orchestrator.init();
+    orchestrator.processTasks(tasks.map((task) => 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, skipCapableCheck?: boolean): any;