nx 18.1.0-canary.20240315-3b8cbae → 18.1.1

package/src/executors/run-commands/run-commands.impl.js

@@ -6,8 +6,7 @@ const path = require("path");
 const yargsParser = require("yargs-parser");
 const npm_run_path_1 = require("npm-run-path");
 const chalk = require("chalk");
-const native_1 = require("../../native");
-const child_process_2 = require("../../utils/child-process");
+const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
 exports.LARGE_BUFFER = 1024 * 1000000;
 async function loadEnvVars(path) {
     if (path) {
@@ -48,10 +47,11 @@ async function default_1(options, context) {
         !options.parallel) {
         throw new Error('ERROR: Bad executor config for run-commands - "prefix", "color" and "bgColor" can only be set when "parallel=true".');
     }
+    const terminal = (0, pseudo_terminal_1.getPseudoTerminal)();
     try {
         const result = options.parallel
-            ? await runInParallel(normalized, context)
-            : await runSerially(normalized, context);
+            ? await runInParallel(terminal, normalized, context)
+            : await runSerially(terminal, normalized, context);
         return result;
     }
     catch (e) {
@@ -62,8 +62,8 @@ async function default_1(options, context) {
     }
 }
 exports.default = default_1;
-async function runInParallel(options, context) {
-    const procs = options.commands.map((c) => createProcess(c, options.readyWhen, options.color, calculateCwd(options.cwd, context), options.env ?? {}, true, options.usePty, options.streamOutput).then((result) => ({
+async function runInParallel(pseudoTerminal, options, context) {
+    const procs = options.commands.map((c) => createProcess(pseudoTerminal, c, options.readyWhen, options.color, calculateCwd(options.cwd, context), options.env ?? {}, true, options.usePty, options.streamOutput).then((result) => ({
         result,
         command: c.command,
     })));
@@ -135,10 +135,10 @@ function normalizeOptions(options) {
     });
     return options;
 }
-async function runSerially(options, context) {
+async function runSerially(pseudoTerminal, options, context) {
     let terminalOutput = '';
     for (const c of options.commands) {
-        const result = await createProcess(c, undefined, options.color, calculateCwd(options.cwd, context), options.env ?? {}, false, options.usePty, options.streamOutput);
+        const result = await createProcess(pseudoTerminal, c, undefined, options.color, calculateCwd(options.cwd, context), options.env ?? {}, false, options.usePty, options.streamOutput);
         terminalOutput += result.terminalOutput;
         if (!result.success) {
             const output = `Warning: command "${c.command}" exited with non-zero status code`;
@@ -151,7 +151,7 @@ async function runSerially(options, context) {
     }
     return { success: true, terminalOutput };
 }
-async function createProcess(commandConfig, readyWhen, color, cwd, env, isParallel, usePty = true, streamOutput = true) {
+async function createProcess(pseudoTerminal, commandConfig, readyWhen, color, cwd, env, isParallel, usePty = true, streamOutput = true) {
     env = processEnv(color, cwd, env);
     // The rust runCommand is always a tty, so it will not look nice in parallel and if we need prefixes
     // currently does not work properly in windows
@@ -160,7 +160,11 @@ async function createProcess(commandConfig, readyWhen, color, cwd, env, isParall
         !commandConfig.prefix &&
         !isParallel &&
         usePty) {
-        const cp = new child_process_2.PseudoTtyProcess((0, native_1.runCommand)(commandConfig.command, cwd, env, !streamOutput));
+        const cp = pseudoTerminal.runCommand(commandConfig.command, {
+            cwd,
+            jsEnv: env,
+            quiet: !streamOutput,
+        });
         let terminalOutput = '';
         return new Promise((res) => {
             cp.onOutput((output) => {

package/src/executors/run-script/run-script.impl.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const path = require("path");
-const native_1 = require("../../native");
-const child_process_1 = require("../../utils/child-process");
 const package_manager_1 = require("../../utils/package-manager");
-const child_process_2 = require("child_process");
+const child_process_1 = require("child_process");
+const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
 async function default_1(options, context) {
     const pm = (0, package_manager_1.getPackageManagerCommand)();
     try {
@@ -32,15 +31,16 @@ async function default_1(options, context) {
 }
 exports.default = default_1;
 function nodeProcess(command, cwd, env) {
-    (0, child_process_2.execSync)(command, {
+    (0, child_process_1.execSync)(command, {
         stdio: ['inherit', 'inherit', 'inherit'],
         cwd,
         env,
     });
 }
 async function ptyProcess(command, cwd, env) {
+    const terminal = (0, pseudo_terminal_1.getPseudoTerminal)();
     return new Promise((res, rej) => {
-        const cp = new child_process_1.PseudoTtyProcess((0, native_1.runCommand)(command, cwd, env));
+        const cp = terminal.runCommand(command, { cwd, jsEnv: env });
         cp.onExit((code) => {
             if (code === 0) {
                 res();

package/src/migrations/update-17-3-0/nx-release-path.js

@@ -5,7 +5,6 @@ const node_path_1 = require("node:path");
 const ignore_1 = require("../../utils/ignore");
 function nxReleasePath(tree) {
     visitNotIgnoredFiles(tree, '', (file) => {
-        console.log({ file });
         const contents = tree.read(file).toString('utf-8');
         if (
         // the deep import usage should be replaced by the new location

package/src/native/index.d.ts

@@ -21,12 +21,6 @@ export function expandOutputs(directory: string, entries: Array<string>): Array<
 export function getFilesForOutputs(directory: string, entries: Array<string>): Array<string>
 export function remove(src: string): void
 export function copy(src: string, dest: string): void
-export function runCommand(command: string, commandDir?: string | undefined | null, jsEnv?: Record<string, string> | undefined | null, quiet?: boolean | undefined | null): ChildProcess
-/**
- * This allows us to run a pseudoterminal with a fake node ipc channel
- * this makes it possible to be backwards compatible with the old implementation
- */
-export function nxFork(id: string, forkScript: string, psuedoIpcPath: string, commandDir: string | undefined | null, jsEnv: Record<string, string> | undefined | null, quiet: boolean): ChildProcess
 export function hashArray(input: Array<string>): string
 export function hashFile(file: string): string | null
 export function findImports(projectFileMap: Record<string, Array<string>>): Array<ImportResult>
@@ -146,17 +140,26 @@ export interface FileMap {
   nonProjectFiles: Array<FileData>
 }
 export function testOnlyTransferFileMap(projectFiles: Record<string, Array<FileData>>, nonProjectFiles: Array<FileData>): NxWorkspaceFilesExternals
-export class ChildProcess {
-  kill(): void
-  onExit(callback: (message: string) => void): void
-  onOutput(callback: (message: string) => void): void
-}
 export class ImportResult {
   file: string
   sourceProject: string
   dynamicImportExpressions: Array<string>
   staticImportExpressions: Array<string>
 }
+export class ChildProcess {
+  kill(): void
+  onExit(callback: (message: string) => void): void
+  onOutput(callback: (message: string) => void): void
+}
+export class RustPseudoTerminal {
+  constructor()
+  runCommand(command: string, commandDir?: string | undefined | null, jsEnv?: Record<string, string> | undefined | null, quiet?: boolean | undefined | null): ChildProcess
+  /**
+   * This allows us to run a pseudoterminal with a fake node ipc channel
+   * this makes it possible to be backwards compatible with the old implementation
+   */
+  fork(id: string, forkScript: string, pseudoIpcPath: string, commandDir: string | undefined | null, jsEnv: Record<string, string> | undefined | null, quiet: boolean): ChildProcess
+}
 export class HashPlanner {
   constructor(nxJson: NxJson, projectGraph: ExternalObject<ProjectGraph>)
   getPlans(taskIds: Array<string>, taskGraph: TaskGraph): Record<string, string[]>

package/src/native/index.js

@@ -246,20 +246,19 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { expandOutputs, getFilesForOutputs, remove, copy, ChildProcess, runCommand, nxFork, hashArray, hashFile, ImportResult, findImports, transferProjectGraph, HashPlanner, TaskHasher, EventType, Watcher, WorkspaceContext, WorkspaceErrors, testOnlyTransferFileMap } = nativeBinding
+const { expandOutputs, getFilesForOutputs, remove, copy, hashArray, hashFile, ImportResult, findImports, transferProjectGraph, ChildProcess, RustPseudoTerminal, HashPlanner, TaskHasher, EventType, Watcher, WorkspaceContext, WorkspaceErrors, testOnlyTransferFileMap } = nativeBinding
 
 module.exports.expandOutputs = expandOutputs
 module.exports.getFilesForOutputs = getFilesForOutputs
 module.exports.remove = remove
 module.exports.copy = copy
-module.exports.ChildProcess = ChildProcess
-module.exports.runCommand = runCommand
-module.exports.nxFork = nxFork
 module.exports.hashArray = hashArray
 module.exports.hashFile = hashFile
 module.exports.ImportResult = ImportResult
 module.exports.findImports = findImports
 module.exports.transferProjectGraph = transferProjectGraph
+module.exports.ChildProcess = ChildProcess
+module.exports.RustPseudoTerminal = RustPseudoTerminal
 module.exports.HashPlanner = HashPlanner
 module.exports.TaskHasher = TaskHasher
 module.exports.EventType = EventType

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

@@ -147,7 +147,7 @@ Object.defineProperty(exports, "workspaceLayout", { enumerable: true, get: funct
  * TODO(v19): Remove this function.
  */
 function getProjectsSyncNoInference(root, nxJson) {
-    const projectFiles = (0, retrieve_workspace_files_1.retrieveProjectConfigurationPaths)(root, (0, nx_plugin_deprecated_1.getDefaultPluginsSync)(root));
+    const allConfigFiles = (0, retrieve_workspace_files_1.retrieveProjectConfigurationPaths)(root, (0, nx_plugin_deprecated_1.getDefaultPluginsSync)(root));
     const plugins = [
         { plugin: package_json_next_to_project_json_1.PackageJsonProjectsNextToProjectJsonPlugin },
         ...(0, nx_plugin_deprecated_1.getDefaultPluginsSync)(root),
@@ -159,11 +159,13 @@ function getProjectsSyncNoInference(root, nxJson) {
         if (!pattern) {
             continue;
         }
-        for (const file of projectFiles) {
+        const matchingConfigFiles = allConfigFiles.filter((file) => (0, minimatch_1.minimatch)(file, pattern, { dot: true }));
+        for (const file of matchingConfigFiles) {
             if ((0, minimatch_1.minimatch)(file, pattern, { dot: true })) {
                 let r = createNodes(file, options, {
                     nxJsonConfiguration: nxJson,
                     workspaceRoot: root,
+                    configFiles: matchingConfigFiles,
                 });
                 for (const node in r.projects) {
                     const project = {

package/src/project-graph/utils/project-configuration-utils.d.ts

@@ -20,11 +20,11 @@ export type ConfigurationResult = {
  * 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
  */
-export declare function buildProjectsConfigurationsFromProjectPathsAndPlugins(nxJson: NxJsonConfiguration, projectFiles: string[], // making this parameter allows devkit to pick up newly created projects
+export declare function buildProjectsConfigurationsFromProjectPathsAndPlugins(nxJson: NxJsonConfiguration, workspaceFiles: string[], // making this parameter allows devkit to pick up newly created projects
 plugins: LoadedNxPlugin[], root?: string): Promise<ConfigurationResult>;
 export declare function readProjectConfigurationsFromRootMap(projectRootMap: Map<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
 /**

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

@@ -124,11 +124,11 @@ 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.
@@ -139,40 +139,40 @@ plugins, root = workspace_root_1.workspaceRoot) {
         if (!pattern) {
             continue;
         }
-        for (const file of projectFiles) {
+        const matchingConfigFiles = workspaceFiles.filter(minimatch_1.minimatch.filter(pattern, { dot: true }));
+        for (const file of matchingConfigFiles) {
             performance.mark(`${plugin.name}:createNodes:${file} - start`);
-            if ((0, minimatch_1.minimatch)(file, pattern, { dot: true })) {
-                try {
-                    let r = createNodes(file, options, {
-                        nxJsonConfiguration: nxJson,
-                        workspaceRoot: root,
-                    });
-                    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 {
+            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`);
-                        pluginResults.push({
-                            ...r,
-                            file,
-                            pluginName: plugin.name,
-                        });
-                    }
+                        return { ...r, file, pluginName: plugin.name };
+                    }));
                 }
-                catch (e) {
-                    throw new CreateNodesError(`Unable to create nodes for ${file} using plugin ${plugin.name}.`, e);
+                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);
+            }
         }
         // If there are no promises (counter undefined) or all promises have resolved (counter === 0)
         results.push(Promise.all(pluginResults).then((results) => {

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

@@ -57,8 +57,8 @@ async function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot, n
 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);
@@ -75,7 +75,7 @@ async function retrieveProjectConfigurationsWithoutPluginInference(root) {
     if (projectsWithoutPluginCache.has(cacheKey)) {
         return projectsWithoutPluginCache.get(cacheKey);
     }
-    const projectFiles = (0, workspace_context_1.globWithWorkspaceContext)(root, projectGlobPatterns);
+    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 },

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/{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;
+}