@depup/nx 22.5.4-depup.0

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

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessTasks = void 0;
+exports.createTaskGraph = createTaskGraph;
+exports.mapTargetDefaultsToDependencies = mapTargetDefaultsToDependencies;
+exports.filterDummyTasks = filterDummyTasks;
+exports.getNonDummyDeps = getNonDummyDeps;
+const utils_1 = require("./utils");
+const project_graph_utils_1 = require("../utils/project-graph-utils");
+const output_1 = require("../utils/output");
+const task_graph_utils_1 = require("./task-graph-utils");
+const DUMMY_TASK_TARGET = '__nx_dummy_task__';
+class ProcessTasks {
+    constructor(extraTargetDependencies, projectGraph) {
+        this.extraTargetDependencies = extraTargetDependencies;
+        this.projectGraph = projectGraph;
+        this.seen = new Set();
+        this.tasks = {};
+        this.dependencies = {};
+        this.continuousDependencies = {};
+        const allTargetNames = new Set();
+        for (const projectName in projectGraph.nodes) {
+            const project = projectGraph.nodes[projectName];
+            for (const targetName in project.data.targets ?? {}) {
+                allTargetNames.add(targetName);
+            }
+        }
+        this.allTargetNames = Array.from(allTargetNames);
+    }
+    processTasks(projectNames, targets, configuration, overrides, excludeTaskDependencies) {
+        for (const projectName of projectNames) {
+            for (const target of targets) {
+                const project = this.projectGraph.nodes[projectName];
+                if (targets.length === 1 || project.data.targets[target]) {
+                    const resolvedConfiguration = this.resolveConfiguration(project, target, configuration);
+                    const id = (0, utils_1.createTaskId)(projectName, target, resolvedConfiguration);
+                    const task = this.createTask(id, project, target, resolvedConfiguration, overrides);
+                    this.tasks[task.id] = task;
+                    this.dependencies[task.id] = [];
+                    this.continuousDependencies[task.id] = [];
+                }
+            }
+        }
+        // used when excluding tasks
+        const initialTasks = { ...this.tasks };
+        for (const taskId of Object.keys(this.tasks)) {
+            const task = this.tasks[taskId];
+            this.processTask(task, task.target.project, configuration, overrides);
+        }
+        if (excludeTaskDependencies) {
+            for (let t of Object.keys(this.tasks)) {
+                if (!initialTasks[t]) {
+                    delete this.tasks[t];
+                    delete this.dependencies[t];
+                    delete this.continuousDependencies[t];
+                }
+            }
+            for (let d of Object.keys(this.dependencies)) {
+                this.dependencies[d] = this.dependencies[d].filter((dd) => !!initialTasks[dd]);
+            }
+            for (let d of Object.keys(this.continuousDependencies)) {
+                this.continuousDependencies[d] = this.continuousDependencies[d].filter((dd) => !!initialTasks[dd]);
+            }
+        }
+        filterDummyTasks(this.dependencies);
+        for (const taskId of Object.keys(this.dependencies)) {
+            if (this.dependencies[taskId].length > 0) {
+                this.dependencies[taskId] = [
+                    ...new Set(this.dependencies[taskId].filter((d) => d !== taskId)).values(),
+                ];
+            }
+        }
+        filterDummyTasks(this.continuousDependencies);
+        for (const taskId of Object.keys(this.continuousDependencies)) {
+            if (this.continuousDependencies[taskId].length > 0) {
+                this.continuousDependencies[taskId] = [
+                    ...new Set(this.continuousDependencies[taskId].filter((d) => d !== taskId)).values(),
+                ];
+            }
+        }
+        return Object.keys(this.tasks).filter((d) => this.dependencies[d].length === 0 &&
+            this.continuousDependencies[d].length === 0);
+    }
+    processTask(task, projectUsedToDeriveDependencies, configuration, overrides) {
+        const seenKey = `${task.id}-${projectUsedToDeriveDependencies}`;
+        if (this.seen.has(seenKey)) {
+            return;
+        }
+        this.seen.add(seenKey);
+        const dependencyConfigs = (0, utils_1.getDependencyConfigs)({ project: task.target.project, target: task.target.target }, this.extraTargetDependencies, this.projectGraph, this.allTargetNames);
+        for (const dependencyConfig of dependencyConfigs) {
+            const taskOverrides = createTaskOverrides(dependencyConfig, overrides, task, this.projectGraph);
+            if (dependencyConfig.projects) {
+                this.processTasksForMultipleProjects(dependencyConfig, configuration, task, taskOverrides, overrides);
+            }
+            else if (dependencyConfig.dependencies) {
+                this.processTasksForDependencies(projectUsedToDeriveDependencies, dependencyConfig, configuration, task, taskOverrides, overrides);
+            }
+            else {
+                this.processTasksForSingleProject(task, task.target.project, dependencyConfig, configuration, taskOverrides, overrides);
+            }
+        }
+    }
+    processTasksForMultipleProjects(dependencyConfig, configuration, task, taskOverrides, overrides) {
+        if (dependencyConfig.projects.length === 0) {
+            output_1.output.warn({
+                title: `\`dependsOn\` is misconfigured for ${task.target.project}:${task.target.target}`,
+                bodyLines: [
+                    `Project patterns "${dependencyConfig.projects}" does not match any projects.`,
+                ],
+            });
+        }
+        for (const projectName of dependencyConfig.projects) {
+            this.processTasksForSingleProject(task, projectName, dependencyConfig, configuration, taskOverrides, overrides);
+        }
+    }
+    processTasksForSingleProject(task, projectName, dependencyConfig, configuration, taskOverrides, overrides) {
+        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 = (0, utils_1.createTaskId)(selfProject.name, dependencyConfig.target, resolvedConfiguration);
+            if (!this.tasks[selfTaskId]) {
+                const newTask = this.createTask(selfTaskId, selfProject, dependencyConfig.target, resolvedConfiguration, taskOverrides);
+                this.tasks[selfTaskId] = newTask;
+                this.dependencies[selfTaskId] = [];
+                this.continuousDependencies[selfTaskId] = [];
+                this.processTask(newTask, newTask.target.project, configuration, overrides);
+            }
+            if (task.id !== selfTaskId) {
+                if (this.tasks[selfTaskId].continuous) {
+                    this.continuousDependencies[task.id].push(selfTaskId);
+                }
+                else {
+                    this.dependencies[task.id].push(selfTaskId);
+                }
+            }
+        }
+    }
+    processTasksForDependencies(projectUsedToDeriveDependencies, dependencyConfig, configuration, task, taskOverrides, overrides) {
+        if (!this.projectGraph.dependencies.hasOwnProperty(projectUsedToDeriveDependencies)) {
+            return;
+        }
+        for (const dep of this.projectGraph.dependencies[projectUsedToDeriveDependencies]) {
+            const depProject = this.projectGraph.nodes[dep.target];
+            // this is to handle external dependencies
+            if (!depProject)
+                continue;
+            if ((0, project_graph_utils_1.projectHasTarget)(depProject, dependencyConfig.target)) {
+                const resolvedConfiguration = this.resolveConfiguration(depProject, dependencyConfig.target, configuration);
+                const depTargetId = (0, utils_1.createTaskId)(depProject.name, dependencyConfig.target, resolvedConfiguration);
+                const depTargetConfiguration = this.projectGraph.nodes[depProject.name].data.targets[dependencyConfig.target];
+                if (task.id !== depTargetId) {
+                    if (depTargetConfiguration.continuous) {
+                        this.continuousDependencies[task.id].push(depTargetId);
+                    }
+                    else {
+                        this.dependencies[task.id].push(depTargetId);
+                    }
+                }
+                if (!this.tasks[depTargetId]) {
+                    const newTask = this.createTask(depTargetId, depProject, dependencyConfig.target, resolvedConfiguration, taskOverrides);
+                    this.tasks[depTargetId] = newTask;
+                    this.dependencies[depTargetId] = [];
+                    this.continuousDependencies[depTargetId] = [];
+                    this.processTask(newTask, newTask.target.project, configuration, overrides);
+                }
+            }
+            else {
+                // Create a dummy task for task.target.project... which simulates if depProject had dependencyConfig.target
+                const dummyId = (0, utils_1.createTaskId)(depProject.name, task.target.project +
+                    task.target.target +
+                    '__' +
+                    dependencyConfig.target +
+                    DUMMY_TASK_TARGET, undefined);
+                this.dependencies[task.id].push(dummyId);
+                this.dependencies[dummyId] ??= [];
+                this.continuousDependencies[dummyId] ??= [];
+                const noopTask = this.createDummyTask(dummyId, task);
+                this.processTask(noopTask, depProject.name, configuration, overrides);
+            }
+        }
+    }
+    createDummyTask(id, task) {
+        return {
+            ...task,
+            id,
+        };
+    }
+    createTask(id, project, target, resolvedConfiguration, overrides) {
+        if (!project.data.targets[target]) {
+            throw new Error(`Cannot find configuration for task ${project.name}:${target}`);
+        }
+        if (!project.data.targets[target].executor) {
+            throw new Error(`Target "${project.name}:${target}" does not have an executor configured`);
+        }
+        const qualifiedTarget = {
+            project: project.name,
+            target,
+            configuration: resolvedConfiguration,
+        };
+        const interpolatedOverrides = interpolateOverrides(overrides, project.name, project.data);
+        return {
+            id,
+            target: qualifiedTarget,
+            projectRoot: project.data.root,
+            overrides: interpolatedOverrides,
+            outputs: (0, utils_1.getOutputs)(this.projectGraph.nodes, qualifiedTarget, interpolatedOverrides),
+            cache: project.data.targets[target].cache,
+            parallelism: project.data.targets[target].parallelism ?? true,
+            continuous: project.data.targets[target].continuous ?? false,
+        };
+    }
+    resolveConfiguration(project, target, configuration) {
+        const defaultConfiguration = project.data.targets?.[target]?.defaultConfiguration;
+        configuration ??= defaultConfiguration;
+        return (0, project_graph_utils_1.projectHasTargetAndConfiguration)(project, target, configuration)
+            ? configuration
+            : defaultConfiguration;
+    }
+}
+exports.ProcessTasks = ProcessTasks;
+function createTaskGraph(projectGraph, extraTargetDependencies, projectNames, targets, configuration, overrides, excludeTaskDependencies = false) {
+    const p = new ProcessTasks(extraTargetDependencies, projectGraph);
+    const roots = p.processTasks(projectNames, targets, configuration, overrides, excludeTaskDependencies);
+    return {
+        roots,
+        tasks: p.tasks,
+        dependencies: p.dependencies,
+        continuousDependencies: p.continuousDependencies,
+    };
+}
+function mapTargetDefaultsToDependencies(defaults) {
+    const res = {};
+    Object.keys(defaults ?? {}).forEach((k) => {
+        res[k] = defaults[k].dependsOn;
+    });
+    return res;
+}
+function interpolateOverrides(args, projectName, project) {
+    const interpolatedArgs = { ...args };
+    Object.entries(interpolatedArgs).forEach(([name, value]) => {
+        interpolatedArgs[name] =
+            typeof value === 'string'
+                ? (0, utils_1.interpolate)(value, {
+                    workspaceRoot: '',
+                    projectRoot: project.root,
+                    projectName: project.name,
+                    project: { ...project, name: projectName }, // this is legacy
+                })
+                : value;
+    });
+    return interpolatedArgs;
+}
+/**
+ * This function is used to filter out the dummy tasks from the dependencies
+ * It will manipulate the dependencies object in place
+ */
+function filterDummyTasks(dependencies) {
+    const cycles = (0, task_graph_utils_1.findCycles)({ dependencies });
+    for (const [key, deps] of Object.entries(dependencies)) {
+        if (!key.endsWith(DUMMY_TASK_TARGET)) {
+            const normalizedDeps = [];
+            for (const dep of deps) {
+                normalizedDeps.push(...getNonDummyDeps(dep, dependencies, cycles, new Set([key])));
+            }
+            dependencies[key] = normalizedDeps;
+        }
+    }
+    for (const key of Object.keys(dependencies)) {
+        if (key.endsWith(DUMMY_TASK_TARGET)) {
+            delete dependencies[key];
+        }
+    }
+}
+/**
+ * this function is used to get the non dummy dependencies of a task recursively
+ */
+function getNonDummyDeps(currentTask, dependencies, cycles, seen = new Set()) {
+    if (seen.has(currentTask)) {
+        return [];
+    }
+    seen.add(currentTask);
+    if (currentTask.endsWith(DUMMY_TASK_TARGET)) {
+        if (cycles?.has(currentTask)) {
+            return [];
+        }
+        const deps = dependencies[currentTask] ?? [];
+        if (!Array.isArray(deps)) {
+            throw new Error(`Expected dependencies of task ${currentTask} to be an array, but got ${typeof deps}`);
+        }
+        // if not a cycle, recursively get the non dummy dependencies
+        return deps.flatMap((dep) => getNonDummyDeps(dep, dependencies, cycles, seen));
+    }
+    else {
+        return [currentTask];
+    }
+}
+function createTaskOverrides(dependencyConfig, cliOverrides, sourceTask, projectGraph) {
+    const optionsToForward = {};
+    if (dependencyConfig.options === 'forward') {
+        const sourceTargetConfig = projectGraph.nodes[sourceTask.target.project].data.targets?.[sourceTask.target.target];
+        if (sourceTargetConfig?.options) {
+            Object.assign(optionsToForward, sourceTargetConfig.options);
+        }
+        if (sourceTask.target.configuration &&
+            sourceTargetConfig?.configurations?.[sourceTask.target.configuration]) {
+            Object.assign(optionsToForward, sourceTargetConfig.configurations[sourceTask.target.configuration]);
+        }
+    }
+    return dependencyConfig.params === 'forward'
+        ? { ...optionsToForward, ...cliOverrides }
+        : { ...optionsToForward, __overrides_unparsed__: [] };
+}

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

@@ -0,0 +1,28 @@
+import { TasksRunner } from './tasks-runner';
+import { LifeCycle } from './life-cycle';
+import { CachedResult } from '../native';
+export interface RemoteCache {
+    retrieve: (hash: string, cacheDirectory: string) => Promise<boolean>;
+    store: (hash: string, cacheDirectory: string) => Promise<boolean>;
+}
+export declare abstract class RemoteCacheV2 {
+    static fromCacheV1(cache: RemoteCache): Promise<RemoteCacheV2>;
+    abstract retrieve(hash: string, cacheDirectory: string): Promise<CachedResult | null>;
+    abstract store(hash: string, cacheDirectory: string, terminalOutput: string, code: number): Promise<boolean>;
+}
+export interface DefaultTasksRunnerOptions {
+    parallel?: number;
+    cacheableOperations?: string[];
+    cacheableTargets?: string[];
+    runtimeCacheInputs?: string[];
+    cacheDirectory?: string;
+    remoteCache?: RemoteCache;
+    lifeCycle: LifeCycle;
+    captureStderr?: boolean;
+    skipNxCache?: boolean;
+    skipRemoteCache?: boolean;
+    batch?: boolean;
+}
+export declare const defaultTasksRunner: TasksRunner<DefaultTasksRunnerOptions>;
+export default defaultTasksRunner;
+//# sourceMappingURL=default-tasks-runner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"default-tasks-runner.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/tasks-runner/default-tasks-runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAc,MAAM,gBAAgB,CAAC;AAGzD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AASzC,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACrE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACnE;AAED,8BAAsB,aAAa;WACpB,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC;IA6DpE,QAAQ,CAAC,QAAQ,CACf,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,KAAK,CACZ,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,EACtB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,SAAS,EAAE,SAAS,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAC1C,yBAAyB,CAuB1B,CAAC;AA+BF,eAAe,kBAAkB,CAAC"}

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTasksRunner = exports.RemoteCacheV2 = void 0;
+const task_orchestrator_1 = require("./task-orchestrator");
+const cache_directory_1 = require("../utils/cache-directory");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+class RemoteCacheV2 {
+    static async fromCacheV1(cache) {
+        await (0, promises_1.mkdir)((0, path_1.join)(cache_directory_1.cacheDir, 'terminalOutputs'), { recursive: true });
+        return {
+            retrieve: async (hash, cacheDirectory) => {
+                const res = await cache.retrieve(hash, cacheDirectory);
+                if (res) {
+                    const [terminalOutput, oldTerminalOutput, code] = await Promise.all([
+                        (0, promises_1.readFile)((0, path_1.join)(cacheDirectory, hash, 'terminalOutputs'), 'utf-8').catch(() => null),
+                        (0, promises_1.readFile)((0, path_1.join)(cache_directory_1.cacheDir, 'terminalOutputs', hash), 'utf-8').catch(() => null),
+                        (0, promises_1.readFile)((0, path_1.join)(cacheDirectory, hash, 'code'), 'utf-8').then((s) => +s),
+                    ]);
+                    return {
+                        outputsPath: (0, path_1.join)(cacheDirectory, hash, 'outputs'),
+                        terminalOutput: terminalOutput ?? oldTerminalOutput,
+                        code,
+                    };
+                }
+                else {
+                    return null;
+                }
+            },
+            store: async (hash, cacheDirectory, terminalOutput, code) => {
+                // The new db cache places the outputs directly into the cacheDirectory + hash.
+                // old instances of Nx Cloud expect these outputs to be in cacheDirectory + hash + outputs
+                // this ensures that everything that was in the cache directory is moved to the outputs directory
+                const cacheDir = (0, path_1.join)(cacheDirectory, hash);
+                const outputDir = (0, path_1.join)(cacheDir, 'outputs');
+                await (0, promises_1.mkdir)(outputDir, { recursive: true });
+                const files = await (0, promises_1.readdir)(cacheDir);
+                await Promise.all(files.map(async (file) => {
+                    const filePath = (0, path_1.join)(cacheDir, file);
+                    // we don't want to move these files to the outputs directory because they are not artifacts of the task
+                    if (filePath === outputDir ||
+                        file === 'code' ||
+                        file === 'terminalOutput') {
+                        return;
+                    }
+                    await (0, promises_1.rename)(filePath, (0, path_1.join)(outputDir, file));
+                }));
+                await (0, promises_1.writeFile)((0, path_1.join)(cacheDirectory, hash, 'code'), code.toString());
+                await (0, promises_1.writeFile)((0, path_1.join)(cacheDirectory, hash, 'terminalOutput'), terminalOutput);
+                return cache.store(hash, cacheDirectory);
+            },
+        };
+    }
+}
+exports.RemoteCacheV2 = RemoteCacheV2;
+const defaultTasksRunner = async (tasks, options, context) => {
+    const threadCount = (0, task_orchestrator_1.getThreadCount)(options, context.taskGraph);
+    await options.lifeCycle.startCommand(threadCount);
+    try {
+        return await runAllTasks(options, context);
+    }
+    finally {
+        await options.lifeCycle.endCommand();
+    }
+};
+exports.defaultTasksRunner = defaultTasksRunner;
+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/fork.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fork.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fork.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/tasks-runner/fork.ts"],"names":[],"mappings":""}

package/src/tasks-runner/fork.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const pseudo_ipc_1 = require("./pseudo-ipc");
+const exit_codes_1 = require("../utils/exit-codes");
+const pseudoIPCPath = process.argv[2];
+const forkId = process.argv[3];
+const script = (0, path_1.join)(__dirname, '../../bin/run-executor.js');
+let execArgv;
+if (process.env['NX_PSEUDO_TERMINAL_EXEC_ARGV']) {
+    execArgv = process.env['NX_PSEUDO_TERMINAL_EXEC_ARGV'].split('|');
+    delete process.env['NX_PSEUDO_TERMINAL_EXEC_ARGV'];
+}
+const childProcess = (0, child_process_1.fork)(script, {
+    stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+    env: process.env,
+    execArgv,
+});
+const pseudoIPC = new pseudo_ipc_1.PseudoIPCClient(pseudoIPCPath);
+pseudoIPC.onMessageFromParent(forkId, (message) => {
+    childProcess.send(message);
+}, () => {
+    // IPC connection closed
+    cleanup();
+    process.exit(0);
+}, () => {
+    // IPC connection error
+    cleanup();
+    process.exit(0);
+});
+pseudoIPC.notifyChildIsReady(forkId);
+process.on('message', (message) => {
+    pseudoIPC.sendMessageToParent(message);
+});
+childProcess.on('exit', (code, signal) => {
+    cleanup();
+    if (code === null)
+        code = (0, exit_codes_1.signalToCode)(signal);
+    process.exit(code);
+});
+let isCleaningUp = false;
+function cleanup() {
+    if (isCleaningUp) {
+        return;
+    }
+    isCleaningUp = true;
+    // Kill child process if still running
+    if (childProcess && !childProcess.killed) {
+        childProcess.kill('SIGTERM');
+    }
+    // Close IPC connection
+    try {
+        pseudoIPC.close();
+    }
+    catch {
+        // Ignore errors when closing, connection might already be broken
+    }
+}
+// Terminate the child process when exiting
+process.on('exit', () => {
+    cleanup();
+});
+process.on('SIGINT', () => {
+    cleanup();
+    process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
+});
+process.on('SIGTERM', () => {
+    cleanup();
+});
+process.on('SIGHUP', () => {
+    cleanup();
+});

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

@@ -0,0 +1,43 @@
+import { ProjectGraph } from '../config/project-graph';
+import { Task, TaskGraph } from '../config/task-graph';
+import { DefaultTasksRunnerOptions } from './default-tasks-runner';
+import { PseudoTtyProcess } from './pseudo-terminal';
+import { BatchProcess } from './running-tasks/batch-process';
+import { RunningTask } from './running-tasks/running-task';
+import { Batch } from './tasks-schedule';
+export declare class ForkedProcessTaskRunner {
+    private readonly options;
+    private readonly tuiEnabled;
+    cliPath: string;
+    private readonly verbose;
+    private processes;
+    private finishedProcesses;
+    private pseudoTerminals;
+    constructor(options: DefaultTasksRunnerOptions, tuiEnabled: boolean);
+    init(): Promise<void>;
+    forkProcessForBatch({ id: batchId, 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;
+        pipeOutput: boolean;
+        taskGraph: TaskGraph;
+        env: NodeJS.ProcessEnv;
+    }): Promise<RunningTask>;
+    forkProcess(task: Task, { temporaryOutputPath, streamOutput, taskGraph, env, disablePseudoTerminal, }: {
+        temporaryOutputPath: string;
+        streamOutput: boolean;
+        pipeOutput: boolean;
+        taskGraph: TaskGraph;
+        env: NodeJS.ProcessEnv;
+        disablePseudoTerminal: boolean;
+    }): Promise<RunningTask | PseudoTtyProcess>;
+    private createPseudoTerminal;
+    private forkProcessWithPseudoTerminal;
+    private forkProcessWithPrefixAndNotTTY;
+    private forkProcessDirectOutputCapture;
+    private writeTerminalOutput;
+    cleanup(signal?: NodeJS.Signals): void;
+    private setupProcessEventListeners;
+}
+//# sourceMappingURL=forked-process-task-runner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"forked-process-task-runner.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/tasks-runner/forked-process-task-runner.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAMvD,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAEnE,OAAO,EAGL,gBAAgB,EACjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAK7D,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAE3D,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAOzC,qBAAa,uBAAuB;IAShC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAT7B,OAAO,SAAgB;IAEvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6C;IACrE,OAAO,CAAC,SAAS,CAAyC;IAC1D,OAAO,CAAC,iBAAiB,CAA2B;IACpD,OAAO,CAAC,eAAe,CAA6B;gBAGjC,OAAO,EAAE,yBAAyB,EAClC,UAAU,EAAE,OAAO;IAGhC,IAAI;IAKG,mBAAmB,CAC9B,EAAE,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,EAAE,KAAK,EAC/D,YAAY,EAAE,YAAY,EAC1B,aAAa,EAAE,SAAS,EACxB,GAAG,EAAE,MAAM,CAAC,UAAU,GACrB,OAAO,CAAC,YAAY,CAAC;IAgDjB,qBAAqB;IASf,iBAAiB,CAC5B,IAAI,EAAE,IAAI,EACV,EACE,mBAAmB,EACnB,YAAY,EACZ,UAAU,EACV,SAAS,EACT,GAAG,GACJ,EAAE;QACD,mBAAmB,EAAE,MAAM,CAAC;QAC5B,YAAY,EAAE,OAAO,CAAC;QACtB,UAAU,EAAE,OAAO,CAAC;QACpB,SAAS,EAAE,SAAS,CAAC;QACrB,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;KACxB,GACA,OAAO,CAAC,WAAW,CAAC;IAgBV,WAAW,CACtB,IAAI,EAAE,IAAI,EACV,EACE,mBAAmB,EACnB,YAAY,EACZ,SAAS,EACT,GAAG,EACH,qBAAqB,GACtB,EAAE;QACD,mBAAmB,EAAE,MAAM,CAAC;QAC5B,YAAY,EAAE,OAAO,CAAC;QACtB,UAAU,EAAE,OAAO,CAAC;QACpB,SAAS,EAAE,SAAS,CAAC;QACrB,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;QACvB,qBAAqB,EAAE,OAAO,CAAC;KAChC,GACA,OAAO,CAAC,WAAW,GAAG,gBAAgB,CAAC;YAiC5B,oBAAoB;YAapB,6BAA6B;IA6D3C,OAAO,CAAC,8BAA8B;IAmEtC,OAAO,CAAC,8BAA8B;IA2EtC,OAAO,CAAC,mBAAmB;IAI3B,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,OAAO;IAO/B,OAAO,CAAC,0BAA0B;CAwCnC"}