@ohos-ports/nx 17.3.2-beta.0

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

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvVariablesForTask = exports.getTaskSpecificEnv = exports.getEnvVariablesForBatchProcess = void 0;
+const dotenv_1 = require("dotenv");
+const dotenv_expand_1 = require("dotenv-expand");
+const workspace_root_1 = require("../utils/workspace-root");
+function getEnvVariablesForBatchProcess(skipNxCache, captureStderr) {
+    return {
+        // User Process Env Variables override Dotenv Variables
+        ...process.env,
+        // Nx Env Variables overrides everything
+        ...getNxEnvVariablesForForkedProcess(process.env.FORCE_COLOR === undefined ? 'true' : process.env.FORCE_COLOR, skipNxCache, captureStderr),
+    };
+}
+exports.getEnvVariablesForBatchProcess = getEnvVariablesForBatchProcess;
+function getTaskSpecificEnv(task) {
+    // Unload any dot env files at the root of the workspace that were loaded on init of Nx.
+    const taskEnv = unloadDotEnvFiles({ ...process.env });
+    return process.env.NX_LOAD_DOT_ENV_FILES === 'true'
+        ? loadDotEnvFilesForTask(task, taskEnv)
+        : // If not loading dot env files, ensure env vars created by system are still loaded
+            taskEnv;
+}
+exports.getTaskSpecificEnv = getTaskSpecificEnv;
+function getEnvVariablesForTask(task, taskSpecificEnv, forceColor, skipNxCache, captureStderr, outputPath, streamOutput) {
+    const res = {
+        // Start With Dotenv Variables
+        ...taskSpecificEnv,
+        // Nx Env Variables overrides everything
+        ...getNxEnvVariablesForTask(task, forceColor, skipNxCache, captureStderr, outputPath, streamOutput),
+    };
+    // we have to delete it because if we invoke Nx from within Nx, we need to reset those values
+    if (!outputPath) {
+        delete res.NX_TERMINAL_OUTPUT_PATH;
+        delete res.NX_STREAM_OUTPUT;
+        delete res.NX_PREFIX_OUTPUT;
+    }
+    // we don't reset NX_BASE or NX_HEAD because those are set by the user and should be preserved
+    delete res.NX_SET_CLI;
+    return res;
+}
+exports.getEnvVariablesForTask = getEnvVariablesForTask;
+function getNxEnvVariablesForForkedProcess(forceColor, skipNxCache, captureStderr, outputPath, streamOutput) {
+    const env = {
+        FORCE_COLOR: forceColor,
+        NX_WORKSPACE_ROOT: workspace_root_1.workspaceRoot,
+        NX_SKIP_NX_CACHE: skipNxCache ? 'true' : undefined,
+    };
+    if (outputPath) {
+        env.NX_TERMINAL_OUTPUT_PATH = outputPath;
+        if (captureStderr) {
+            env.NX_TERMINAL_CAPTURE_STDERR = 'true';
+        }
+        if (streamOutput) {
+            env.NX_STREAM_OUTPUT = 'true';
+        }
+    }
+    return env;
+}
+function getNxEnvVariablesForTask(task, forceColor, skipNxCache, captureStderr, outputPath, streamOutput) {
+    const env = {
+        NX_TASK_TARGET_PROJECT: task.target.project,
+        NX_TASK_TARGET_TARGET: task.target.target,
+        NX_TASK_TARGET_CONFIGURATION: task.target.configuration ?? undefined,
+        NX_TASK_HASH: task.hash,
+        // used when Nx is invoked via Lerna
+        LERNA_PACKAGE_NAME: task.target.project,
+    };
+    // TODO: remove this once we have a reasonable way to configure it
+    if (task.target.target === 'test') {
+        env.NX_TERMINAL_CAPTURE_STDERR = 'true';
+    }
+    return {
+        ...getNxEnvVariablesForForkedProcess(forceColor, skipNxCache, captureStderr, outputPath, streamOutput),
+        ...env,
+    };
+}
+function loadDotEnvFilesForTask(task, environmentVariables) {
+    // Collect dot env files that may pertain to a task
+    const dotEnvFiles = [
+        // Load DotEnv Files for a configuration in the project root
+        ...(task.target.configuration
+            ? [
+                `${task.projectRoot}/.env.${task.target.target}.${task.target.configuration}`,
+                `${task.projectRoot}/.env.${task.target.configuration}`,
+                `${task.projectRoot}/.${task.target.target}.${task.target.configuration}.env`,
+                `${task.projectRoot}/.${task.target.configuration}.env`,
+            ]
+            : []),
+        // Load DotEnv Files for a target in the project root
+        `${task.projectRoot}/.env.${task.target.target}`,
+        `${task.projectRoot}/.${task.target.target}.env`,
+        `${task.projectRoot}/.env.local`,
+        `${task.projectRoot}/.local.env`,
+        `${task.projectRoot}/.env`,
+        // Load DotEnv Files for a configuration in the workspace root
+        ...(task.target.configuration
+            ? [
+                `.env.${task.target.target}.${task.target.configuration}`,
+                `.env.${task.target.configuration}`,
+                `.${task.target.target}.${task.target.configuration}.env`,
+                `.${task.target.configuration}.env`,
+            ]
+            : []),
+        // Load DotEnv Files for a target in the workspace root
+        `.env.${task.target.target}`,
+        `.${task.target.target}.env`,
+        // Load base DotEnv Files at workspace root
+        `.local.env`,
+        `.env.local`,
+        `.env`,
+    ];
+    for (const file of dotEnvFiles) {
+        const myEnv = (0, dotenv_1.config)({
+            path: file,
+            processEnv: environmentVariables,
+            // Do not override existing env variables as we load
+            override: false,
+        });
+        environmentVariables = {
+            ...(0, dotenv_expand_1.expand)({
+                ...myEnv,
+                ignoreProcessEnv: true, // Do not override existing env variables as we load
+            }).parsed,
+            ...environmentVariables,
+        };
+    }
+    return environmentVariables;
+}
+function unloadDotEnvFiles(environmentVariables) {
+    const unloadDotEnvFile = (filename) => {
+        let parsedDotEnvFile = {};
+        (0, dotenv_1.config)({ path: filename, processEnv: parsedDotEnvFile });
+        Object.keys(parsedDotEnvFile).forEach((envVarKey) => {
+            if (environmentVariables[envVarKey] === parsedDotEnvFile[envVarKey]) {
+                delete environmentVariables[envVarKey];
+            }
+        });
+    };
+    for (const file of ['.env', '.local.env', '.env.local']) {
+        unloadDotEnvFile(file);
+    }
+    return environmentVariables;
+}

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

@@ -0,0 +1,7 @@
+export declare function findCycle(taskGraph: {
+    dependencies: Record<string, string[]>;
+}): string[] | null;
+export declare function makeAcyclic(graph: {
+    roots: string[];
+    dependencies: Record<string, string[]>;
+}): void;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAcyclic = exports.findCycle = void 0;
+function _findCycle(graph, id, visited, path) {
+    if (visited[id])
+        return null;
+    visited[id] = true;
+    for (const d of graph.dependencies[id]) {
+        if (path.includes(d))
+            return [...path, d];
+        const cycle = _findCycle(graph, d, visited, [...path, d]);
+        if (cycle)
+            return cycle;
+    }
+    return null;
+}
+function findCycle(taskGraph) {
+    const visited = {};
+    for (const t of Object.keys(taskGraph.dependencies)) {
+        visited[t] = false;
+    }
+    for (const t of Object.keys(taskGraph.dependencies)) {
+        const cycle = _findCycle(taskGraph, t, visited, [t]);
+        if (cycle)
+            return cycle;
+    }
+    return null;
+}
+exports.findCycle = findCycle;
+function _makeAcyclic(graph, id, visited, path) {
+    if (visited[id])
+        return;
+    visited[id] = true;
+    const deps = graph.dependencies[id];
+    for (const d of [...deps]) {
+        if (path.includes(d)) {
+            deps.splice(deps.indexOf(d), 1);
+        }
+        else {
+            _makeAcyclic(graph, d, visited, [...path, d]);
+        }
+    }
+    return null;
+}
+function makeAcyclic(graph) {
+    const visited = {};
+    for (const t of Object.keys(graph.dependencies)) {
+        visited[t] = false;
+    }
+    for (const t of Object.keys(graph.dependencies)) {
+        _makeAcyclic(graph, t, visited, [t]);
+    }
+    graph.roots = Object.keys(graph.dependencies).filter((t) => graph.dependencies[t].length === 0);
+}
+exports.makeAcyclic = makeAcyclic;

package/src/tasks-runner/task-orchestrator.d.ts

@@ -0,0 +1,50 @@
+import { TaskHasher } from '../hasher/task-hasher';
+import { DefaultTasksRunnerOptions } from './default-tasks-runner';
+import { TaskStatus } from './tasks-runner';
+import { ProjectGraph } from '../config/project-graph';
+import { TaskGraph } from '../config/task-graph';
+import { DaemonClient } from '../daemon/client/client';
+export declare class TaskOrchestrator {
+    private readonly hasher;
+    private readonly initiatingProject;
+    private readonly projectGraph;
+    private readonly taskGraph;
+    private readonly options;
+    private readonly bail;
+    private readonly daemon;
+    private cache;
+    private forkedProcessTaskRunner;
+    private tasksSchedule;
+    private batchEnv;
+    private reverseTaskDeps;
+    private processedTasks;
+    private processedBatches;
+    private completedTasks;
+    private waitingForTasks;
+    private groups;
+    private bailed;
+    constructor(hasher: TaskHasher, initiatingProject: string | undefined, projectGraph: ProjectGraph, taskGraph: TaskGraph, options: DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient);
+    run(): Promise<{
+        [id: string]: TaskStatus;
+    }>;
+    private executeNextBatchOfTasksUsingTaskSchedule;
+    private processScheduledTask;
+    private processScheduledBatch;
+    private processAllScheduledTasks;
+    private applyCachedResults;
+    private applyCachedResult;
+    private applyFromCacheOrRunBatch;
+    private runBatch;
+    private applyFromCacheOrRunTask;
+    private runTaskInForkedProcess;
+    private preRunSteps;
+    private postRunSteps;
+    private scheduleNextTasks;
+    private complete;
+    private pipeOutputCapture;
+    private shouldCacheTaskResult;
+    private closeGroup;
+    private openGroup;
+    private shouldCopyOutputsFromCache;
+    private recordOutputsHash;
+}

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

@@ -0,0 +1,375 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskOrchestrator = void 0;
+const events_1 = require("events");
+const perf_hooks_1 = require("perf_hooks");
+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");
+class TaskOrchestrator {
+    // endregion internal state
+    constructor(hasher, initiatingProject, projectGraph, taskGraph, options, bail, daemon) {
+        this.hasher = hasher;
+        this.initiatingProject = initiatingProject;
+        this.projectGraph = projectGraph;
+        this.taskGraph = taskGraph;
+        this.options = options;
+        this.bail = bail;
+        this.daemon = daemon;
+        this.cache = new cache_1.Cache(this.options);
+        this.forkedProcessTaskRunner = new forked_process_task_runner_1.ForkedProcessTaskRunner(this.options);
+        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);
+        this.reverseTaskDeps = (0, utils_1.calculateReverseDeps)(this.taskGraph);
+        this.processedTasks = new Map();
+        this.processedBatches = new Map();
+        this.completedTasks = {};
+        this.waitingForTasks = [];
+        this.groups = [];
+        this.bailed = false;
+    }
+    async run() {
+        // Init the ForkedProcessTaskRunner
+        await this.forkedProcessTaskRunner.init();
+        // initial scheduling
+        await this.scheduleNextTasks();
+        perf_hooks_1.performance.mark('task-execution:start');
+        const threads = [];
+        process.stdout.setMaxListeners(this.options.parallel + events_1.defaultMaxListeners);
+        process.stderr.setMaxListeners(this.options.parallel + events_1.defaultMaxListeners);
+        // initial seeding of the queue
+        for (let i = 0; i < this.options.parallel; ++i) {
+            threads.push(this.executeNextBatchOfTasksUsingTaskSchedule());
+        }
+        await Promise.all(threads);
+        perf_hooks_1.performance.mark('task-execution:end');
+        perf_hooks_1.performance.measure('task-execution', 'task-execution:start', 'task-execution:end');
+        this.forkedProcessTaskRunner.destroy();
+        this.cache.removeOldCacheRecords();
+        return this.completedTasks;
+    }
+    async executeNextBatchOfTasksUsingTaskSchedule() {
+        // completed all the tasks
+        if (!this.tasksSchedule.hasTasks() || this.bailed) {
+            return null;
+        }
+        const doNotSkipCache = this.options.skipNxCache === false ||
+            this.options.skipNxCache === undefined;
+        const batch = this.tasksSchedule.nextBatch();
+        if (batch) {
+            const groupId = this.closeGroup();
+            await this.applyFromCacheOrRunBatch(doNotSkipCache, batch, groupId);
+            this.openGroup(groupId);
+            return this.executeNextBatchOfTasksUsingTaskSchedule();
+        }
+        const task = this.tasksSchedule.nextTask();
+        if (task) {
+            const groupId = this.closeGroup();
+            await this.applyFromCacheOrRunTask(doNotSkipCache, task, groupId);
+            this.openGroup(groupId);
+            return this.executeNextBatchOfTasksUsingTaskSchedule();
+        }
+        // block until some other task completes, then try again
+        return new Promise((res) => this.waitingForTasks.push(res)).then(() => this.executeNextBatchOfTasksUsingTaskSchedule());
+    }
+    // region Processing Scheduled Tasks
+    async processScheduledTask(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.options.lifeCycle.scheduleTask(task);
+        return taskSpecificEnv;
+    }
+    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.options.lifeCycle.scheduleTask(task);
+        }));
+    }
+    processAllScheduledTasks() {
+        const { scheduledTasks, scheduledBatches } = this.tasksSchedule.getAllScheduledTasks();
+        for (const batch of scheduledBatches) {
+            this.processedBatches.set(batch, this.processScheduledBatch(batch));
+        }
+        for (const taskId of scheduledTasks) {
+            // Task is already handled or being handled
+            if (!this.processedTasks.has(taskId)) {
+                this.processedTasks.set(taskId, this.processScheduledTask(taskId));
+            }
+        }
+    }
+    // endregion Processing Scheduled Tasks
+    // region Applying Cache
+    async applyCachedResults(tasks) {
+        const cacheableTasks = tasks.filter((t) => (0, utils_1.isCacheableTask)(t, this.options));
+        const res = await Promise.all(cacheableTasks.map((t) => this.applyCachedResult(t)));
+        return res.filter((r) => r !== null);
+    }
+    async applyCachedResult(task) {
+        task.startTime = Date.now();
+        const cachedResult = await this.cache.get(task);
+        if (!cachedResult || cachedResult.code !== 0)
+            return null;
+        const outputs = task.outputs;
+        const shouldCopyOutputsFromCache = !!outputs.length &&
+            (await this.shouldCopyOutputsFromCache(outputs, task.hash));
+        if (shouldCopyOutputsFromCache) {
+            await this.cache.copyFilesFromCache(task.hash, cachedResult, outputs);
+        }
+        task.endTime = Date.now();
+        const status = cachedResult.remote
+            ? 'remote-cache'
+            : shouldCopyOutputsFromCache
+                ? 'local-cache'
+                : 'local-cache-kept-existing';
+        this.options.lifeCycle.printTaskTerminalOutput(task, status, cachedResult.terminalOutput);
+        return {
+            task,
+            status,
+        };
+    }
+    // endregion Applying Cache
+    // region Batch
+    async applyFromCacheOrRunBatch(doNotSkipCache, batch, groupId) {
+        const taskEntries = Object.entries(batch.taskGraph.tasks);
+        const tasks = taskEntries.map(([, task]) => task);
+        // Wait for batch to be processed
+        await this.processedBatches.get(batch);
+        await this.preRunSteps(tasks, { groupId });
+        let results = doNotSkipCache ? await this.applyCachedResults(tasks) : [];
+        // Run tasks that were not cached
+        if (results.length !== taskEntries.length) {
+            const unrunTaskGraph = (0, utils_1.removeTasksFromTaskGraph)(batch.taskGraph, results.map(({ task }) => task.id));
+            const batchResults = await this.runBatch({
+                executorName: batch.executorName,
+                taskGraph: unrunTaskGraph,
+            }, this.batchEnv);
+            results.push(...batchResults);
+        }
+        await this.postRunSteps(tasks, results, doNotSkipCache, { groupId });
+        const tasksCompleted = taskEntries.filter(([taskId]) => this.completedTasks[taskId]);
+        // Batch is still not done, run it again
+        if (tasksCompleted.length !== taskEntries.length) {
+            await this.applyFromCacheOrRunBatch(doNotSkipCache, {
+                executorName: batch.executorName,
+                taskGraph: (0, utils_1.removeTasksFromTaskGraph)(batch.taskGraph, tasksCompleted.map(([taskId]) => taskId)),
+            }, groupId);
+        }
+    }
+    async runBatch(batch, env) {
+        try {
+            const results = await this.forkedProcessTaskRunner.forkProcessForBatch(batch, this.taskGraph, env);
+            const batchResultEntries = Object.entries(results);
+            return batchResultEntries.map(([taskId, result]) => ({
+                ...result,
+                task: {
+                    ...this.taskGraph.tasks[taskId],
+                    startTime: result.startTime,
+                    endTime: result.endTime,
+                },
+                status: (result.success ? 'success' : 'failure'),
+                terminalOutput: result.terminalOutput,
+            }));
+        }
+        catch (e) {
+            return batch.taskGraph.roots.map((rootTaskId) => ({
+                task: this.taskGraph.tasks[rootTaskId],
+                status: 'failure',
+            }));
+        }
+    }
+    // endregion Batch
+    // region Single Task
+    async applyFromCacheOrRunTask(doNotSkipCache, task, groupId) {
+        // Wait for task to be processed
+        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 = (0, utils_1.shouldStreamOutput)(task, this.initiatingProject);
+        const 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);
+        let results = doNotSkipCache ? await this.applyCachedResults([task]) : [];
+        // the task wasn't cached
+        if (results.length === 0) {
+            // cache prep
+            const { code, terminalOutput } = await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
+            results.push({
+                task,
+                status: code === 0 ? 'success' : 'failure',
+                terminalOutput,
+            });
+        }
+        await this.postRunSteps([task], results, doNotSkipCache, { groupId });
+    }
+    async runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput) {
+        try {
+            // execution
+            const { code, terminalOutput } = process.env.NX_NATIVE_COMMAND_RUNNER !== 'false'
+                ? await this.forkedProcessTaskRunner.forkProcess(task, {
+                    temporaryOutputPath,
+                    streamOutput,
+                    pipeOutput,
+                    taskGraph: this.taskGraph,
+                    env,
+                })
+                : await this.forkedProcessTaskRunner.forkProcessLegacy(task, {
+                    temporaryOutputPath,
+                    streamOutput,
+                    pipeOutput,
+                    taskGraph: this.taskGraph,
+                    env,
+                });
+            return {
+                code,
+                terminalOutput,
+            };
+        }
+        catch (e) {
+            return {
+                code: 1,
+            };
+        }
+    }
+    // endregion Single Task
+    // region Lifecycle
+    async preRunSteps(tasks, metadata) {
+        this.options.lifeCycle.startTasks(tasks, metadata);
+    }
+    async postRunSteps(tasks, results, doNotSkipCache, { groupId }) {
+        for (const task of tasks) {
+            await this.recordOutputsHash(task);
+        }
+        if (doNotSkipCache) {
+            // cache the results
+            perf_hooks_1.performance.mark('cache-results-start');
+            await Promise.all(results
+                .filter(({ status }) => status !== 'local-cache' &&
+                status !== 'local-cache-kept-existing' &&
+                status !== 'remote-cache' &&
+                status !== 'skipped')
+                .map((result) => ({
+                ...result,
+                code: result.status === 'local-cache' ||
+                    result.status === 'local-cache-kept-existing' ||
+                    result.status === 'remote-cache' ||
+                    result.status === 'success'
+                    ? 0
+                    : 1,
+                outputs: result.task.outputs,
+            }))
+                .filter(({ task, code }) => this.shouldCacheTaskResult(task, code))
+                .filter(({ terminalOutput, outputs }) => terminalOutput || outputs)
+                .map(async ({ task, code, terminalOutput, outputs }) => this.cache.put(task, terminalOutput, outputs, code)));
+            perf_hooks_1.performance.mark('cache-results-end');
+            perf_hooks_1.performance.measure('cache-results', 'cache-results-start', 'cache-results-end');
+        }
+        this.options.lifeCycle.endTasks(results.map((result) => {
+            const code = result.status === 'success' ||
+                result.status === 'local-cache' ||
+                result.status === 'local-cache-kept-existing' ||
+                result.status === 'remote-cache'
+                ? 0
+                : 1;
+            return {
+                ...result,
+                task: result.task,
+                status: result.status,
+                code,
+            };
+        }), { groupId });
+        this.complete(results.map(({ task, status }) => {
+            return {
+                taskId: task.id,
+                status,
+            };
+        }));
+        await this.scheduleNextTasks();
+        // release blocked threads
+        this.waitingForTasks.forEach((f) => f(null));
+        this.waitingForTasks.length = 0;
+    }
+    async scheduleNextTasks() {
+        await this.tasksSchedule.scheduleNextTasks();
+        this.processAllScheduledTasks();
+    }
+    complete(taskResults) {
+        this.tasksSchedule.complete(taskResults.map(({ taskId }) => taskId));
+        for (const { taskId, status } of taskResults) {
+            if (this.completedTasks[taskId] === undefined) {
+                this.completedTasks[taskId] = status;
+                if (status === 'failure' || status === 'skipped') {
+                    if (this.bail) {
+                        // mark the execution as bailed which will stop all further execution
+                        // only the tasks that are currently running will finish
+                        this.bailed = true;
+                    }
+                    else {
+                        // only mark the packages that depend on the current task as skipped
+                        // other tasks will continue to execute
+                        this.complete(this.reverseTaskDeps[taskId].map((depTaskId) => ({
+                            taskId: depTaskId,
+                            status: 'skipped',
+                        })));
+                    }
+                }
+            }
+        }
+    }
+    //endregion Lifecycle
+    // region utils
+    async pipeOutputCapture(task) {
+        try {
+            if (process.env.NX_NATIVE_COMMAND_RUNNER !== 'false') {
+                return true;
+            }
+            const { schema } = await (0, utils_1.getExecutorForTask)(task, this.projectGraph);
+            return (schema.outputCapture === 'pipe' ||
+                process.env.NX_STREAM_OUTPUT === 'true');
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    shouldCacheTaskResult(task, code) {
+        return ((0, utils_1.isCacheableTask)(task, this.options) &&
+            (process.env.NX_CACHE_FAILURES == 'true' ? true : code === 0));
+    }
+    closeGroup() {
+        for (let i = 0; i < this.options.parallel; i++) {
+            if (!this.groups[i]) {
+                this.groups[i] = true;
+                return i;
+            }
+        }
+    }
+    openGroup(id) {
+        this.groups[id] = false;
+    }
+    async shouldCopyOutputsFromCache(outputs, hash) {
+        if (this.daemon?.enabled()) {
+            return !(await this.daemon.outputsHashesMatch(outputs, hash));
+        }
+        else {
+            return true;
+        }
+    }
+    async recordOutputsHash(task) {
+        if (this.daemon?.enabled()) {
+            return this.daemon.recordOutputsHash(task.outputs, task.hash);
+        }
+    }
+}
+exports.TaskOrchestrator = TaskOrchestrator;

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

@@ -0,0 +1,23 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+import { Task, TaskGraph } from '../config/task-graph';
+import { NxArgs } from '../utils/command-line-utils';
+import { TaskHasher } from '../hasher/task-hasher';
+import { DaemonClient } from '../daemon/client/client';
+export type TaskStatus = 'success' | 'failure' | 'skipped' | 'local-cache-kept-existing' | 'local-cache' | 'remote-cache';
+/**
+ * `any | Promise<{ [id: string]: TaskStatus }>`
+ * will change to Promise<{ [id: string]: TaskStatus }> after Nx 15 is released.
+ */
+export type TasksRunner<T = unknown> = (tasks: Task[], options: T, context?: {
+    target?: string;
+    initiatingProject?: string | null;
+    projectGraph: ProjectGraph;
+    nxJson: NxJsonConfiguration;
+    nxArgs: NxArgs;
+    taskGraph?: TaskGraph;
+    hasher?: TaskHasher;
+    daemon?: DaemonClient;
+}) => any | Promise<{
+    [id: string]: TaskStatus;
+}>;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });