nx 20.8.4 → 22.7.7

package/src/tasks-runner/life-cycles/static-run-many-terminal-output-life-cycle.js

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StaticRunManyTerminalOutputLifeCycle = void 0;
-const output_1 = require("../../utils/output");
-const utils_1 = require("../utils");
-const formatting_utils_1 = require("./formatting-utils");
-/**
- * The following life cycle's outputs are static, meaning no previous content
- * is rewritten or modified as new outputs are added. It is therefore intended
- * for use in CI environments.
- *
- * For the common case of a user executing a command on their local machine,
- * the dynamic equivalent of this life cycle is usually preferable.
- */
-class StaticRunManyTerminalOutputLifeCycle {
-    constructor(projectNames, tasks, args, taskOverrides) {
-        this.projectNames = projectNames;
-        this.tasks = tasks;
-        this.args = args;
-        this.taskOverrides = taskOverrides;
-        this.failedTasks = [];
-        this.cachedTasks = [];
-        this.allCompletedTasks = new Map();
-    }
-    startCommand() {
-        if (this.tasks.length === 0) {
-            return;
-        }
-        if (this.projectNames.length <= 0) {
-            output_1.output.logSingleLine(`No projects with ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)} were run`);
-            return;
-        }
-        const bodyLines = this.projectNames.map((affectedProject) => `${output_1.output.dim('-')} ${affectedProject}`);
-        if (Object.keys(this.taskOverrides).length > 0) {
-            bodyLines.push('');
-            bodyLines.push(`${output_1.output.dim('With additional flags:')}`);
-            Object.entries(this.taskOverrides)
-                .map(([flag, value]) => (0, formatting_utils_1.formatFlags)('', flag, value))
-                .forEach((arg) => bodyLines.push(arg));
-        }
-        const title = `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)}:`;
-        output_1.output.log({
-            color: 'cyan',
-            title,
-            bodyLines,
-        });
-        output_1.output.addVerticalSeparatorWithoutNewLines('cyan');
-    }
-    endCommand() {
-        output_1.output.addNewline();
-        if (this.tasks.length === 0) {
-            output_1.output.logSingleLine(`No tasks were run`);
-            return;
-        }
-        if (this.failedTasks.length === 0) {
-            output_1.output.addVerticalSeparatorWithoutNewLines('green');
-            const bodyLines = this.cachedTasks.length > 0
-                ? [
-                    output_1.output.dim(`Nx read the output from the cache instead of running the command for ${this.cachedTasks.length} out of ${this.tasks.length} tasks.`),
-                ]
-                : [];
-            output_1.output.success({
-                title: `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)}`,
-                bodyLines,
-            });
-        }
-        else {
-            output_1.output.addVerticalSeparatorWithoutNewLines('red');
-            const bodyLines = [];
-            const skippedTasks = this.skippedTasks();
-            if (skippedTasks.length > 0) {
-                bodyLines.push(output_1.output.dim('Tasks not run because their dependencies failed or --nx-bail=true:'), '', ...skippedTasks.map((task) => `${output_1.output.dim('-')} ${task.id}`), '');
-            }
-            bodyLines.push(output_1.output.dim('Failed tasks:'), '', ...[...this.failedTasks.values()].map((task) => `${output_1.output.dim('-')} ${task.id}`));
-            output_1.output.error({
-                title: `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)} failed`,
-                bodyLines,
-            });
-        }
-    }
-    skippedTasks() {
-        return this.tasks.filter((t) => !this.allCompletedTasks.has(t.id));
-    }
-    endTasks(taskResults) {
-        for (let t of taskResults) {
-            this.allCompletedTasks.set(t.task.id, t.task);
-            if (t.status === 'failure') {
-                this.failedTasks.push(t.task);
-            }
-            else if (t.status === 'local-cache') {
-                this.cachedTasks.push(t.task);
-            }
-            else if (t.status === 'local-cache-kept-existing') {
-                this.cachedTasks.push(t.task);
-            }
-            else if (t.status === 'remote-cache') {
-                this.cachedTasks.push(t.task);
-            }
-        }
-    }
-    printTaskTerminalOutput(task, cacheStatus, terminalOutput) {
-        const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-        output_1.output.logCommandOutput(args.join(' '), cacheStatus, terminalOutput);
-    }
-}
-exports.StaticRunManyTerminalOutputLifeCycle = StaticRunManyTerminalOutputLifeCycle;

package/src/tasks-runner/life-cycles/task-history-life-cycle-old.d.ts

@@ -1,9 +0,0 @@
-import { Task } from '../../config/task-graph';
-import { LifeCycle, TaskResult } from '../life-cycle';
-export declare class LegacyTaskHistoryLifeCycle implements LifeCycle {
-    private startTimings;
-    private taskRuns;
-    startTasks(tasks: Task[]): void;
-    endTasks(taskResults: TaskResult[]): Promise<void>;
-    endCommand(): Promise<void>;
-}

package/src/tasks-runner/life-cycles/task-history-life-cycle-old.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LegacyTaskHistoryLifeCycle = void 0;
-const serialize_target_1 = require("../../utils/serialize-target");
-const output_1 = require("../../utils/output");
-const legacy_task_history_1 = require("../../utils/legacy-task-history");
-class LegacyTaskHistoryLifeCycle {
-    constructor() {
-        this.startTimings = {};
-        this.taskRuns = [];
-    }
-    startTasks(tasks) {
-        for (let task of tasks) {
-            this.startTimings[task.id] = new Date().getTime();
-        }
-    }
-    async endTasks(taskResults) {
-        const taskRuns = taskResults.map((taskResult) => ({
-            project: taskResult.task.target.project,
-            target: taskResult.task.target.target,
-            configuration: taskResult.task.target.configuration,
-            hash: taskResult.task.hash,
-            code: taskResult.code.toString(),
-            status: taskResult.status,
-            start: (taskResult.task.startTime ?? this.startTimings[taskResult.task.id]).toString(),
-            end: (taskResult.task.endTime ?? new Date().getTime()).toString(),
-        }));
-        this.taskRuns.push(...taskRuns);
-    }
-    async endCommand() {
-        await (0, legacy_task_history_1.writeTaskRunsToHistory)(this.taskRuns);
-        const history = await (0, legacy_task_history_1.getHistoryForHashes)(this.taskRuns.map((t) => t.hash));
-        const flakyTasks = [];
-        // check if any hash has different exit codes => flaky
-        for (let hash in history) {
-            if (history[hash].length > 1 &&
-                history[hash].some((run) => run.code !== history[hash][0].code)) {
-                flakyTasks.push((0, serialize_target_1.serializeTarget)(history[hash][0].project, history[hash][0].target, history[hash][0].configuration));
-            }
-        }
-        if (flakyTasks.length > 0) {
-            output_1.output.warn({
-                title: `Nx detected ${flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
-                bodyLines: [
-                    ,
-                    ...flakyTasks.map((t) => `  ${t}`),
-                    '',
-                    `Flaky tasks can disrupt your CI pipeline. Automatically retry them with Nx Cloud. Learn more at https://nx.dev/ci/features/flaky-tasks`,
-                ],
-            });
-        }
-    }
-}
-exports.LegacyTaskHistoryLifeCycle = LegacyTaskHistoryLifeCycle;

package/src/tasks-runner/life-cycles/task-history-life-cycle.d.ts

@@ -1,10 +0,0 @@
-import { Task } from '../../config/task-graph';
-import { LifeCycle, TaskResult } from '../life-cycle';
-export declare class TaskHistoryLifeCycle implements LifeCycle {
-    private startTimings;
-    private taskRuns;
-    private taskHistory;
-    startTasks(tasks: Task[]): void;
-    endTasks(taskResults: TaskResult[]): Promise<void>;
-    endCommand(): Promise<void>;
-}

package/src/tasks-runner/life-cycles/task-history-life-cycle.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskHistoryLifeCycle = void 0;
-const serialize_target_1 = require("../../utils/serialize-target");
-const output_1 = require("../../utils/output");
-const task_history_1 = require("../../utils/task-history");
-class TaskHistoryLifeCycle {
-    constructor() {
-        this.startTimings = {};
-        this.taskRuns = new Map();
-        this.taskHistory = (0, task_history_1.getTaskHistory)();
-    }
-    startTasks(tasks) {
-        for (let task of tasks) {
-            this.startTimings[task.id] = new Date().getTime();
-        }
-    }
-    async endTasks(taskResults) {
-        taskResults
-            .map((taskResult) => ({
-            hash: taskResult.task.hash,
-            target: taskResult.task.target,
-            code: taskResult.code,
-            status: taskResult.status,
-            start: taskResult.task.startTime ?? this.startTimings[taskResult.task.id],
-            end: taskResult.task.endTime ?? Date.now(),
-        }))
-            .forEach((taskRun) => {
-            this.taskRuns.set(taskRun.hash, taskRun);
-        });
-    }
-    async endCommand() {
-        const entries = Array.from(this.taskRuns);
-        if (!this.taskHistory) {
-            return;
-        }
-        await this.taskHistory.recordTaskRuns(entries.map(([_, v]) => v));
-        const flakyTasks = await this.taskHistory.getFlakyTasks(entries.map(([hash]) => hash));
-        if (flakyTasks.length > 0) {
-            output_1.output.warn({
-                title: `Nx detected ${flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
-                bodyLines: [
-                    ,
-                    ...flakyTasks.map((hash) => {
-                        const taskRun = this.taskRuns.get(hash);
-                        return `  ${(0, serialize_target_1.serializeTarget)(taskRun.target.project, taskRun.target.target, taskRun.target.configuration)}`;
-                    }),
-                    '',
-                    `Flaky tasks can disrupt your CI pipeline. Automatically retry them with Nx Cloud. Learn more at https://nx.dev/ci/features/flaky-tasks`,
-                ],
-            });
-        }
-    }
-}
-exports.TaskHistoryLifeCycle = TaskHistoryLifeCycle;

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

@@ -1,140 +0,0 @@
-"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 Pseudo IPC Channel
- *     * This returns RustChildProcess
- *         * RustChildProcess.onMessage(msg => ());
- *         * pseudo_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 = getPseudoIpcChannel(process.env.NX_IPC_CHANNEL_ID)
- *     * forkChildProcess.on('message', writeToPseudoIpcChannel)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PseudoIPCClient = exports.PseudoIPCServer = void 0;
-const net_1 = require("net");
-const consume_messages_from_socket_1 = require("../utils/consume-messages-from-socket");
-class PseudoIPCServer {
-    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.PseudoIPCServer = PseudoIPCServer;
-class PseudoIPCClient {
-    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.PseudoIPCClient = PseudoIPCClient;

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

@@ -1,45 +0,0 @@
-import { ChildProcess, RustPseudoTerminal } from '../native';
-import { PseudoIPCServer } from './pseudo-ipc';
-import { Serializable } from 'child_process';
-export declare function getPseudoTerminal(skipSupportCheck?: boolean): PseudoTerminal;
-export declare class PseudoTerminal {
-    private rustPseudoTerminal;
-    private pseudoIPCPath;
-    private pseudoIPC;
-    private initialized;
-    static isSupported(): boolean;
-    constructor(rustPseudoTerminal: RustPseudoTerminal);
-    init(): Promise<void>;
-    runCommand(command: string, { cwd, execArgv, jsEnv, quiet, tty, }?: {
-        cwd?: string;
-        execArgv?: string[];
-        jsEnv?: Record<string, string>;
-        quiet?: boolean;
-        tty?: boolean;
-    }): PseudoTtyProcess;
-    fork(id: string, script: string, { cwd, execArgv, jsEnv, quiet, }: {
-        cwd?: string;
-        execArgv?: string[];
-        jsEnv?: Record<string, string>;
-        quiet?: boolean;
-    }): Promise<PseudoTtyProcessWithSend>;
-    sendMessageToChildren(message: Serializable): void;
-    onMessageFromChildren(callback: (message: Serializable) => void): void;
-    private setupProcessListeners;
-    private shutdownPseudoIPC;
-}
-export declare class PseudoTtyProcess {
-    private childProcess;
-    isAlive: boolean;
-    exitCallbacks: any[];
-    constructor(childProcess: ChildProcess);
-    onExit(callback: (code: number) => void): void;
-    onOutput(callback: (message: string) => void): void;
-    kill(): void;
-}
-export declare class PseudoTtyProcessWithSend extends PseudoTtyProcess {
-    private id;
-    private pseudoIpc;
-    constructor(_childProcess: ChildProcess, id: string, pseudoIpc: PseudoIPCServer);
-    send(message: Serializable): void;
-}

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

@@ -1,168 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PseudoTtyProcessWithSend = exports.PseudoTtyProcess = exports.PseudoTerminal = void 0;
-exports.getPseudoTerminal = getPseudoTerminal;
-const native_1 = require("../native");
-const pseudo_ipc_1 = require("./pseudo-ipc");
-const socket_utils_1 = require("../daemon/socket-utils");
-const os = require("os");
-let pseudoTerminal;
-function getPseudoTerminal(skipSupportCheck = false) {
-    if (!skipSupportCheck && !PseudoTerminal.isSupported()) {
-        throw new Error('Pseudo terminal is not supported on this platform.');
-    }
-    pseudoTerminal ??= new PseudoTerminal(new native_1.RustPseudoTerminal());
-    return pseudoTerminal;
-}
-class PseudoTerminal {
-    static isSupported() {
-        return process.stdout.isTTY && supportedPtyPlatform();
-    }
-    constructor(rustPseudoTerminal) {
-        this.rustPseudoTerminal = rustPseudoTerminal;
-        this.pseudoIPCPath = (0, socket_utils_1.getForkedProcessOsSocketPath)(process.pid.toString());
-        this.pseudoIPC = new pseudo_ipc_1.PseudoIPCServer(this.pseudoIPCPath);
-        this.initialized = false;
-        this.setupProcessListeners();
-    }
-    async init() {
-        if (this.initialized) {
-            return;
-        }
-        await this.pseudoIPC.init();
-        this.initialized = true;
-    }
-    runCommand(command, { cwd, execArgv, jsEnv, quiet, tty, } = {}) {
-        return new PseudoTtyProcess(this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, execArgv, quiet, tty));
-    }
-    async fork(id, script, { cwd, execArgv, jsEnv, quiet, }) {
-        if (!this.initialized) {
-            throw new Error('Call init() before forking processes');
-        }
-        const cp = new PseudoTtyProcessWithSend(this.rustPseudoTerminal.fork(id, script, this.pseudoIPCPath, cwd, jsEnv, execArgv, quiet), id, this.pseudoIPC);
-        await this.pseudoIPC.waitForChildReady(id);
-        return cp;
-    }
-    sendMessageToChildren(message) {
-        this.pseudoIPC.sendMessageToChildren(message);
-    }
-    onMessageFromChildren(callback) {
-        this.pseudoIPC.onMessageFromChildren(callback);
-    }
-    setupProcessListeners() {
-        const shutdown = () => {
-            this.shutdownPseudoIPC();
-        };
-        process.on('SIGINT', () => {
-            this.shutdownPseudoIPC();
-        });
-        process.on('SIGTERM', () => {
-            this.shutdownPseudoIPC();
-        });
-        process.on('SIGHUP', () => {
-            this.shutdownPseudoIPC();
-        });
-        process.on('exit', () => {
-            this.shutdownPseudoIPC();
-        });
-    }
-    shutdownPseudoIPC() {
-        if (this.initialized) {
-            this.pseudoIPC.close();
-        }
-    }
-}
-exports.PseudoTerminal = PseudoTerminal;
-class PseudoTtyProcess {
-    constructor(childProcess) {
-        this.childProcess = childProcess;
-        this.isAlive = true;
-        this.exitCallbacks = [];
-        childProcess.onExit((message) => {
-            this.isAlive = false;
-            const exitCode = messageToCode(message);
-            this.exitCallbacks.forEach((cb) => cb(exitCode));
-        });
-    }
-    onExit(callback) {
-        this.exitCallbacks.push(callback);
-    }
-    onOutput(callback) {
-        this.childProcess.onOutput(callback);
-    }
-    kill() {
-        try {
-            this.childProcess.kill();
-        }
-        catch {
-            // when the child process completes before we explicitly call kill, this will throw
-            // do nothing
-        }
-        finally {
-            if (this.isAlive == true) {
-                this.isAlive = false;
-            }
-        }
-    }
-}
-exports.PseudoTtyProcess = PseudoTtyProcess;
-class PseudoTtyProcessWithSend extends PseudoTtyProcess {
-    constructor(_childProcess, id, pseudoIpc) {
-        super(_childProcess);
-        this.id = id;
-        this.pseudoIpc = pseudoIpc;
-    }
-    send(message) {
-        this.pseudoIpc.sendMessageToChild(this.id, message);
-    }
-}
-exports.PseudoTtyProcessWithSend = PseudoTtyProcessWithSend;
-function messageToCode(message) {
-    if (message.startsWith('Terminated by ')) {
-        switch (message.replace('Terminated by ', '').trim()) {
-            case 'Termination':
-                return 143;
-            case 'Interrupt':
-                return 130;
-            default:
-                return 128;
-        }
-    }
-    else if (message.startsWith('Exited with code ')) {
-        return parseInt(message.replace('Exited with code ', '').trim());
-    }
-    else if (message === 'Success') {
-        return 0;
-    }
-    else {
-        return 1;
-    }
-}
-function supportedPtyPlatform() {
-    if (native_1.IS_WASM) {
-        return false;
-    }
-    if (process.platform !== 'win32') {
-        return true;
-    }
-    // TODO: Re-enable Windows support when it's stable
-    // Currently, there's an issue with control chars.
-    // See: https://github.com/nrwl/nx/issues/22358
-    if (process.env.NX_WINDOWS_PTY_SUPPORT !== 'true') {
-        return false;
-    }
-    let windowsVersion = os.release().split('.');
-    let windowsBuild = windowsVersion[2];
-    if (!windowsBuild) {
-        return false;
-    }
-    // Mininum supported Windows version:
-    // https://en.wikipedia.org/wiki/Windows_10,_version_1809
-    // https://learn.microsoft.com/en-us/windows/console/createpseudoconsole#requirements
-    if (+windowsBuild < 17763) {
-        return false;
-    }
-    else {
-        return true;
-    }
-}

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

@@ -1,36 +0,0 @@
-import { NxJsonConfiguration } from '../config/nx-json';
-import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
-import { Task, TaskGraph } from '../config/task-graph';
-import { TargetDependencyConfig } from '../config/workspace-json-project-json';
-import { NxArgs } from '../utils/command-line-utils';
-import { LifeCycle, TaskResult, TaskResults } from './life-cycle';
-import { TasksRunner } from './tasks-runner';
-export declare function runCommand(projectsToRun: ProjectGraphProjectNode[], currentProjectGraph: 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 runCommandForTasks(projectsToRun: ProjectGraphProjectNode[], currentProjectGraph: ProjectGraph, { nxJson }: {
-    nxJson: NxJsonConfiguration;
-}, nxArgs: NxArgs, overrides: any, initiatingProject: string | null, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, extraOptions: {
-    excludeTaskDependencies: boolean;
-    loadDotEnvFiles: boolean;
-}): Promise<TaskResults>;
-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<{
-    [id: string]: TaskResult;
-}>;
-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;