nx 18.1.0 → 18.1.1

package/src/project-graph/utils/project-configuration-utils.js

@@ -7,8 +7,6 @@ const workspace_root_1 = require("../../utils/workspace-root");
 const target_defaults_plugin_1 = require("../../plugins/target-defaults/target-defaults-plugin");
 const minimatch_1 = require("minimatch");
 const path_1 = require("path");
-const utils_1 = require("../plugins/utils");
-const plugin_pool_1 = require("../plugins/plugin-pool");
 function mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInformation, 
 // This function is used when reading project configuration
 // in generators, where we don't want to do this.
@@ -126,33 +124,62 @@ exports.mergeProjectConfigurationIntoRootMap = mergeProjectConfigurationIntoRoot
  * Transforms a list of project paths into a map of project configurations.
  *
  * @param nxJson The NxJson configuration
- * @param projectFiles A list of files identified as projects
+ * @param workspaceFiles A list of non-ignored workspace files
  * @param plugins The plugins that should be used to infer project configuration
  * @param root The workspace root
  */
-function buildProjectsConfigurationsFromProjectPathsAndPlugins(nxJson, projectFiles, // making this parameter allows devkit to pick up newly created projects
+function buildProjectsConfigurationsFromProjectPathsAndPlugins(nxJson, workspaceFiles, // making this parameter allows devkit to pick up newly created projects
 plugins, root = workspace_root_1.workspaceRoot) {
     const results = [];
     // We iterate over plugins first - this ensures that plugins specified first take precedence.
-    for (const plugin of plugins) {
+    for (const { plugin, options } of plugins) {
         const [pattern, createNodes] = plugin.createNodes ?? [];
+        const pluginResults = [];
+        performance.mark(`${plugin.name}:createNodes - start`);
         if (!pattern) {
             continue;
         }
-        const matchedFiles = [];
-        performance.mark(`${plugin.name}:createNodes - start`);
-        for (const file of projectFiles) {
-            if ((0, minimatch_1.minimatch)(file, pattern, { dot: true })) {
-                matchedFiles.push(file);
+        const matchingConfigFiles = workspaceFiles.filter(minimatch_1.minimatch.filter(pattern, { dot: true }));
+        for (const file of matchingConfigFiles) {
+            performance.mark(`${plugin.name}:createNodes:${file} - start`);
+            try {
+                let r = createNodes(file, options, {
+                    nxJsonConfiguration: nxJson,
+                    workspaceRoot: root,
+                    configFiles: matchingConfigFiles,
+                });
+                if (r instanceof Promise) {
+                    pluginResults.push(r
+                        .catch((e) => {
+                        performance.mark(`${plugin.name}:createNodes:${file} - end`);
+                        throw new CreateNodesError(`Unable to create nodes for ${file} using plugin ${plugin.name}.`, e);
+                    })
+                        .then((r) => {
+                        performance.mark(`${plugin.name}:createNodes:${file} - end`);
+                        performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
+                        return { ...r, file, pluginName: plugin.name };
+                    }));
+                }
+                else {
+                    performance.mark(`${plugin.name}:createNodes:${file} - end`);
+                    performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
+                    pluginResults.push({
+                        ...r,
+                        file,
+                        pluginName: plugin.name,
+                    });
+                }
+            }
+            catch (e) {
+                throw new CreateNodesError(`Unable to create nodes for ${file} using plugin ${plugin.name}.`, e);
             }
         }
-        let r = createNodes(matchedFiles, {
-            nxJsonConfiguration: nxJson,
-            workspaceRoot: root,
-        }).catch((e) => (0, plugin_pool_1.shutdownPluginWorkers)().then(() => {
-            throw e;
+        // If there are no promises (counter undefined) or all promises have resolved (counter === 0)
+        results.push(Promise.all(pluginResults).then((results) => {
+            performance.mark(`${plugin.name}:createNodes - end`);
+            performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
+            return results;
         }));
-        results.push(r);
     }
     return Promise.all(results).then((results) => {
         performance.mark('createNodes:merge - start');
@@ -174,7 +201,7 @@ plugins, root = workspace_root_1.workspaceRoot) {
                     mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInfo);
                 }
                 catch (e) {
-                    throw new utils_1.CreateNodesError(`Unable to merge project information for "${project.root}" from ${result.file} using plugin ${result.pluginName}.`, e);
+                    throw new CreateNodesError(`Unable to merge project information for "${project.root}" from ${result.file} using plugin ${result.pluginName}.`, e);
                 }
             }
             Object.assign(externalNodes, pluginExternalNodes);
@@ -234,6 +261,20 @@ function readProjectConfigurationsFromRootMap(projectRootMap) {
     return projects;
 }
 exports.readProjectConfigurationsFromRootMap = readProjectConfigurationsFromRootMap;
+class CreateNodesError extends Error {
+    constructor(msg, cause) {
+        const message = `${msg} ${!cause
+            ? ''
+            : cause instanceof Error
+                ? `\n\n\t Inner Error: ${cause.stack}`
+                : cause}`;
+        // These errors are thrown during a JS callback which is invoked via rust.
+        // The errors messaging gets lost in the rust -> js -> rust transition, but
+        // logging the error here will ensure that it is visible in the console.
+        console.error(message);
+        super(message, { cause });
+    }
+}
 /**
  * Merges two targets.
  *

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

@@ -2,7 +2,7 @@ import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { NxJsonConfiguration } from '../../config/nx-json';
 import { ProjectGraphExternalNode } from '../../config/project-graph';
 import { ConfigurationSourceMaps } from './project-configuration-utils';
-import { RemotePlugin } from '../plugins/internal-api';
+import { LoadedNxPlugin } from '../../utils/nx-plugin';
 /**
  * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
  * @throws
@@ -31,11 +31,7 @@ export type RetrievedGraphNodes = {
     sourceMaps: ConfigurationSourceMaps;
     projectRootMap: Record<string, string>;
 };
-export declare function retrieveProjectConfigurationPaths(root: string, plugins: PluginGlobsOnly): string[];
+export declare function retrieveProjectConfigurationPaths(root: string, plugins: LoadedNxPlugin[]): string[];
 export declare function retrieveProjectConfigurationsWithoutPluginInference(root: string): Promise<Record<string, ProjectConfiguration>>;
-export declare function createProjectConfigurations(workspaceRoot: string, nxJson: NxJsonConfiguration, configFiles: string[], plugins: RemotePlugin[]): Promise<RetrievedGraphNodes>;
-type PluginGlobsOnly = Array<{
-    createNodes?: readonly [string, ...unknown[]];
-}>;
-export declare function configurationGlobs(plugins: PluginGlobsOnly): string[];
-export {};
+export declare function createProjectConfigurations(workspaceRoot: string, nxJson: NxJsonConfiguration, configFiles: string[], plugins: LoadedNxPlugin[]): Promise<RetrievedGraphNodes>;
+export declare function configurationGlobs(plugins: LoadedNxPlugin[]): string[];

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

@@ -2,14 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configurationGlobs = exports.createProjectConfigurations = 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 project_configuration_utils_1 = require("./project-configuration-utils");
-const internal_api_1 = require("../plugins/internal-api");
+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");
-const path_1 = require("path");
-const plugin_pool_1 = require("../plugins/plugin-pool");
 /**
  * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
  * @throws
@@ -41,29 +42,23 @@ exports.retrieveWorkspaceFiles = retrieveWorkspaceFiles;
  * @param nxJson
  */
 async function retrieveProjectConfigurations(workspaceRoot, nxJson) {
-    const plugins = await (0, internal_api_1.loadNxPlugins)(nxJson?.plugins ?? [], workspaceRoot);
-    const projects = await _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins);
-    if (!global.NX_GRAPH_CREATION) {
-        await (0, plugin_pool_1.shutdownPluginWorkers)();
-    }
-    return projects;
+    const plugins = await (0, nx_plugin_1.loadNxPlugins)(nxJson?.plugins ?? [], (0, installation_directory_1.getNxRequirePaths)(workspaceRoot), workspaceRoot);
+    return _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins);
 }
 exports.retrieveProjectConfigurations = retrieveProjectConfigurations;
 async function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot, nxJson) {
-    const pluginsToLoad = nxJson?.plugins ?? [];
+    const plugins = await (0, nx_plugin_1.loadNxPlugins)(nxJson?.plugins ?? [], (0, installation_directory_1.getNxRequirePaths)(workspaceRoot), workspaceRoot);
     if ((0, angular_json_1.shouldMergeAngularProjects)(workspaceRoot, true) &&
-        !pluginsToLoad.some((p) => p === angular_json_1.NX_ANGULAR_JSON_PLUGIN_NAME ||
-            (typeof p === 'object' && p.plugin === angular_json_1.NX_ANGULAR_JSON_PLUGIN_NAME))) {
-        pluginsToLoad.push((0, path_1.join)(__dirname, '../../adapter/angular-json'));
+        !plugins.some((p) => p.plugin.name === angular_json_1.NX_ANGULAR_JSON_PLUGIN_NAME)) {
+        plugins.push({ plugin: angular_json_1.NxAngularJsonPlugin });
     }
-    const plugins = await (0, internal_api_1.loadNxPlugins)(nxJson?.plugins ?? [], workspaceRoot);
     return _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins);
 }
 exports.retrieveProjectConfigurationsWithAngularProjects = retrieveProjectConfigurationsWithAngularProjects;
 function _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins) {
     const globPatterns = configurationGlobs(plugins);
-    const projectFiles = (0, workspace_context_1.globWithWorkspaceContext)(workspaceRoot, globPatterns);
-    return createProjectConfigurations(workspaceRoot, nxJson, projectFiles, plugins);
+    const workspaceFiles = (0, workspace_context_1.globWithWorkspaceContext)(workspaceRoot, globPatterns);
+    return createProjectConfigurations(workspaceRoot, nxJson, workspaceFiles, plugins);
 }
 function retrieveProjectConfigurationPaths(root, plugins) {
     const projectGlobPatterns = configurationGlobs(plugins);
@@ -74,14 +69,17 @@ const projectsWithoutPluginCache = new Map();
 // TODO: This function is called way too often, it should be optimized without this cache
 async function retrieveProjectConfigurationsWithoutPluginInference(root) {
     const nxJson = (0, nx_json_1.readNxJson)(root);
-    const plugins = await (0, internal_api_1.loadNxPlugins)([]); // only load default plugins
+    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 projectFiles = (0, workspace_context_1.globWithWorkspaceContext)(root, projectGlobPatterns);
-    const { projects } = await createProjectConfigurations(root, nxJson, projectFiles, plugins);
+    const projectFiles = (0, workspace_context_1.globWithWorkspaceContext)(root, projectGlobPatterns) ?? [];
+    const { projects } = await createProjectConfigurations(root, nxJson, projectFiles, [
+        { plugin: (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root) },
+        { plugin: project_json_1.ProjectJsonProjectsPlugin },
+    ]);
     projectsWithoutPluginCache.set(cacheKey, projects);
     return projects;
 }
@@ -101,7 +99,7 @@ async function createProjectConfigurations(workspaceRoot, nxJson, configFiles, p
 exports.createProjectConfigurations = createProjectConfigurations;
 function configurationGlobs(plugins) {
     const globPatterns = [];
-    for (const plugin of plugins) {
+    for (const { plugin } of plugins) {
         if (plugin.createNodes) {
             globPatterns.push(plugin.createNodes[0]);
         }

package/src/tasks-runner/fork.js

@@ -2,22 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const path_1 = require("path");
-const psuedo_ipc_1 = require("./psuedo-ipc");
-const psuedoIPCPath = process.argv[2];
+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 psuedoIPC = new psuedo_ipc_1.PsuedoIPCClient(psuedoIPCPath);
-psuedoIPC.onMessageFromParent(forkId, (message) => {
+const pseudoIPC = new pseudo_ipc_1.PseudoIPCClient(pseudoIPCPath);
+pseudoIPC.onMessageFromParent(forkId, (message) => {
     childProcess.send(message);
 });
-psuedoIPC.notifyChildIsReady(forkId);
+pseudoIPC.notifyChildIsReady(forkId);
 process.on('message', (message) => {
-    psuedoIPC.sendMessageToParent(message);
+    pseudoIPC.sendMessageToParent(message);
 });
 childProcess.on('exit', (code) => {
-    psuedoIPC.close();
+    pseudoIPC.close();
     process.exit(code);
 });

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

@@ -8,8 +8,7 @@ export declare class ForkedProcessTaskRunner {
     cliPath: string;
     private readonly verbose;
     private processes;
-    private psuedoIPCPath;
-    private psuedoIPC;
+    private pseudoTerminal;
     constructor(options: DefaultTasksRunnerOptions);
     init(): Promise<void>;
     forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }: Batch, fullTaskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<BatchResults>;
@@ -33,12 +32,11 @@ export declare class ForkedProcessTaskRunner {
         code: number;
         terminalOutput: string;
     }>;
-    private forkProcessWithPsuedoTerminal;
+    private forkProcessWithPseudoTerminal;
     private forkProcessPipeOutputCapture;
     private forkProcessWithPrefixAndNotTTY;
     private forkProcessDirectOutputCapture;
     private readTerminalOutput;
     private writeTerminalOutput;
     private setupProcessEventListeners;
-    destroy(): void;
 }

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

@@ -11,10 +11,7 @@ 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 native_1 = require("../native");
-const psuedo_ipc_1 = require("./psuedo-ipc");
-const socket_utils_1 = require("../daemon/socket-utils");
-const child_process_2 = require("../utils/child-process");
+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');
@@ -24,11 +21,10 @@ class ForkedProcessTaskRunner {
         this.cliPath = (0, utils_1.getCliPath)();
         this.verbose = process.env.NX_VERBOSE_LOGGING === 'true';
         this.processes = new Set();
-        this.psuedoIPCPath = (0, socket_utils_1.FORKED_PROCESS_OS_SOCKET_PATH)(process.pid.toString());
-        this.psuedoIPC = new psuedo_ipc_1.PsuedoIPCServer(this.psuedoIPCPath);
+        this.pseudoTerminal = (0, pseudo_terminal_1.getPseudoTerminal)();
     }
     async init() {
-        await this.psuedoIPC.init();
+        await this.pseudoTerminal.init();
         this.setupProcessEventListeners();
     }
     // TODO: vsavkin delegate terminal output printing
@@ -121,7 +117,7 @@ class ForkedProcessTaskRunner {
             });
         }
         else {
-            return this.forkProcessWithPsuedoTerminal(task, {
+            return this.forkProcessWithPseudoTerminal(task, {
                 temporaryOutputPath,
                 streamOutput,
                 taskGraph,
@@ -129,15 +125,18 @@ class ForkedProcessTaskRunner {
             });
         }
     }
-    async forkProcessWithPsuedoTerminal(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 = new child_process_2.PseudoTtyProcess((0, native_1.nxFork)(childId, forkScript, this.psuedoIPCPath, process.cwd(), env, !streamOutput));
-        await this.psuedoIPC.waitForChildReady(childId);
-        this.psuedoIPC.sendMessageToChild(childId, {
+        const p = await this.pseudoTerminal.fork(childId, forkScript, {
+            cwd: process.cwd(),
+            jsEnv: env,
+            quiet: !streamOutput,
+        });
+        p.send({
             targetDescription: task.target,
             overrides: task.overrides,
             taskGraph,
@@ -304,13 +303,13 @@ class ForkedProcessTaskRunner {
         (0, fs_1.writeFileSync)(outputPath, content);
     }
     setupProcessEventListeners() {
-        this.psuedoIPC.onMessageFromChildren((message) => {
+        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());
-            this.psuedoIPC.sendMessageToChildren(message);
+            this.pseudoTerminal.sendMessageToChildren(message);
             this.processes.forEach((p) => {
                 if ('connected' in p && p.connected) {
                     p.send(message);
@@ -353,9 +352,6 @@ class ForkedProcessTaskRunner {
             // will store results to the cache and will terminate this process
         });
     }
-    destroy() {
-        this.psuedoIPC.close();
-    }
 }
 exports.ForkedProcessTaskRunner = ForkedProcessTaskRunner;
 const colors = [

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

@@ -9,8 +9,9 @@ const output_1 = require("../../utils/output");
 const pretty_time_1 = require("./pretty-time");
 const formatting_utils_1 = require("./formatting-utils");
 const view_logs_utils_1 = require("./view-logs-utils");
-const LEFT_PAD = `  `;
-const EXTENDED_LEFT_PAD = `    `;
+const LEFT_PAD = `   `;
+const SPACER = `  `;
+const EXTENDED_LEFT_PAD = `      `;
 /**
  * The following function is responsible for creating a life cycle with dynamic
  * outputs, meaning previous outputs can be rewritten or modified as new outputs
@@ -92,7 +93,7 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
         switch (status) {
             case 'local-cache':
                 writeCompletedTaskResultLine(`${output_1.output.colors.green(figures.tick) +
-                    '  ' +
+                    SPACER +
                     output_1.output.formatCommand(task.id)}  ${output_1.output.dim('[local cache]')}`);
                 if (isVerbose) {
                     writeCommandOutputBlock(tasksToTerminalOutputs[task.id]);
@@ -100,7 +101,7 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
                 break;
             case 'local-cache-kept-existing':
                 writeCompletedTaskResultLine(`${output_1.output.colors.green(figures.tick) +
-                    '  ' +
+                    SPACER +
                     output_1.output.formatCommand(task.id)}  ${output_1.output.dim('[existing outputs match the cache, left as is]')}`);
                 if (isVerbose) {
                     writeCommandOutputBlock(tasksToTerminalOutputs[task.id]);
@@ -108,7 +109,7 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
                 break;
             case 'remote-cache':
                 writeCompletedTaskResultLine(`${output_1.output.colors.green(figures.tick) +
-                    '  ' +
+                    SPACER +
                     output_1.output.formatCommand(task.id)}  ${output_1.output.dim('[remote cache]')}`);
                 if (isVerbose) {
                     writeCommandOutputBlock(tasksToTerminalOutputs[task.id]);
@@ -117,7 +118,7 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
             case 'success': {
                 const timeTakenText = (0, pretty_time_1.prettyTime)(process.hrtime(tasksToProcessStartTimes[task.id]));
                 writeCompletedTaskResultLine(output_1.output.colors.green(figures.tick) +
-                    '  ' +
+                    SPACER +
                     output_1.output.formatCommand(task.id) +
                     output_1.output.dim(` (${timeTakenText})`));
                 if (isVerbose) {
@@ -126,9 +127,10 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
                 break;
             }
             case 'failure':
+                output_1.output.addNewline();
                 output_1.output.addNewline();
                 writeCompletedTaskResultLine(output_1.output.colors.red(figures.cross) +
-                    '  ' +
+                    SPACER +
                     output_1.output.formatCommand(output_1.output.colors.red(task.id)));
                 writeCommandOutputBlock(tasksToTerminalOutputs[task.id]);
                 break;
@@ -145,10 +147,10 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
         const runningTasks = taskRows.filter((row) => row.status === 'running');
         const remainingTasks = totalTasks - totalCompletedTasks;
         if (runningTasks.length > 0) {
-            additionalFooterRows.push(output_1.output.dim(`${LEFT_PAD}${output_1.output.colors.cyan(figures.arrowRight)}    Executing ${runningTasks.length}/${remainingTasks} remaining tasks${runningTasks.length > 1 ? ' in parallel' : ''}...`));
+            additionalFooterRows.push(output_1.output.dim(`${LEFT_PAD}${output_1.output.colors.cyan(figures.arrowRight)}${SPACER}Executing ${runningTasks.length}/${remainingTasks} remaining tasks${runningTasks.length > 1 ? ' in parallel' : ''}...`));
             additionalFooterRows.push('');
             for (const runningTask of runningTasks) {
-                additionalFooterRows.push(`${LEFT_PAD}${output_1.output.dim.cyan(cli_spinners_1.dots.frames[currentFrame])}    ${output_1.output.formatCommand(runningTask.task.id)}`);
+                additionalFooterRows.push(`${LEFT_PAD}${output_1.output.dim.cyan(cli_spinners_1.dots.frames[currentFrame])}${SPACER}${output_1.output.formatCommand(runningTask.task.id)}`);
             }
             /**
              * Reduce layout thrashing by ensuring that there is a relatively consistent
@@ -172,10 +174,10 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
             additionalFooterRows.push('');
         }
         if (totalSuccessfulTasks > 0) {
-            additionalFooterRows.push(`${LEFT_PAD}${output_1.output.colors.green(figures.tick)}    ${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`);
+            additionalFooterRows.push(`${LEFT_PAD}${output_1.output.colors.green(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`);
         }
         if (totalFailedTasks > 0) {
-            additionalFooterRows.push(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}    ${totalFailedTasks}${`/${totalCompletedTasks}`} failed`);
+            additionalFooterRows.push(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} failed`);
         }
         moveCursorToStartOfPinnedFooter();
         if (additionalFooterRows.length > 1) {
@@ -253,9 +255,10 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
                 output_1.output.applyNxPrefix('red', output_1.output.colors.red(text) + output_1.output.dim.white(` (${timeTakenText})`)),
                 ...taskOverridesRows,
                 '',
-                output_1.output.dim(`${LEFT_PAD}${output_1.output.dim(figures.tick)}    ${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`),
+                output_1.output.dim(`${LEFT_PAD}${output_1.output.dim(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`),
+                '',
+                `${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} targets failed, including the following:`,
                 '',
-                `${LEFT_PAD}${output_1.output.colors.red(figures.cross)}    ${totalFailedTasks}${`/${totalCompletedTasks}`} targets failed, including the following:`,
                 `${failedTasksForPrinting
                     .map((t) => `${EXTENDED_LEFT_PAD}${output_1.output.colors.red('-')} ${output_1.output.formatCommand(t.toString())}`)
                     .join('\n ')}`,

package/src/tasks-runner/life-cycles/dynamic-run-one-terminal-output-life-cycle.js

@@ -9,8 +9,9 @@ const output_1 = require("../../utils/output");
 const pretty_time_1 = require("./pretty-time");
 const formatting_utils_1 = require("./formatting-utils");
 const view_logs_utils_1 = require("./view-logs-utils");
-const LEFT_PAD = `  `;
-const EXTENDED_LEFT_PAD = `    `;
+const LEFT_PAD = `   `;
+const SPACER = `  `;
+const EXTENDED_LEFT_PAD = `      `;
 /**
  * The following function is responsible for creating a life cycle with dynamic
  * outputs, meaning previous outputs can be rewritten or modified as new outputs
@@ -88,7 +89,7 @@ async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, arg
         switch (state) {
             case 'EXECUTING_DEPENDENT_TARGETS':
                 if (totalFailedTasks === 0) {
-                    linesToRender.push(`${LEFT_PAD}${output_1.output.colors.cyan(cli_spinners_1.dots.frames[dependentTargetsCurrentFrame])}    ${output_1.output.dim(`Nx is waiting on ${remainingDependentTasksNotFromInitiatingProject} dependent project tasks before running tasks from`)} ${initiatingProject}${output_1.output.dim('...')}`);
+                    linesToRender.push(`${LEFT_PAD}${output_1.output.colors.cyan(cli_spinners_1.dots.frames[dependentTargetsCurrentFrame])}${SPACER}${output_1.output.dim(`Nx is waiting on ${remainingDependentTasksNotFromInitiatingProject} dependent project tasks before running tasks from`)} ${initiatingProject}${output_1.output.dim('...')}`);
                     if (totalSuccessfulTasks > 0) {
                         linesToRender.push('');
                     }
@@ -96,10 +97,10 @@ async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, arg
                 break;
         }
         if (totalFailedTasks > 0) {
-            linesToRender.push(output_1.output.colors.red.dim(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}    ${totalFailedTasks}${`/${totalCompletedTasks}`} dependent project tasks failed (see below)`));
+            linesToRender.push(output_1.output.colors.red.dim(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} dependent project tasks failed (see below)`));
         }
         if (totalSuccessfulTasks > 0) {
-            linesToRender.push(output_1.output.dim(`${LEFT_PAD}${output_1.output.dim(figures.tick)}    ${totalSuccessfulTasks}${`/${totalCompletedTasks}`} dependent project tasks succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`));
+            linesToRender.push(output_1.output.dim(`${LEFT_PAD}${output_1.output.dim(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} dependent project tasks succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`));
         }
         moveCursorToStartOfDependentTargetLines();
         if (linesToRender.length > 1) {
@@ -212,8 +213,8 @@ async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, arg
                 output_1.output.applyNxPrefix('red', output_1.output.colors.red(text) + output_1.output.dim(` (${timeTakenText})`)),
                 ...taskOverridesLines,
                 '',
-                `${LEFT_PAD}${output_1.output.colors.red(figures.cross)}    ${totalFailedTasks}${`/${totalCompletedTasks}`} failed`,
-                `${LEFT_PAD}${output_1.output.dim(figures.tick)}    ${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`,
+                `${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} failed`,
+                `${LEFT_PAD}${output_1.output.dim(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`,
                 ...viewLogs,
             ], 'red');
         }

package/src/tasks-runner/{psuedo-ipc.d.ts → pseudo-ipc.d.ts}

@@ -6,24 +6,24 @@
  * Main Nx Process
  *   * Calls Rust Fork Function
  *     * `node fork.js`
- *     * Create a Rust - Node.js Agnostic Channel aka Psuedo IPC Channel
+ *     * Create a Rust - Node.js Agnostic Channel aka Pseudo IPC Channel
  *     * This returns RustChildProcess
  *         * RustChildProcess.onMessage(msg => ());
- *         * psuedo_ipc_channel.on_message() => tx.send(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 = getPsuedoIpcChannel(process.env.NX_IPC_CHANNEL_ID)
- *     * forkChildProcess.on('message', writeToPsuedoIpcChannel)
+ *     * channel = getPseudoIpcChannel(process.env.NX_IPC_CHANNEL_ID)
+ *     * forkChildProcess.on('message', writeToPseudoIpcChannel)
  */
 /// <reference types="node" />
 import { Serializable } from 'child_process';
-export interface PsuedoIPCMessage {
+export interface PseudoIPCMessage {
     type: 'TO_CHILDREN_FROM_PARENT' | 'TO_PARENT_FROM_CHILDREN' | 'CHILD_READY';
     id: string | undefined;
     message: Serializable;
 }
-export declare class PsuedoIPCServer {
+export declare class PseudoIPCServer {
     private path;
     private sockets;
     private server;
@@ -38,7 +38,7 @@ export declare class PsuedoIPCServer {
     onMessageFromChildren(onMessage: (message: Serializable) => void, onClose?: () => void, onError?: (err: Error) => void): void;
     close(): void;
 }
-export declare class PsuedoIPCClient {
+export declare class PseudoIPCClient {
     private path;
     private socket;
     constructor(path: string);

package/src/tasks-runner/{psuedo-ipc.js → pseudo-ipc.js}

@@ -7,21 +7,21 @@
  * Main Nx Process
  *   * Calls Rust Fork Function
  *     * `node fork.js`
- *     * Create a Rust - Node.js Agnostic Channel aka Psuedo IPC Channel
+ *     * Create a Rust - Node.js Agnostic Channel aka Pseudo IPC Channel
  *     * This returns RustChildProcess
  *         * RustChildProcess.onMessage(msg => ());
- *         * psuedo_ipc_channel.on_message() => tx.send(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 = getPsuedoIpcChannel(process.env.NX_IPC_CHANNEL_ID)
- *     * forkChildProcess.on('message', writeToPsuedoIpcChannel)
+ *     * channel = getPseudoIpcChannel(process.env.NX_IPC_CHANNEL_ID)
+ *     * forkChildProcess.on('message', writeToPseudoIpcChannel)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PsuedoIPCClient = exports.PsuedoIPCServer = void 0;
+exports.PseudoIPCClient = exports.PseudoIPCServer = void 0;
 const net_1 = require("net");
 const consume_messages_from_socket_1 = require("../utils/consume-messages-from-socket");
-class PsuedoIPCServer {
+class PseudoIPCServer {
     constructor(path) {
         this.path = path;
         this.sockets = new Set();
@@ -98,8 +98,8 @@ class PsuedoIPCServer {
         this.sockets.forEach((s) => s.destroy());
     }
 }
-exports.PsuedoIPCServer = PsuedoIPCServer;
-class PsuedoIPCClient {
+exports.PseudoIPCServer = PseudoIPCServer;
+class PseudoIPCClient {
     constructor(path) {
         this.path = path;
         this.socket = (0, net_1.connect)(this.path);
@@ -137,4 +137,4 @@ class PsuedoIPCClient {
         this.socket?.destroy();
     }
 }
-exports.PsuedoIPCClient = PsuedoIPCClient;
+exports.PseudoIPCClient = PseudoIPCClient;

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

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+import { ChildProcess, RustPseudoTerminal } from '../native';
+import { PseudoIPCServer } from './pseudo-ipc';
+import { Serializable } from 'child_process';
+export declare function getPseudoTerminal(): PseudoTerminal;
+export declare class PseudoTerminal {
+    private rustPseudoTerminal;
+    private pseudoIPCPath;
+    private pseudoIPC;
+    private initialized;
+    constructor(rustPseudoTerminal: RustPseudoTerminal);
+    init(): Promise<void>;
+    runCommand(command: string, { cwd, jsEnv, quiet, }?: {
+        cwd?: string;
+        jsEnv?: Record<string, string>;
+        quiet?: boolean;
+    }): PseudoTtyProcess;
+    fork(id: string, script: string, { cwd, jsEnv, quiet, }: {
+        cwd?: 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;
+}