@ohos-ports/nx 17.3.2-beta.0

package/src/tasks-runner/life-cycles/view-logs-utils.d.ts

@@ -0,0 +1 @@
+export declare function viewLogsFooterRows(failedTasks: number): string[];

package/src/tasks-runner/life-cycles/view-logs-utils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.viewLogsFooterRows = void 0;
+const nx_json_1 = require("../../config/nx-json");
+const nx_cloud_utils_1 = require("../../utils/nx-cloud-utils");
+const output_1 = require("../../utils/output");
+const VIEW_LOGS_MESSAGE = `Hint: Try "nx view-logs" to get structured, searchable errors logs in your browser.`;
+function viewLogsFooterRows(failedTasks) {
+    if (failedTasks >= 2 && !(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
+        return [``, output_1.output.dim(`${output_1.output.X_PADDING} ${VIEW_LOGS_MESSAGE}`)];
+    }
+    else {
+        return [];
+    }
+}
+exports.viewLogsFooterRows = viewLogsFooterRows;

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

@@ -0,0 +1,49 @@
+/**
+ * Node IPC is specific to Node, but when spawning child processes in Rust, it won't have IPC.
+ *
+ * Thus, this is a wrapper which is spawned by Rust, which will create a Node IPC channel and pipe it to a ZeroMQ Channel
+ *
+ * Main Nx Process
+ *   * Calls Rust Fork Function
+ *     * `node fork.js`
+ *     * Create a Rust - Node.js Agnostic Channel aka Psuedo IPC Channel
+ *     * This returns RustChildProcess
+ *         * RustChildProcess.onMessage(msg => ());
+ *         * psuedo_ipc_channel.on_message() => tx.send(msg);
+ *   * Node.js Fork Wrapper (fork.js)
+ *     * fork(run-command.js) with `inherit` and `ipc`
+ *         * This will create a Node IPC Channel
+ *     * channel = getPsuedoIpcChannel(process.env.NX_IPC_CHANNEL_ID)
+ *     * forkChildProcess.on('message', writeToPsuedoIpcChannel)
+ */
+/// <reference types="node" />
+import { Serializable } from 'child_process';
+export interface PsuedoIPCMessage {
+    type: 'TO_CHILDREN_FROM_PARENT' | 'TO_PARENT_FROM_CHILDREN' | 'CHILD_READY';
+    id: string | undefined;
+    message: Serializable;
+}
+export declare class PsuedoIPCServer {
+    private path;
+    private sockets;
+    private server;
+    private childMessages;
+    constructor(path: string);
+    init(): Promise<void>;
+    private childReadyMap;
+    waitForChildReady(childId: string): Promise<void>;
+    private registerChildMessages;
+    sendMessageToChildren(message: Serializable): void;
+    sendMessageToChild(id: string, message: Serializable): void;
+    onMessageFromChildren(onMessage: (message: Serializable) => void, onClose?: () => void, onError?: (err: Error) => void): void;
+    close(): void;
+}
+export declare class PsuedoIPCClient {
+    private path;
+    private socket;
+    constructor(path: string);
+    sendMessageToParent(message: Serializable): void;
+    notifyChildIsReady(id: string): void;
+    onMessageFromParent(forkId: string, onMessage: (message: Serializable) => void, onClose?: () => void, onError?: (err: Error) => void): this;
+    close(): void;
+}

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

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * Node IPC is specific to Node, but when spawning child processes in Rust, it won't have IPC.
+ *
+ * Thus, this is a wrapper which is spawned by Rust, which will create a Node IPC channel and pipe it to a ZeroMQ Channel
+ *
+ * Main Nx Process
+ *   * Calls Rust Fork Function
+ *     * `node fork.js`
+ *     * Create a Rust - Node.js Agnostic Channel aka Psuedo IPC Channel
+ *     * This returns RustChildProcess
+ *         * RustChildProcess.onMessage(msg => ());
+ *         * psuedo_ipc_channel.on_message() => tx.send(msg);
+ *   * Node.js Fork Wrapper (fork.js)
+ *     * fork(run-command.js) with `inherit` and `ipc`
+ *         * This will create a Node IPC Channel
+ *     * channel = getPsuedoIpcChannel(process.env.NX_IPC_CHANNEL_ID)
+ *     * forkChildProcess.on('message', writeToPsuedoIpcChannel)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsuedoIPCClient = exports.PsuedoIPCServer = void 0;
+const net_1 = require("net");
+const consume_messages_from_socket_1 = require("../utils/consume-messages-from-socket");
+class PsuedoIPCServer {
+    constructor(path) {
+        this.path = path;
+        this.sockets = new Set();
+        this.childMessages = [];
+        this.childReadyMap = new Map();
+    }
+    init() {
+        return new Promise((res) => {
+            this.server = new net_1.Server((socket) => {
+                this.sockets.add(socket);
+                this.registerChildMessages(socket);
+                socket.on('close', () => {
+                    this.sockets.delete(socket);
+                });
+            });
+            this.server.listen(this.path, () => {
+                res();
+            });
+        });
+    }
+    async waitForChildReady(childId) {
+        return new Promise((res) => {
+            this.childReadyMap.set(childId, res);
+        });
+    }
+    registerChildMessages(socket) {
+        socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(async (rawMessage) => {
+            const { type, message } = JSON.parse(rawMessage);
+            if (type === 'TO_PARENT_FROM_CHILDREN') {
+                for (const childMessage of this.childMessages) {
+                    childMessage.onMessage(message);
+                }
+            }
+            else if (type === 'CHILD_READY') {
+                const childId = message;
+                if (this.childReadyMap.has(childId)) {
+                    this.childReadyMap.get(childId)();
+                }
+            }
+        }));
+        socket.on('close', () => {
+            for (const childMessage of this.childMessages) {
+                childMessage.onClose?.();
+            }
+        });
+        socket.on('error', (err) => {
+            for (const childMessage of this.childMessages) {
+                childMessage.onError?.(err);
+            }
+        });
+    }
+    sendMessageToChildren(message) {
+        this.sockets.forEach((socket) => {
+            socket.write(JSON.stringify({ type: 'TO_CHILDREN_FROM_PARENT', message }));
+            // send EOT to indicate that the message has been fully written
+            socket.write(String.fromCodePoint(4));
+        });
+    }
+    sendMessageToChild(id, message) {
+        this.sockets.forEach((socket) => {
+            socket.write(JSON.stringify({ type: 'TO_CHILDREN_FROM_PARENT', id, message }));
+            socket.write(String.fromCodePoint(4));
+        });
+    }
+    onMessageFromChildren(onMessage, onClose = () => { }, onError = (err) => { }) {
+        this.childMessages.push({
+            onMessage,
+            onClose,
+            onError,
+        });
+    }
+    close() {
+        this.server?.close();
+        this.sockets.forEach((s) => s.destroy());
+    }
+}
+exports.PsuedoIPCServer = PsuedoIPCServer;
+class PsuedoIPCClient {
+    constructor(path) {
+        this.path = path;
+        this.socket = (0, net_1.connect)(this.path);
+    }
+    sendMessageToParent(message) {
+        this.socket.write(JSON.stringify({ type: 'TO_PARENT_FROM_CHILDREN', message }));
+        // send EOT to indicate that the message has been fully written
+        this.socket.write(String.fromCodePoint(4));
+    }
+    notifyChildIsReady(id) {
+        this.socket.write(JSON.stringify({
+            type: 'CHILD_READY',
+            message: id,
+        }));
+        // send EOT to indicate that the message has been fully written
+        this.socket.write(String.fromCodePoint(4));
+    }
+    onMessageFromParent(forkId, onMessage, onClose = () => { }, onError = (err) => { }) {
+        this.socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(async (rawMessage) => {
+            const { id, type, message } = JSON.parse(rawMessage);
+            if (type === 'TO_CHILDREN_FROM_PARENT') {
+                if (id && id === forkId) {
+                    onMessage(message);
+                }
+                else if (id === undefined) {
+                    onMessage(message);
+                }
+            }
+        }));
+        this.socket.on('close', onClose);
+        this.socket.on('error', onError);
+        return this;
+    }
+    close() {
+        this.socket?.destroy();
+    }
+}
+exports.PsuedoIPCClient = PsuedoIPCClient;

package/src/tasks-runner/remove-old-cache-records.d.ts

@@ -0,0 +1 @@
+export {};

package/src/tasks-runner/remove-old-cache-records.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const WEEK_IN_MS = 1000 * 60 * 60 * 24 * 7;
+const folder = process.argv[2];
+removeOld(terminalOutputs());
+removeOld(cachedFiles());
+function terminalOutputs() {
+    try {
+        return (0, fs_1.readdirSync)((0, path_1.join)(folder, 'terminalOutputs')).map((f) => (0, path_1.join)(folder, 'terminalOutputs', f));
+    }
+    catch (e) {
+        return [];
+    }
+}
+function cachedFiles() {
+    try {
+        return (0, fs_1.readdirSync)(folder)
+            .filter((f) => !f.endsWith('terminalOutputs'))
+            .map((f) => (0, path_1.join)(folder, f));
+    }
+    catch (e) {
+        return [];
+    }
+}
+function removeOld(records) {
+    try {
+        const time = mostRecentMTime(records);
+        records.forEach((r) => {
+            try {
+                const s = (0, fs_1.statSync)(r);
+                if (time - s.mtimeMs > WEEK_IN_MS) {
+                    if (s.isDirectory()) {
+                        try {
+                            (0, fs_extra_1.removeSync)(`${r}.commit`);
+                        }
+                        catch (e) { }
+                    }
+                    (0, fs_extra_1.removeSync)(r);
+                }
+            }
+            catch (e) { }
+        });
+    }
+    catch (e) { }
+}
+function mostRecentMTime(records) {
+    let mostRecentTime = 0;
+    records.forEach((r) => {
+        try {
+            const s = (0, fs_1.statSync)(r);
+            if (s.mtimeMs > mostRecentTime) {
+                mostRecentTime = s.mtimeMs;
+            }
+        }
+        catch (e) { }
+    });
+    return mostRecentTime;
+}

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

@@ -0,0 +1,28 @@
+import { TasksRunner } from './tasks-runner';
+import { NxArgs } from '../utils/command-line-utils';
+import { LifeCycle } from './life-cycle';
+import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { NxJsonConfiguration } from '../config/nx-json';
+import { Task, TaskGraph } from '../config/task-graph';
+import { TargetDependencyConfig } from '../config/workspace-json-project-json';
+export declare function runCommand(projectsToRun: ProjectGraphProjectNode[], projectGraph: ProjectGraph, { nxJson }: {
+    nxJson: NxJsonConfiguration;
+}, nxArgs: NxArgs, overrides: any, initiatingProject: string | null, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, extraOptions: {
+    excludeTaskDependencies: boolean;
+    loadDotEnvFiles: boolean;
+}): Promise<NodeJS.Process['exitCode']>;
+export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, }: {
+    tasks: Task[];
+    projectGraph: ProjectGraph;
+    taskGraph: TaskGraph;
+    lifeCycle: LifeCycle;
+    nxJson: NxJsonConfiguration;
+    nxArgs: NxArgs;
+    loadDotEnvFiles: boolean;
+    initiatingProject: string | null;
+}): Promise<1 | 0>;
+export declare function getRunner(nxArgs: NxArgs, nxJson: NxJsonConfiguration): {
+    tasksRunner: TasksRunner;
+    runnerOptions: any;
+};
+export declare function getRunnerOptions(runner: string, nxJson: NxJsonConfiguration<string[] | '*'>, nxArgs: NxArgs, isCloudDefault: boolean): any;

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

@@ -0,0 +1,353 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRunnerOptions = exports.getRunner = exports.invokeTasksRunner = exports.runCommand = void 0;
+const path_1 = require("path");
+const workspace_root_1 = require("../utils/workspace-root");
+const fileutils_1 = require("../utils/fileutils");
+const output_1 = require("../utils/output");
+const utils_1 = require("./utils");
+const life_cycle_1 = require("./life-cycle");
+const static_run_many_terminal_output_life_cycle_1 = require("./life-cycles/static-run-many-terminal-output-life-cycle");
+const static_run_one_terminal_output_life_cycle_1 = require("./life-cycles/static-run-one-terminal-output-life-cycle");
+const task_timings_life_cycle_1 = require("./life-cycles/task-timings-life-cycle");
+const dynamic_run_many_terminal_output_life_cycle_1 = require("./life-cycles/dynamic-run-many-terminal-output-life-cycle");
+const task_profiling_life_cycle_1 = require("./life-cycles/task-profiling-life-cycle");
+const is_ci_1 = require("../utils/is-ci");
+const dynamic_run_one_terminal_output_life_cycle_1 = require("./life-cycles/dynamic-run-one-terminal-output-life-cycle");
+const create_task_graph_1 = require("./create-task-graph");
+const task_graph_utils_1 = require("./task-graph-utils");
+const params_1 = require("../utils/params");
+const hash_task_1 = require("../hasher/hash-task");
+const client_1 = require("../daemon/client/client");
+const store_run_information_life_cycle_1 = require("./life-cycles/store-run-information-life-cycle");
+const create_task_hasher_1 = require("../hasher/create-task-hasher");
+async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides) {
+    const { runnerOptions } = getRunner(nxArgs, nxJson);
+    const isRunOne = initiatingProject != null;
+    const useDynamicOutput = shouldUseDynamicLifeCycle(tasks, runnerOptions, nxArgs.outputStyle);
+    const overridesWithoutHidden = { ...overrides };
+    delete overridesWithoutHidden['__overrides_unparsed__'];
+    if (isRunOne) {
+        if (useDynamicOutput) {
+            return await (0, dynamic_run_one_terminal_output_life_cycle_1.createRunOneDynamicOutputRenderer)({
+                initiatingProject,
+                tasks,
+                args: nxArgs,
+                overrides: overridesWithoutHidden,
+            });
+        }
+        return {
+            lifeCycle: new static_run_one_terminal_output_life_cycle_1.StaticRunOneTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs),
+            renderIsDone: Promise.resolve(),
+        };
+    }
+    else {
+        if (useDynamicOutput) {
+            return await (0, dynamic_run_many_terminal_output_life_cycle_1.createRunManyDynamicOutputRenderer)({
+                projectNames,
+                tasks,
+                args: nxArgs,
+                overrides: overridesWithoutHidden,
+            });
+        }
+        else {
+            return {
+                lifeCycle: new static_run_many_terminal_output_life_cycle_1.StaticRunManyTerminalOutputLifeCycle(projectNames, tasks, nxArgs, overridesWithoutHidden),
+                renderIsDone: Promise.resolve(),
+            };
+        }
+    }
+}
+function createTaskGraphAndValidateCycles(projectGraph, defaultDependencyConfigs, projectNames, nxArgs, overrides, extraOptions) {
+    const taskGraph = (0, create_task_graph_1.createTaskGraph)(projectGraph, defaultDependencyConfigs, projectNames, nxArgs.targets, nxArgs.configuration, overrides, extraOptions.excludeTaskDependencies);
+    const cycle = (0, task_graph_utils_1.findCycle)(taskGraph);
+    if (cycle) {
+        if (process.env.NX_IGNORE_CYCLES === 'true' || nxArgs.nxIgnoreCycles) {
+            output_1.output.warn({
+                title: `The task graph has a circular dependency`,
+                bodyLines: [`${cycle.join(' --> ')}`],
+            });
+            (0, task_graph_utils_1.makeAcyclic)(taskGraph);
+        }
+        else {
+            output_1.output.error({
+                title: `Could not execute command because the task graph has a circular dependency`,
+                bodyLines: [`${cycle.join(' --> ')}`],
+            });
+            process.exit(1);
+        }
+    }
+    return taskGraph;
+}
+async function runCommand(projectsToRun, projectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
+    const status = await (0, params_1.handleErrors)(process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+        const defaultDependencyConfigs = mergeTargetDependencies(nxJson.targetDefaults, extraTargetDependencies);
+        const projectNames = projectsToRun.map((t) => t.name);
+        const taskGraph = createTaskGraphAndValidateCycles(projectGraph, defaultDependencyConfigs, projectNames, nxArgs, overrides, extraOptions);
+        const tasks = Object.values(taskGraph.tasks);
+        const { lifeCycle, renderIsDone } = await getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides);
+        const status = await invokeTasksRunner({
+            tasks,
+            projectGraph,
+            taskGraph,
+            lifeCycle,
+            nxJson,
+            nxArgs,
+            loadDotEnvFiles: extraOptions.loadDotEnvFiles,
+            initiatingProject,
+        });
+        await renderIsDone;
+        return status;
+    });
+    return status;
+}
+exports.runCommand = runCommand;
+function setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles) {
+    if (nxArgs.outputStyle == 'stream' ||
+        process.env.NX_BATCH_MODE === 'true' ||
+        nxArgs.batch) {
+        process.env.NX_STREAM_OUTPUT = 'true';
+        process.env.NX_PREFIX_OUTPUT = 'true';
+    }
+    if (nxArgs.outputStyle == 'stream-without-prefixes') {
+        process.env.NX_STREAM_OUTPUT = 'true';
+    }
+    if (loadDotEnvFiles) {
+        process.env.NX_LOAD_DOT_ENV_FILES = 'true';
+    }
+}
+async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, }) {
+    setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles);
+    const { tasksRunner, runnerOptions } = getRunner(nxArgs, nxJson);
+    let hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, runnerOptions);
+    // this is used for two reasons: to fetch all remote cache hits AND
+    // to submit everything that is known in advance to Nx Cloud to run in
+    // a distributed fashion
+    await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson);
+    const promiseOrObservable = tasksRunner(tasks, {
+        ...runnerOptions,
+        lifeCycle: new life_cycle_1.CompositeLifeCycle(constructLifeCycles(lifeCycle)),
+    }, {
+        initiatingProject: nxArgs.outputStyle === 'compact' ? null : initiatingProject,
+        projectGraph,
+        nxJson,
+        nxArgs,
+        taskGraph,
+        hasher: {
+            hashTask(task, taskGraph_, env) {
+                if (!taskGraph_) {
+                    output_1.output.warn({
+                        title: `TaskGraph is now required as an argument to hashTask`,
+                        bodyLines: [
+                            `The TaskGraph object can be retrieved from the context`,
+                            'This will result in an error in Nx 19',
+                        ],
+                    });
+                    taskGraph_ = taskGraph;
+                }
+                if (!env) {
+                    output_1.output.warn({
+                        title: `The environment variables are now required as an argument to hashTask`,
+                        bodyLines: [
+                            `Please pass the environment variables used when running the task`,
+                            'This will result in an error in Nx 19',
+                        ],
+                    });
+                    env = process.env;
+                }
+                return hasher.hashTask(task, taskGraph_, env);
+            },
+            hashTasks(task, taskGraph_, env) {
+                if (!taskGraph_) {
+                    output_1.output.warn({
+                        title: `TaskGraph is now required as an argument to hashTasks`,
+                        bodyLines: [
+                            `The TaskGraph object can be retrieved from the context`,
+                            'This will result in an error in Nx 19',
+                        ],
+                    });
+                    taskGraph_ = taskGraph;
+                }
+                if (!env) {
+                    output_1.output.warn({
+                        title: `The environment variables are now required as an argument to hashTasks`,
+                        bodyLines: [
+                            `Please pass the environment variables used when running the tasks`,
+                            'This will result in an error in Nx 19',
+                        ],
+                    });
+                    env = process.env;
+                }
+                return hasher.hashTasks(task, taskGraph_, env);
+            },
+        },
+        daemon: client_1.daemonClient,
+    });
+    let anyFailures;
+    if (promiseOrObservable.subscribe) {
+        anyFailures = await anyFailuresInObservable(promiseOrObservable);
+    }
+    else {
+        // simply await the promise
+        anyFailures = await anyFailuresInPromise(promiseOrObservable);
+    }
+    return anyFailures ? 1 : 0;
+}
+exports.invokeTasksRunner = invokeTasksRunner;
+function constructLifeCycles(lifeCycle) {
+    const lifeCycles = [];
+    lifeCycles.push(new store_run_information_life_cycle_1.StoreRunInformationLifeCycle());
+    lifeCycles.push(lifeCycle);
+    if (process.env.NX_PERF_LOGGING === 'true') {
+        lifeCycles.push(new task_timings_life_cycle_1.TaskTimingsLifeCycle());
+    }
+    if (process.env.NX_PROFILE) {
+        lifeCycles.push(new task_profiling_life_cycle_1.TaskProfilingLifeCycle(process.env.NX_PROFILE));
+    }
+    return lifeCycles;
+}
+function mergeTargetDependencies(defaults, deps) {
+    const res = {};
+    Object.keys(defaults ?? {}).forEach((k) => {
+        res[k] = defaults[k].dependsOn;
+    });
+    if (deps) {
+        Object.keys(deps).forEach((k) => {
+            if (res[k]) {
+                res[k] = [...res[k], deps[k]];
+            }
+            else {
+                res[k] = deps[k];
+            }
+        });
+        return res;
+    }
+}
+async function anyFailuresInPromise(promise) {
+    return Object.values(await promise).some((v) => v === 'failure' || v === 'skipped');
+}
+async function anyFailuresInObservable(obs) {
+    return await new Promise((res) => {
+        let anyFailures = false;
+        obs.subscribe((t) => {
+            if (!t.success) {
+                anyFailures = true;
+            }
+        }, (error) => {
+            output_1.output.error({
+                title: 'Unhandled error in task executor',
+            });
+            console.error(error);
+            res(true);
+        }, () => {
+            res(anyFailures);
+        });
+    });
+}
+function shouldUseDynamicLifeCycle(tasks, options, outputStyle) {
+    if (process.env.NX_BATCH_MODE === 'true' ||
+        process.env.NX_VERBOSE_LOGGING === 'true' ||
+        process.env.NX_TASKS_RUNNER_DYNAMIC_OUTPUT === 'false') {
+        return false;
+    }
+    if (!process.stdout.isTTY)
+        return false;
+    if ((0, is_ci_1.isCI)())
+        return false;
+    if (outputStyle === 'static' || outputStyle === 'stream')
+        return false;
+    return !tasks.find((t) => (0, utils_1.shouldStreamOutput)(t, null));
+}
+function loadTasksRunner(modulePath) {
+    try {
+        const maybeTasksRunner = require(modulePath);
+        // to support both babel and ts formats
+        return 'default' in maybeTasksRunner
+            ? maybeTasksRunner.default
+            : maybeTasksRunner;
+    }
+    catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND' &&
+            (modulePath === 'nx-cloud' || modulePath === '@nrwl/nx-cloud')) {
+            return require('../nx-cloud/nx-cloud-tasks-runner-shell')
+                .nxCloudTasksRunnerShell;
+        }
+        throw e;
+    }
+}
+function getRunner(nxArgs, nxJson) {
+    let runner = nxArgs.runner;
+    runner = runner || 'default';
+    if (runner !== 'default' && !nxJson.tasksRunnerOptions?.[runner]) {
+        throw new Error(`Could not find runner configuration for ${runner}`);
+    }
+    const modulePath = getTasksRunnerPath(runner, nxJson);
+    try {
+        const tasksRunner = loadTasksRunner(modulePath);
+        return {
+            tasksRunner,
+            runnerOptions: getRunnerOptions(runner, nxJson, nxArgs, modulePath === 'nx-cloud'),
+        };
+    }
+    catch {
+        throw new Error(`Could not find runner configuration for ${runner}`);
+    }
+}
+exports.getRunner = getRunner;
+function getTasksRunnerPath(runner, nxJson) {
+    let modulePath = nxJson.tasksRunnerOptions?.[runner]?.runner;
+    if (modulePath) {
+        if ((0, fileutils_1.isRelativePath)(modulePath)) {
+            return (0, path_1.join)(workspace_root_1.workspaceRoot, modulePath);
+        }
+        return modulePath;
+    }
+    const isCloudRunner = 
+    // No tasksRunnerOptions for given --runner
+    nxJson.nxCloudAccessToken ||
+        // No runner prop in tasks runner options, check if access token is set.
+        nxJson.tasksRunnerOptions?.[runner]?.options?.accessToken ||
+        // Cloud access token specified in env var.
+        process.env.NX_CLOUD_ACCESS_TOKEN;
+    return isCloudRunner ? 'nx-cloud' : require.resolve('./default-tasks-runner');
+}
+function getRunnerOptions(runner, nxJson, nxArgs, isCloudDefault) {
+    const defaultCacheableOperations = [];
+    for (const key in nxJson.targetDefaults) {
+        if (nxJson.targetDefaults[key].cache) {
+            defaultCacheableOperations.push(key);
+        }
+    }
+    const result = {
+        ...nxJson.tasksRunnerOptions?.[runner]?.options,
+        ...nxArgs,
+    };
+    // NOTE: we don't pull from env here because the cloud package
+    // supports it within nx-cloud's implementation. We could
+    // normalize it here, and that may make more sense, but
+    // leaving it as is for now.
+    if (nxJson.nxCloudAccessToken && isCloudDefault) {
+        result.accessToken ??= nxJson.nxCloudAccessToken;
+    }
+    if (nxJson.nxCloudUrl && isCloudDefault) {
+        result.url ??= nxJson.nxCloudUrl;
+    }
+    if (nxJson.nxCloudEncryptionKey && isCloudDefault) {
+        result.encryptionKey ??= nxJson.nxCloudEncryptionKey;
+    }
+    if (nxJson.parallel) {
+        result.parallel ??= nxJson.parallel;
+    }
+    if (nxJson.cacheDirectory) {
+        result.cacheDirectory ??= nxJson.cacheDirectory;
+    }
+    if (defaultCacheableOperations.length) {
+        result.cacheableOperations ??= [];
+        result.cacheableOperations = result.cacheableOperations.concat(defaultCacheableOperations);
+    }
+    if (nxJson.useDaemonProcess !== undefined) {
+        result.useDaemonProcess ??= nxJson.useDaemonProcess;
+    }
+    return result;
+}
+exports.getRunnerOptions = getRunnerOptions;

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

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { Task } from '../config/task-graph';
+export declare function getEnvVariablesForBatchProcess(skipNxCache: boolean, captureStderr: boolean): NodeJS.ProcessEnv;
+export declare function getTaskSpecificEnv(task: Task): NodeJS.ProcessEnv;
+export declare function getEnvVariablesForTask(task: Task, taskSpecificEnv: NodeJS.ProcessEnv, forceColor: string, skipNxCache: boolean, captureStderr: boolean, outputPath: string, streamOutput: boolean): {
+    [x: string]: string;
+    TZ?: string;
+};