nx 17.0.2 → 17.0.4

package/src/project-graph/utils/retrieve-workspace-files.d.ts

@@ -1,6 +1,6 @@
-import { ProjectConfiguration, ProjectsConfigurations } from '../../config/workspace-json-project-json';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { NxJsonConfiguration } from '../../config/nx-json';
-import { FileData, ProjectGraphExternalNode } from '../../config/project-graph';
+import { ConfigurationResult } from './project-configuration-utils';
 import { LoadedNxPlugin } from '../../utils/nx-plugin';
 /**
  * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
@@ -8,14 +8,13 @@ import { LoadedNxPlugin } from '../../utils/nx-plugin';
  * @param workspaceRoot
  * @param nxJson
  */
-export declare function retrieveWorkspaceFiles(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<{
-    allWorkspaceFiles: FileData[];
+export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<{
+    allWorkspaceFiles: import("nx/src/devkit-exports").FileData[];
     fileMap: {
-        projectFileMap: Record<string, import("../../native").FileData[]>;
-        nonProjectFiles: import("../../native").FileData[];
+        projectFileMap: ProjectFiles;
+        nonProjectFiles: import("nx/src/native").FileData[];
     };
-    projectConfigurations: ProjectsConfigurations;
-    externalNodes: Record<string, ProjectGraphExternalNode>;
+    rustReferences: import("nx/src/native").NxWorkspaceFilesExternals;
 }>;
 /**
  * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.
@@ -23,26 +22,8 @@ export declare function retrieveWorkspaceFiles(workspaceRoot: string, nxJson: Nx
  * @param workspaceRoot
  * @param nxJson
  */
-export declare function retrieveProjectConfigurations(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<{
-    externalNodes: Record<string, ProjectGraphExternalNode>;
-    projectNodes: Record<string, ProjectConfiguration>;
-}>;
-export declare function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<{
-    externalNodes: Record<string, ProjectGraphExternalNode>;
-    projectNodes: Record<string, ProjectConfiguration>;
-}>;
-/**
- * @deprecated Use {@link retrieveProjectConfigurations} instead.
- */
-export declare function retrieveProjectConfigurationsSync(workspaceRoot: string, nxJson: NxJsonConfiguration): {
-    externalNodes: Record<string, ProjectGraphExternalNode>;
-    projectNodes: Record<string, ProjectConfiguration>;
-};
-export declare function retrieveProjectConfigurationPaths(root: string, nxJson: NxJsonConfiguration): Promise<string[]>;
-export declare function retrieveProjectConfigurationPathsWithoutPluginInference(root: string): string[];
-export declare function retrieveProjectConfigurationsWithoutPluginInference(root: string): Record<string, ProjectConfiguration>;
-export declare function createProjectConfigurations(workspaceRoot: string, nxJson: NxJsonConfiguration, configFiles: string[], plugins: LoadedNxPlugin[]): {
-    projects: Record<string, ProjectConfiguration>;
-    externalNodes: Record<string, ProjectGraphExternalNode>;
-};
-export declare function configurationGlobs(workspaceRoot: string, plugins: LoadedNxPlugin[]): string[];
+export declare function retrieveProjectConfigurations(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<ConfigurationResult>;
+export declare function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<ConfigurationResult>;
+export declare function retrieveProjectConfigurationPaths(root: string, plugins: LoadedNxPlugin[]): string[];
+export declare function retrieveProjectConfigurationsWithoutPluginInference(root: string): Promise<Record<string, ProjectConfiguration>>;
+export declare function configurationGlobs(plugins: LoadedNxPlugin[]): string[];

package/src/project-graph/utils/retrieve-workspace-files.js

@@ -1,48 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configurationGlobs = exports.createProjectConfigurations = exports.retrieveProjectConfigurationsWithoutPluginInference = exports.retrieveProjectConfigurationPathsWithoutPluginInference = exports.retrieveProjectConfigurationPaths = exports.retrieveProjectConfigurationsSync = exports.retrieveProjectConfigurationsWithAngularProjects = exports.retrieveProjectConfigurations = exports.retrieveWorkspaceFiles = void 0;
+exports.configurationGlobs = exports.retrieveProjectConfigurationsWithoutPluginInference = exports.retrieveProjectConfigurationPaths = exports.retrieveProjectConfigurationsWithAngularProjects = exports.retrieveProjectConfigurations = exports.retrieveWorkspaceFiles = void 0;
 const perf_hooks_1 = require("perf_hooks");
 const installation_directory_1 = require("../../utils/installation-directory");
 const angular_json_1 = require("../../adapter/angular-json");
 const nx_json_1 = require("../../config/nx-json");
-const package_json_workspaces_1 = require("../../../plugins/package-json-workspaces");
+const package_json_workspaces_1 = require("../../plugins/package-json-workspaces");
 const project_configuration_utils_1 = require("./project-configuration-utils");
 const nx_plugin_1 = require("../../utils/nx-plugin");
 const project_json_1 = require("../../plugins/project-json/build-nodes/project-json");
 const workspace_context_1 = require("../../utils/workspace-context");
+const build_all_workspace_files_1 = require("./build-all-workspace-files");
 /**
  * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
  * @throws
  * @param workspaceRoot
  * @param nxJson
  */
-async function retrieveWorkspaceFiles(workspaceRoot, nxJson) {
+async function retrieveWorkspaceFiles(workspaceRoot, projectRootMap) {
     perf_hooks_1.performance.mark('native-file-deps:start');
-    const plugins = await (0, nx_plugin_1.loadNxPlugins)(nxJson?.plugins ?? [], (0, installation_directory_1.getNxRequirePaths)(workspaceRoot), workspaceRoot);
-    let globs = configurationGlobs(workspaceRoot, plugins);
     perf_hooks_1.performance.mark('native-file-deps:end');
     perf_hooks_1.performance.measure('native-file-deps', 'native-file-deps:start', 'native-file-deps:end');
     perf_hooks_1.performance.mark('get-workspace-files:start');
-    const { projectConfigurations, projectFileMap, globalFiles, externalNodes } = (0, workspace_context_1.getNxWorkspaceFilesFromContext)(workspaceRoot, globs, (configs) => {
-        const projectConfigurations = createProjectConfigurations(workspaceRoot, nxJson, configs, plugins);
-        return {
-            projectNodes: projectConfigurations.projects,
-            externalNodes: projectConfigurations.externalNodes,
-        };
-    });
+    const { projectFileMap, globalFiles, externalReferences } = (0, workspace_context_1.getNxWorkspaceFilesFromContext)(workspaceRoot, projectRootMap);
     perf_hooks_1.performance.mark('get-workspace-files:end');
     perf_hooks_1.performance.measure('get-workspace-files', 'get-workspace-files:start', 'get-workspace-files:end');
     return {
-        allWorkspaceFiles: buildAllWorkspaceFiles(projectFileMap, globalFiles),
+        allWorkspaceFiles: (0, build_all_workspace_files_1.buildAllWorkspaceFiles)(projectFileMap, globalFiles),
         fileMap: {
             projectFileMap,
             nonProjectFiles: globalFiles,
         },
-        projectConfigurations: {
-            version: 2,
-            projects: projectConfigurations,
-        },
-        externalNodes: externalNodes,
+        rustReferences: externalReferences,
     };
 }
 exports.retrieveWorkspaceFiles = retrieveWorkspaceFiles;
@@ -54,8 +43,7 @@ exports.retrieveWorkspaceFiles = retrieveWorkspaceFiles;
  */
 async function retrieveProjectConfigurations(workspaceRoot, nxJson) {
     const plugins = await (0, nx_plugin_1.loadNxPlugins)(nxJson?.plugins ?? [], (0, installation_directory_1.getNxRequirePaths)(workspaceRoot), workspaceRoot);
-    const globs = configurationGlobs(workspaceRoot, plugins);
-    return _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins, globs);
+    return _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins);
 }
 exports.retrieveProjectConfigurations = retrieveProjectConfigurations;
 async function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot, nxJson) {
@@ -64,82 +52,40 @@ async function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot, n
         !plugins.some((p) => p.plugin.name === angular_json_1.NX_ANGULAR_JSON_PLUGIN_NAME)) {
         plugins.push({ plugin: angular_json_1.NxAngularJsonPlugin });
     }
-    const globs = configurationGlobs(workspaceRoot, plugins);
-    return _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins, globs);
+    return _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins);
 }
 exports.retrieveProjectConfigurationsWithAngularProjects = retrieveProjectConfigurationsWithAngularProjects;
-/**
- * @deprecated Use {@link retrieveProjectConfigurations} instead.
- */
-function retrieveProjectConfigurationsSync(workspaceRoot, nxJson) {
-    const plugins = (0, nx_plugin_1.loadNxPluginsSync)(nxJson?.plugins ?? [], (0, installation_directory_1.getNxRequirePaths)(workspaceRoot), workspaceRoot);
-    const globs = configurationGlobs(workspaceRoot, plugins);
-    return _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins, globs);
-}
-exports.retrieveProjectConfigurationsSync = retrieveProjectConfigurationsSync;
-function _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins, globs) {
-    return (0, workspace_context_1.getProjectConfigurationsFromContext)(workspaceRoot, globs, (configs) => {
-        const projectConfigurations = createProjectConfigurations(workspaceRoot, nxJson, configs, plugins);
-        return {
-            projectNodes: projectConfigurations.projects,
-            externalNodes: projectConfigurations.externalNodes,
-        };
-    });
+function _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins) {
+    const globPatterns = configurationGlobs(plugins);
+    const workspaceFiles = (0, workspace_context_1.globWithWorkspaceContext)(workspaceRoot, globPatterns);
+    return (0, project_configuration_utils_1.createProjectConfigurations)(workspaceRoot, nxJson, workspaceFiles, plugins);
 }
-async function retrieveProjectConfigurationPaths(root, nxJson) {
-    const projectGlobPatterns = configurationGlobs(root, await (0, nx_plugin_1.loadNxPlugins)(nxJson?.plugins ?? [], (0, installation_directory_1.getNxRequirePaths)(root), root));
+function retrieveProjectConfigurationPaths(root, plugins) {
+    const projectGlobPatterns = configurationGlobs(plugins);
     return (0, workspace_context_1.globWithWorkspaceContext)(root, projectGlobPatterns);
 }
 exports.retrieveProjectConfigurationPaths = retrieveProjectConfigurationPaths;
-function retrieveProjectConfigurationPathsWithoutPluginInference(root) {
-    return (0, workspace_context_1.globWithWorkspaceContext)(root, configurationGlobsWithoutPlugins(root));
-}
-exports.retrieveProjectConfigurationPathsWithoutPluginInference = retrieveProjectConfigurationPathsWithoutPluginInference;
 const projectsWithoutPluginCache = new Map();
 // TODO: This function is called way too often, it should be optimized without this cache
-function retrieveProjectConfigurationsWithoutPluginInference(root) {
+async function retrieveProjectConfigurationsWithoutPluginInference(root) {
     const nxJson = (0, nx_json_1.readNxJson)(root);
-    const projectGlobPatterns = configurationGlobsWithoutPlugins(root);
+    const plugins = await (0, nx_plugin_1.getDefaultPlugins)(root);
+    const projectGlobPatterns = retrieveProjectConfigurationPaths(root, plugins);
     const cacheKey = root + ',' + projectGlobPatterns.join(',');
     if (projectsWithoutPluginCache.has(cacheKey)) {
         return projectsWithoutPluginCache.get(cacheKey);
     }
-    const projectConfigurations = (0, workspace_context_1.getProjectConfigurationsFromContext)(root, projectGlobPatterns, (configs) => {
-        const { projects } = createProjectConfigurations(root, nxJson, configs, [
-            { plugin: (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root) },
-            { plugin: project_json_1.CreateProjectJsonProjectsPlugin },
-        ]);
-        return {
-            projectNodes: projects,
-            externalNodes: {},
-        };
-    }).projectNodes;
-    projectsWithoutPluginCache.set(cacheKey, projectConfigurations);
-    return projectConfigurations;
+    const projectFiles = (0, workspace_context_1.globWithWorkspaceContext)(root, projectGlobPatterns) ?? [];
+    const { projects } = await (0, project_configuration_utils_1.createProjectConfigurations)(root, nxJson, projectFiles, [
+        { plugin: (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root) },
+        { plugin: project_json_1.ProjectJsonProjectsPlugin },
+    ]);
+    projectsWithoutPluginCache.set(cacheKey, projects);
+    return projects;
 }
 exports.retrieveProjectConfigurationsWithoutPluginInference = retrieveProjectConfigurationsWithoutPluginInference;
-function buildAllWorkspaceFiles(projectFileMap, globalFiles) {
-    perf_hooks_1.performance.mark('get-all-workspace-files:start');
-    let fileData = Object.values(projectFileMap).flat();
-    fileData = fileData.concat(globalFiles).sort();
-    perf_hooks_1.performance.mark('get-all-workspace-files:end');
-    perf_hooks_1.performance.measure('get-all-workspace-files', 'get-all-workspace-files:start', 'get-all-workspace-files:end');
-    return fileData;
-}
-function createProjectConfigurations(workspaceRoot, nxJson, configFiles, plugins) {
-    perf_hooks_1.performance.mark('build-project-configs:start');
-    const { projects, externalNodes } = (0, project_configuration_utils_1.buildProjectsConfigurationsFromProjectPathsAndPlugins)(nxJson, configFiles, plugins, workspaceRoot);
-    let projectConfigurations = projects;
-    perf_hooks_1.performance.mark('build-project-configs:end');
-    perf_hooks_1.performance.measure('build-project-configs', 'build-project-configs:start', 'build-project-configs:end');
-    return {
-        projects: projectConfigurations,
-        externalNodes,
-    };
-}
-exports.createProjectConfigurations = createProjectConfigurations;
-function configurationGlobs(workspaceRoot, plugins) {
-    const globPatterns = configurationGlobsWithoutPlugins(workspaceRoot);
+function configurationGlobs(plugins) {
+    const globPatterns = [];
     for (const { plugin } of plugins) {
         if (plugin.createNodes) {
             globPatterns.push(plugin.createNodes[0]);
@@ -148,10 +94,3 @@ function configurationGlobs(workspaceRoot, plugins) {
     return globPatterns;
 }
 exports.configurationGlobs = configurationGlobs;
-function configurationGlobsWithoutPlugins(workspaceRoot) {
-    return [
-        'project.json',
-        '**/project.json',
-        ...(0, package_json_workspaces_1.getGlobPatternsFromPackageManagerWorkspaces)(workspaceRoot),
-    ];
-}

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

@@ -7,16 +7,16 @@ const project_graph_1 = require("../../project-graph/project-graph");
 const configuration_1 = require("../../config/configuration");
 const async_iterator_1 = require("../../utils/async-iterator");
 const executor_utils_1 = require("../../command-line/run/executor-utils");
-function getBatchExecutor(executorName) {
+function getBatchExecutor(executorName, projects) {
     const [nodeModule, exportName] = executorName.split(':');
-    return (0, executor_utils_1.getExecutorInformation)(nodeModule, exportName, workspace_root_1.workspaceRoot);
+    return (0, executor_utils_1.getExecutorInformation)(nodeModule, exportName, workspace_root_1.workspaceRoot, projects);
 }
 async function runTasks(executorName, batchTaskGraph, fullTaskGraph) {
     const input = {};
     const projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
     const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
     const nxJsonConfiguration = (0, configuration_1.readNxJson)();
-    const batchExecutor = getBatchExecutor(executorName);
+    const batchExecutor = getBatchExecutor(executorName, projectsConfigurations.projects);
     const tasks = Object.values(batchTaskGraph.tasks);
     const context = {
         root: workspace_root_1.workspaceRoot,

package/src/tasks-runner/cache.js

@@ -215,18 +215,21 @@ class Cache {
     }
     tryAndRetry(fn) {
         let attempts = 0;
-        const baseTimeout = 100;
+        const baseTimeout = 5;
+        // Generate a random number between 2 and 4 to raise to the power of attempts
+        const baseExponent = Math.random() * 2 + 2;
         const _try = async () => {
             try {
                 attempts++;
                 return await fn();
             }
             catch (e) {
-                if (attempts === 10) {
+                // Max time is 5 * 4^3 = 20480ms
+                if (attempts === 6) {
                     // After enough attempts, throw the error
                     throw e;
                 }
-                await new Promise((res) => setTimeout(res, baseTimeout * attempts));
+                await new Promise((res) => setTimeout(res, baseExponent ** attempts));
                 return await _try();
             }
         };

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

@@ -170,7 +170,7 @@ class ProcessTasks {
             projectRoot: project.data.root,
             overrides: interpolatedOverrides,
             outputs: (0, utils_1.getOutputs)(this.projectGraph.nodes, qualifiedTarget, interpolatedOverrides),
-            // TODO(v18): Remove cast here after typing is moved back onto TargetConfiguration
+            // TODO(v19): Remove cast here after typing is moved back onto TargetConfiguration
             cache: project.data.targets[target].cache,
         };
     }

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

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

package/src/tasks-runner/fork.js

@@ -0,0 +1,23 @@
+"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 pseudoIPCPath = process.argv[2];
+const forkId = process.argv[3];
+const script = (0, path_1.join)(__dirname, '../../bin/run-executor.js');
+const childProcess = (0, child_process_1.fork)(script, {
+    stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+});
+const pseudoIPC = new pseudo_ipc_1.PseudoIPCClient(pseudoIPCPath);
+pseudoIPC.onMessageFromParent(forkId, (message) => {
+    childProcess.send(message);
+});
+pseudoIPC.notifyChildIsReady(forkId);
+process.on('message', (message) => {
+    pseudoIPC.sendMessageToParent(message);
+});
+childProcess.on('exit', (code) => {
+    pseudoIPC.close();
+    process.exit(code);
+});

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

@@ -8,28 +8,36 @@ export declare class ForkedProcessTaskRunner {
     cliPath: string;
     private readonly verbose;
     private processes;
+    private pseudoTerminal;
     constructor(options: DefaultTasksRunnerOptions);
+    init(): Promise<void>;
     forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }: Batch, fullTaskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<BatchResults>;
-    forkProcessPipeOutputCapture(task: Task, { streamOutput, temporaryOutputPath, taskGraph, env, }: {
-        streamOutput: boolean;
+    forkProcessLegacy(task: Task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }: {
         temporaryOutputPath: string;
+        streamOutput: boolean;
+        pipeOutput: boolean;
         taskGraph: TaskGraph;
         env: NodeJS.ProcessEnv;
     }): Promise<{
         code: number;
         terminalOutput: string;
     }>;
-    forkProcessDirectOutputCapture(task: Task, { streamOutput, temporaryOutputPath, taskGraph, env, }: {
-        streamOutput: boolean;
+    forkProcess(task: Task, { temporaryOutputPath, streamOutput, taskGraph, env, disablePseudoTerminal, }: {
         temporaryOutputPath: string;
+        streamOutput: boolean;
+        pipeOutput: boolean;
         taskGraph: TaskGraph;
         env: NodeJS.ProcessEnv;
+        disablePseudoTerminal: boolean;
     }): Promise<{
         code: number;
         terminalOutput: string;
     }>;
+    private forkProcessWithPseudoTerminal;
+    private forkProcessPipeOutputCapture;
+    private forkProcessWithPrefixAndNotTTY;
+    private forkProcessDirectOutputCapture;
     private readTerminalOutput;
     private writeTerminalOutput;
-    private signalToCode;
     private setupProcessEventListeners;
 }

package/src/tasks-runner/forked-process-task-runner.js

@@ -11,6 +11,9 @@ const path_1 = require("path");
 const batch_messages_1 = require("./batch/batch-messages");
 const strip_indents_1 = require("../utils/strip-indents");
 const stream_1 = require("stream");
+const pseudo_terminal_1 = require("./pseudo-terminal");
+const exit_codes_1 = require("../utils/exit-codes");
+const forkScript = (0, path_1.join)(__dirname, './fork.js');
 const workerPath = (0, path_1.join)(__dirname, './batch/run-batch.js');
 class ForkedProcessTaskRunner {
     constructor(options) {
@@ -18,6 +21,14 @@ class ForkedProcessTaskRunner {
         this.cliPath = (0, utils_1.getCliPath)();
         this.verbose = process.env.NX_VERBOSE_LOGGING === 'true';
         this.processes = new Set();
+        this.pseudoTerminal = pseudo_terminal_1.PseudoTerminal.isSupported()
+            ? (0, pseudo_terminal_1.getPseudoTerminal)()
+            : null;
+    }
+    async init() {
+        if (this.pseudoTerminal) {
+            await this.pseudoTerminal.init();
+        }
         this.setupProcessEventListeners();
     }
     // TODO: vsavkin delegate terminal output printing
@@ -31,7 +42,6 @@ class ForkedProcessTaskRunner {
                 else {
                     const args = (0, utils_1.getPrintableCommandArgsForTask)(Object.values(batchTaskGraph.tasks)[0]);
                     output_1.output.logCommand(args.join(' '));
-                    output_1.output.addNewline();
                 }
                 const p = (0, child_process_1.fork)(workerPath, {
                     stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
@@ -41,7 +51,7 @@ class ForkedProcessTaskRunner {
                 p.once('exit', (code, signal) => {
                     this.processes.delete(p);
                     if (code === null)
-                        code = this.signalToCode(signal);
+                        code = (0, exit_codes_1.signalToCode)(signal);
                     if (code !== 0) {
                         const results = {};
                         for (const rootTaskId of batchTaskGraph.roots) {
@@ -83,13 +93,94 @@ class ForkedProcessTaskRunner {
             }
         });
     }
+    async forkProcessLegacy(task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }) {
+        return pipeOutput
+            ? await this.forkProcessPipeOutputCapture(task, {
+                temporaryOutputPath,
+                streamOutput,
+                taskGraph,
+                env,
+            })
+            : await this.forkProcessDirectOutputCapture(task, {
+                temporaryOutputPath,
+                streamOutput,
+                taskGraph,
+                env,
+            });
+    }
+    async forkProcess(task, { temporaryOutputPath, streamOutput, taskGraph, env, disablePseudoTerminal, }) {
+        const shouldPrefix = streamOutput && process.env.NX_PREFIX_OUTPUT === 'true';
+        // streamOutput would be false if we are running multiple targets
+        // there's no point in running the commands in a pty if we are not streaming the output
+        if (!this.pseudoTerminal ||
+            disablePseudoTerminal ||
+            !streamOutput ||
+            shouldPrefix) {
+            return this.forkProcessWithPrefixAndNotTTY(task, {
+                temporaryOutputPath,
+                streamOutput,
+                taskGraph,
+                env,
+            });
+        }
+        else {
+            return this.forkProcessWithPseudoTerminal(task, {
+                temporaryOutputPath,
+                streamOutput,
+                taskGraph,
+                env,
+            });
+        }
+    }
+    async forkProcessWithPseudoTerminal(task, { streamOutput, taskGraph, env, }) {
+        const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+        if (streamOutput) {
+            output_1.output.logCommand(args.join(' '));
+        }
+        const childId = task.id;
+        const p = await this.pseudoTerminal.fork(childId, forkScript, {
+            cwd: process.cwd(),
+            jsEnv: env,
+            quiet: !streamOutput,
+        });
+        p.send({
+            targetDescription: task.target,
+            overrides: task.overrides,
+            taskGraph,
+            isVerbose: this.verbose,
+        });
+        this.processes.add(p);
+        let terminalOutput = '';
+        p.onOutput((msg) => {
+            terminalOutput += msg;
+        });
+        return new Promise((res) => {
+            p.onExit((code) => {
+                // If the exit code is greater than 128, it's a special exit code for a signal
+                if (code >= 128) {
+                    process.exit(code);
+                }
+                res({
+                    code,
+                    terminalOutput,
+                });
+            });
+        });
+    }
     forkProcessPipeOutputCapture(task, { streamOutput, temporaryOutputPath, taskGraph, env, }) {
+        return this.forkProcessWithPrefixAndNotTTY(task, {
+            streamOutput,
+            temporaryOutputPath,
+            taskGraph,
+            env,
+        });
+    }
+    forkProcessWithPrefixAndNotTTY(task, { streamOutput, temporaryOutputPath, taskGraph, env, }) {
         return new Promise((res, rej) => {
             try {
                 const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
                 if (streamOutput) {
                     output_1.output.logCommand(args.join(' '));
-                    output_1.output.addNewline();
                 }
                 const p = (0, child_process_1.fork)(this.cliPath, {
                     stdio: ['inherit', 'pipe', 'pipe', 'ipc'],
@@ -137,7 +228,7 @@ class ForkedProcessTaskRunner {
                 p.on('exit', (code, signal) => {
                     this.processes.delete(p);
                     if (code === null)
-                        code = this.signalToCode(signal);
+                        code = (0, exit_codes_1.signalToCode)(signal);
                     // we didn't print any output as we were running the command
                     // print all the collected output|
                     const terminalOutput = outWithErr.join('');
@@ -160,7 +251,6 @@ class ForkedProcessTaskRunner {
                 const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
                 if (streamOutput) {
                     output_1.output.logCommand(args.join(' '));
-                    output_1.output.addNewline();
                 }
                 const p = (0, child_process_1.fork)(this.cliPath, {
                     stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
@@ -182,7 +272,7 @@ class ForkedProcessTaskRunner {
                 });
                 p.on('exit', (code, signal) => {
                     if (code === null)
-                        code = this.signalToCode(signal);
+                        code = (0, exit_codes_1.signalToCode)(signal);
                     // we didn't print any output as we were running the command
                     // print all the collected output
                     let terminalOutput = '';
@@ -219,20 +309,20 @@ class ForkedProcessTaskRunner {
     writeTerminalOutput(outputPath, content) {
         (0, fs_1.writeFileSync)(outputPath, content);
     }
-    signalToCode(signal) {
-        if (signal === 'SIGHUP')
-            return 128 + 1;
-        if (signal === 'SIGINT')
-            return 128 + 2;
-        if (signal === 'SIGTERM')
-            return 128 + 15;
-        return 128;
-    }
     setupProcessEventListeners() {
+        if (this.pseudoTerminal) {
+            this.pseudoTerminal.onMessageFromChildren((message) => {
+                process.send(message);
+            });
+        }
         // When the nx process gets a message, it will be sent into the task's process
         process.on('message', (message) => {
+            // this.publisher.publish(message.toString());
+            if (this.pseudoTerminal) {
+                this.pseudoTerminal.sendMessageToChildren(message);
+            }
             this.processes.forEach((p) => {
-                if (p.connected) {
+                if ('connected' in p && p.connected) {
                     p.send(message);
                 }
             });
@@ -240,23 +330,23 @@ class ForkedProcessTaskRunner {
         // Terminate any task processes on exit
         process.on('exit', () => {
             this.processes.forEach((p) => {
-                if (p.connected) {
+                if ('connected' in p ? p.connected : p.isAlive) {
                     p.kill();
                 }
             });
         });
         process.on('SIGINT', () => {
             this.processes.forEach((p) => {
-                if (p.connected) {
+                if ('connected' in p ? p.connected : p.isAlive) {
                     p.kill('SIGTERM');
                 }
             });
             // we exit here because we don't need to write anything to cache.
-            process.exit();
+            process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
         });
         process.on('SIGTERM', () => {
             this.processes.forEach((p) => {
-                if (p.connected) {
+                if ('connected' in p ? p.connected : p.isAlive) {
                     p.kill('SIGTERM');
                 }
             });
@@ -265,7 +355,7 @@ class ForkedProcessTaskRunner {
         });
         process.on('SIGHUP', () => {
             this.processes.forEach((p) => {
-                if (p.connected) {
+                if ('connected' in p ? p.connected : p.isAlive) {
                     p.kill('SIGTERM');
                 }
             });

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

@@ -19,7 +19,7 @@ async function initTasksRunner(nxArgs) {
     return {
         invoke: async (opts) => {
             perf_hooks_1.performance.mark('code-loading:end');
-            // TODO: This polyfills the outputs if someone doesn't pass a task with outputs. Remove this in Nx 18
+            // TODO: This polyfills the outputs if someone doesn't pass a task with outputs. Remove this in Nx 19
             opts.tasks.forEach((t) => {
                 if (!t.outputs) {
                     t.outputs = (0, utils_1.getOutputs)(projectGraph.nodes, t.target, t.overrides);