nx 21.0.0-canary.20250205-45d5140 → 21.0.0-canary.20250416-caa26a7

package/src/executors/run-commands/running-tasks.js

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeriallyRunningTasks = exports.ParallelRunningTasks = void 0;
+exports.runSingleCommandWithPseudoTerminal = runSingleCommandWithPseudoTerminal;
+const chalk = require("chalk");
+const child_process_1 = require("child_process");
+const npm_run_path_1 = require("npm-run-path");
+const path_1 = require("path");
+const treeKill = require("tree-kill");
+const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
+const task_env_1 = require("../../tasks-runner/task-env");
+const exit_codes_1 = require("../../utils/exit-codes");
+const run_commands_impl_1 = require("./run-commands.impl");
+class ParallelRunningTasks {
+    constructor(options, context, tuiEnabled) {
+        this.tuiEnabled = tuiEnabled;
+        this.exitCallbacks = [];
+        this.childProcesses = options.commands.map((commandConfig) => new RunningNodeProcess(commandConfig, options.color, calculateCwd(options.cwd, context), options.env ?? {}, options.readyWhenStatus, options.streamOutput, options.envFile));
+        this.readyWhenStatus = options.readyWhenStatus;
+        this.streamOutput = options.streamOutput;
+        this.run();
+    }
+    async getResults() {
+        return new Promise((res) => {
+            this.onExit((code, terminalOutput) => {
+                res({ code, terminalOutput });
+            });
+        });
+    }
+    onExit(cb) {
+        this.exitCallbacks.push(cb);
+    }
+    send(message) {
+        for (const childProcess of this.childProcesses) {
+            childProcess.send(message);
+        }
+    }
+    async kill(signal) {
+        await Promise.all(this.childProcesses.map(async (p) => {
+            try {
+                return p.kill();
+            }
+            catch (e) {
+                console.error(`Unable to terminate "${p.command}"\nError:`, e);
+            }
+        }));
+    }
+    async run() {
+        if (this.readyWhenStatus.length) {
+            let { childProcess, result: { code, terminalOutput }, } = await Promise.race(this.childProcesses.map((childProcess) => new Promise((res) => {
+                childProcess.onExit((code, terminalOutput) => {
+                    res({
+                        childProcess,
+                        result: { code, terminalOutput },
+                    });
+                });
+            })));
+            if (code !== 0) {
+                const output = `Warning: command "${childProcess.command}" exited with non-zero status code`;
+                terminalOutput += output;
+                if (this.streamOutput) {
+                    process.stderr.write(output);
+                }
+            }
+            for (const cb of this.exitCallbacks) {
+                cb(code, terminalOutput);
+            }
+        }
+        else {
+            const results = await Promise.all(this.childProcesses.map((childProcess) => childProcess.getResults().then((result) => ({
+                childProcess,
+                result,
+            }))));
+            let terminalOutput = results
+                .map((r) => r.result.terminalOutput)
+                .join('\r\n');
+            const failed = results.filter((result) => result.result.code !== 0);
+            if (failed.length > 0) {
+                const output = failed
+                    .map((failedResult) => `Warning: command "${failedResult.childProcess.command}" exited with non-zero status code`)
+                    .join('\r\n');
+                terminalOutput += output;
+                if (this.streamOutput) {
+                    process.stderr.write(output);
+                }
+                for (const cb of this.exitCallbacks) {
+                    cb(1, terminalOutput);
+                }
+            }
+            else {
+                for (const cb of this.exitCallbacks) {
+                    cb(0, terminalOutput);
+                }
+            }
+        }
+    }
+}
+exports.ParallelRunningTasks = ParallelRunningTasks;
+class SeriallyRunningTasks {
+    constructor(options, context, tuiEnabled) {
+        this.tuiEnabled = tuiEnabled;
+        this.terminalOutput = '';
+        this.currentProcess = null;
+        this.exitCallbacks = [];
+        this.code = 0;
+        this.run(options, context)
+            .catch((e) => {
+            this.error = e;
+        })
+            .finally(() => {
+            for (const cb of this.exitCallbacks) {
+                cb(this.code, this.terminalOutput);
+            }
+        });
+    }
+    getResults() {
+        return new Promise((res, rej) => {
+            this.onExit((code) => {
+                if (this.error) {
+                    rej(this.error);
+                }
+                else {
+                    res({ code, terminalOutput: this.terminalOutput });
+                }
+            });
+        });
+    }
+    onExit(cb) {
+        this.exitCallbacks.push(cb);
+    }
+    send(message) {
+        throw new Error('Not implemented');
+    }
+    kill(signal) {
+        return this.currentProcess.kill(signal);
+    }
+    async run(options, context) {
+        for (const c of options.commands) {
+            const childProcess = await this.createProcess(c, options.color, calculateCwd(options.cwd, context), options.processEnv ?? options.env ?? {}, options.usePty, options.streamOutput, options.tty, options.envFile);
+            this.currentProcess = childProcess;
+            let { code, terminalOutput } = await childProcess.getResults();
+            this.terminalOutput += terminalOutput;
+            this.code = code;
+            if (code !== 0) {
+                const output = `Warning: command "${c.command}" exited with non-zero status code`;
+                terminalOutput += output;
+                if (options.streamOutput) {
+                    process.stderr.write(output);
+                }
+                this.terminalOutput += terminalOutput;
+                // Stop running commands
+                break;
+            }
+        }
+    }
+    async createProcess(commandConfig, color, cwd, env, usePty = true, streamOutput = true, tty, envFile) {
+        // 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
+        if (process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
+            !commandConfig.prefix &&
+            usePty &&
+            pseudo_terminal_1.PseudoTerminal.isSupported()) {
+            const pseudoTerminal = (0, pseudo_terminal_1.createPseudoTerminal)();
+            registerProcessListener(this, pseudoTerminal);
+            return createProcessWithPseudoTty(pseudoTerminal, commandConfig, color, cwd, env, streamOutput, tty, envFile);
+        }
+        return new RunningNodeProcess(commandConfig, color, cwd, env, [], streamOutput, envFile);
+    }
+}
+exports.SeriallyRunningTasks = SeriallyRunningTasks;
+class RunningNodeProcess {
+    constructor(commandConfig, color, cwd, env, readyWhenStatus, streamOutput = true, envFile) {
+        this.readyWhenStatus = readyWhenStatus;
+        this.terminalOutput = '';
+        this.exitCallbacks = [];
+        env = processEnv(color, cwd, env, envFile);
+        this.command = commandConfig.command;
+        this.terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
+        if (streamOutput) {
+            process.stdout.write(this.terminalOutput);
+        }
+        this.childProcess = (0, child_process_1.exec)(commandConfig.command, {
+            maxBuffer: run_commands_impl_1.LARGE_BUFFER,
+            env,
+            cwd,
+            windowsHide: false,
+        });
+        this.addListeners(commandConfig, streamOutput);
+    }
+    getResults() {
+        return new Promise((res) => {
+            this.onExit((code, terminalOutput) => {
+                res({ code, terminalOutput });
+            });
+        });
+    }
+    onExit(cb) {
+        this.exitCallbacks.push(cb);
+    }
+    send(message) {
+        this.childProcess.send(message);
+    }
+    kill(signal) {
+        return new Promise((res, rej) => {
+            treeKill(this.childProcess.pid, signal, (err) => {
+                if (err) {
+                    rej(err);
+                }
+                else {
+                    res();
+                }
+            });
+        });
+    }
+    addListeners(commandConfig, streamOutput) {
+        this.childProcess.stdout.on('data', (data) => {
+            const output = addColorAndPrefix(data, commandConfig);
+            this.terminalOutput += output;
+            if (streamOutput) {
+                process.stdout.write(output);
+            }
+            if (this.readyWhenStatus.length &&
+                isReady(this.readyWhenStatus, data.toString())) {
+                for (const cb of this.exitCallbacks) {
+                    cb(0, this.terminalOutput);
+                }
+            }
+        });
+        this.childProcess.stderr.on('data', (err) => {
+            const output = addColorAndPrefix(err, commandConfig);
+            this.terminalOutput += output;
+            if (streamOutput) {
+                process.stderr.write(output);
+            }
+            if (this.readyWhenStatus.length &&
+                isReady(this.readyWhenStatus, err.toString())) {
+                for (const cb of this.exitCallbacks) {
+                    cb(1, this.terminalOutput);
+                }
+            }
+        });
+        this.childProcess.on('error', (err) => {
+            const output = addColorAndPrefix(err.toString(), commandConfig);
+            this.terminalOutput += output;
+            if (streamOutput) {
+                process.stderr.write(output);
+            }
+            for (const cb of this.exitCallbacks) {
+                cb(1, this.terminalOutput);
+            }
+        });
+        this.childProcess.on('exit', (code) => {
+            if (!this.readyWhenStatus.length || isReady(this.readyWhenStatus)) {
+                for (const cb of this.exitCallbacks) {
+                    cb(code, this.terminalOutput);
+                }
+            }
+        });
+    }
+}
+async function runSingleCommandWithPseudoTerminal(normalized, context) {
+    const pseudoTerminal = (0, pseudo_terminal_1.createPseudoTerminal)();
+    const pseudoTtyProcess = await createProcessWithPseudoTty(pseudoTerminal, normalized.commands[0], normalized.color, calculateCwd(normalized.cwd, context), normalized.env, normalized.streamOutput, pseudoTerminal ? normalized.isTTY : false, normalized.envFile);
+    registerProcessListener(pseudoTtyProcess, pseudoTerminal);
+    return pseudoTtyProcess;
+}
+async function createProcessWithPseudoTty(pseudoTerminal, commandConfig, color, cwd, env, streamOutput = true, tty, envFile) {
+    return pseudoTerminal.runCommand(commandConfig.command, {
+        cwd,
+        jsEnv: processEnv(color, cwd, env, envFile),
+        quiet: !streamOutput,
+        tty,
+    });
+}
+function addColorAndPrefix(out, config) {
+    if (config.prefix) {
+        out = out
+            .split('\n')
+            .map((l) => {
+            let prefixText = config.prefix;
+            if (config.prefixColor && chalk[config.prefixColor]) {
+                prefixText = chalk[config.prefixColor](prefixText);
+            }
+            prefixText = chalk.bold(prefixText);
+            return l.trim().length > 0 ? `${prefixText} ${l}` : l;
+        })
+            .join('\n');
+    }
+    if (config.color && chalk[config.color]) {
+        out = chalk[config.color](out);
+    }
+    if (config.bgColor && chalk[config.bgColor]) {
+        out = chalk[config.bgColor](out);
+    }
+    return out;
+}
+function calculateCwd(cwd, context) {
+    if (!cwd)
+        return context.root;
+    if ((0, path_1.isAbsolute)(cwd))
+        return cwd;
+    return (0, path_1.join)(context.root, cwd);
+}
+/**
+ * Env variables are processed in the following order:
+ * - env option from executor options
+ * - env file from envFile option if provided
+ * - local env variables
+ */
+function processEnv(color, cwd, envOptionFromExecutor, envFile) {
+    let localEnv = (0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd() });
+    localEnv = {
+        ...process.env,
+        ...localEnv,
+    };
+    if (process.env.NX_LOAD_DOT_ENV_FILES !== 'false' && envFile) {
+        loadEnvVarsFile(envFile, localEnv);
+    }
+    let res = {
+        ...localEnv,
+        ...envOptionFromExecutor,
+    };
+    // need to override PATH to make sure we are using the local node_modules
+    if (localEnv.PATH)
+        res.PATH = localEnv.PATH; // UNIX-like
+    if (localEnv.Path)
+        res.Path = localEnv.Path; // Windows
+    if (color) {
+        res.FORCE_COLOR = `${color}`;
+    }
+    return res;
+}
+function isReady(readyWhenStatus = [], data) {
+    if (data) {
+        for (const readyWhenElement of readyWhenStatus) {
+            if (data.toString().indexOf(readyWhenElement.stringToMatch) > -1) {
+                readyWhenElement.found = true;
+                break;
+            }
+        }
+    }
+    return readyWhenStatus.every((readyWhenElement) => readyWhenElement.found);
+}
+function loadEnvVarsFile(path, env = {}) {
+    (0, task_env_1.unloadDotEnvFile)(path, env);
+    const result = (0, task_env_1.loadAndExpandDotEnvFile)(path, env);
+    if (result.error) {
+        throw result.error;
+    }
+}
+let registered = false;
+function registerProcessListener(runningTask, pseudoTerminal) {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    // 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 (pseudoTerminal) {
+            pseudoTerminal.sendMessageToChildren(message);
+        }
+        if ('send' in runningTask) {
+            runningTask.send(message);
+        }
+    });
+    // Terminate any task processes on exit
+    process.on('exit', () => {
+        runningTask.kill();
+    });
+    process.on('SIGINT', () => {
+        runningTask.kill('SIGTERM');
+        // we exit here because we don't need to write anything to cache.
+        process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
+    });
+    process.on('SIGTERM', () => {
+        runningTask.kill('SIGTERM');
+        // no exit here because we expect child processes to terminate which
+        // will store results to the cache and will terminate this process
+    });
+    process.on('SIGHUP', () => {
+        runningTask.kill('SIGTERM');
+        // no exit here because we expect child processes to terminate which
+        // will store results to the cache and will terminate this process
+    });
+}

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
-const path = require("path");
-const package_manager_1 = require("../../utils/package-manager");
 const child_process_1 = require("child_process");
+const path = require("path");
 const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
+const package_manager_1 = require("../../utils/package-manager");
 async function default_1(options, context) {
     const pm = (0, package_manager_1.getPackageManagerCommand)();
     try {
@@ -39,7 +39,8 @@ function nodeProcess(command, cwd, env) {
     });
 }
 async function ptyProcess(command, cwd, env) {
-    const terminal = (0, pseudo_terminal_1.getPseudoTerminal)();
+    const terminal = (0, pseudo_terminal_1.createPseudoTerminal)();
+    await terminal.init();
     return new Promise((res, rej) => {
         const cp = terminal.runCommand(command, { cwd, jsEnv: env });
         cp.onExit((code) => {

package/src/generators/internal-utils/format-changed-files-with-prettier-if-available.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatChangedFilesWithPrettierIfAvailable = formatChangedFilesWithPrettierIfAvailable;
 exports.formatFilesWithPrettierIfAvailable = formatFilesWithPrettierIfAvailable;
 const path = require("path");
+const is_using_prettier_1 = require("../../utils/is-using-prettier");
 /**
  * Formats all the created or updated files using Prettier
  * @param tree - the file system tree
@@ -19,6 +20,13 @@ async function formatFilesWithPrettierIfAvailable(files, root, options) {
     let prettier;
     try {
         prettier = await Promise.resolve().then(() => require('prettier'));
+        /**
+         * Even after we discovered prettier in node_modules, we need to be sure that the user is intentionally using prettier
+         * before proceeding to format with it.
+         */
+        if (!(0, is_using_prettier_1.isUsingPrettier)(root)) {
+            return results;
+        }
     }
     catch { }
     if (!prettier) {

package/src/generators/testing-utils/create-tree.js

@@ -6,5 +6,9 @@ const tree_1 = require("../tree");
  * Creates a host for testing.
  */
 function createTree() {
-    return new tree_1.FsTree('/virtual', false);
+    const tree = new tree_1.FsTree('/virtual', false);
+    // Allow prettier formatting to be applied to the tree for backwards compatibility within v20
+    // TODO: Decouple formatFiles and other formatting utilities from prettier to avoid this
+    tree.write('.prettierrc', '{}');
+    return tree;
 }

package/src/native/index.d.ts

@@ -7,10 +7,27 @@ export declare class ExternalObject<T> {
     [K: symbol]: T
   }
 }
+export declare class AppLifeCycle {
+  constructor(tasks: Array<Task>, pinnedTasks: Array<string>, tuiCliArgs: TuiCliArgs, tuiConfig: TuiConfig, titleText: string)
+  startCommand(threadCount?: number | undefined | null): void
+  scheduleTask(task: Task): void
+  startTasks(tasks: Array<Task>, metadata: object): void
+  printTaskTerminalOutput(task: Task, status: string, output: string): void
+  endTasks(taskResults: Array<TaskResult>, metadata: object): void
+  endCommand(): void
+  __init(doneCallback: () => any): void
+  registerRunningTask(taskId: string, parserAndWriter: ExternalObject<[ParserArc, WriterArc]>): void
+  setTaskStatus(taskId: string, status: TaskStatus): void
+  registerForcedShutdownCallback(forcedShutdownCallback: () => any): void
+  __setCloudMessage(message: string): Promise<void>
+}
+
 export declare class ChildProcess {
+  getParserAndWriter(): ExternalObject<[ParserArc, WriterArc]>
   kill(): void
   onExit(callback: (message: string) => void): void
   onOutput(callback: (message: string) => void): void
+  cleanup(): void
 }
 
 export declare class FileLock {
@@ -25,7 +42,13 @@ export declare class FileLock {
 export declare class HashPlanner {
   constructor(nxJson: NxJson, projectGraph: ExternalObject<ProjectGraph>)
   getPlans(taskIds: Array<string>, taskGraph: TaskGraph): Record<string, string[]>
-  getPlansReference(taskIds: Array<string>, taskGraph: TaskGraph): JsExternal
+  getPlansReference(taskIds: Array<string>, taskGraph: TaskGraph): ExternalObject<Record<string, Array<HashInstruction>>>
+}
+
+export declare class HttpRemoteCache {
+  constructor()
+  retrieve(hash: string, cacheDirectory: string): Promise<CachedResult | null>
+  store(hash: string, cacheDirectory: string, terminalOutput: string, code: number): Promise<boolean>
 }
 
 export declare class ImportResult {
@@ -37,12 +60,13 @@ export declare class ImportResult {
 
 export declare class NxCache {
   cacheDirectory: string
-  constructor(workspaceRoot: string, cachePath: string, dbConnection: ExternalObject<NxDbConnection>, linkTaskDetails?: boolean | undefined | null)
+  constructor(workspaceRoot: string, cachePath: string, dbConnection: ExternalObject<NxDbConnection>, linkTaskDetails?: boolean | undefined | null, maxCacheSize?: number | undefined | null)
   get(hash: string): CachedResult | null
   put(hash: string, terminalOutput: string, outputs: Array<string>, code: number): void
-  applyRemoteCacheResults(hash: string, result: CachedResult): void
+  applyRemoteCacheResults(hash: string, result: CachedResult, outputs?: Array<string> | undefined | null): void
   getTaskOutputsPath(hash: string): string
-  copyFilesFromCache(cachedResult: CachedResult, outputs: Array<string>): void
+  getCacheSize(): number
+  copyFilesFromCache(cachedResult: CachedResult, outputs: Array<string>): number
   removeOldCacheRecords(): void
   checkCacheFsInSync(): boolean
 }
@@ -54,6 +78,13 @@ export declare class NxTaskHistory {
   getEstimatedTaskTimings(targets: Array<TaskTarget>): Record<string, number>
 }
 
+export declare class RunningTasksService {
+  constructor(db: ExternalObject<NxDbConnection>)
+  getRunningTasks(ids: Array<string>): Array<string>
+  addRunningTask(taskId: string): void
+  removeRunningTask(taskId: string): void
+}
+
 export declare class RustPseudoTerminal {
   constructor()
   runCommand(command: string, commandDir?: string | undefined | null, jsEnv?: Record<string, string> | undefined | null, execArgv?: Array<string> | undefined | null, quiet?: boolean | undefined | null, tty?: boolean | undefined | null): ChildProcess
@@ -93,6 +124,14 @@ export declare class WorkspaceContext {
   constructor(workspaceRoot: string, cacheDir: string)
   getWorkspaceFiles(projectRootMap: Record<string, string>): NxWorkspaceFiles
   glob(globs: Array<string>, exclude?: Array<string> | undefined | null): Array<string>
+  /**
+   * Performs multiple glob pattern matches against workspace files in parallel
+   * @returns An array of arrays, where each inner array contains the file paths
+   * that matched the corresponding glob pattern in the input. The outer array maintains the same order
+   * as the input globs.
+   */
+  multiGlob(globs: Array<string>, exclude?: Array<string> | undefined | null): Array<Array<string>>
+  hashFilesMatchingGlobs(globGroups: Array<Array<string>>): Array<string>
   hashFilesMatchingGlob(globs: Array<string>, exclude?: Array<string> | undefined | null): string
   incrementalUpdate(updatedFiles: Array<string>, deletedFiles: Array<string>): Record<string, string>
   updateProjectFiles(projectRootMappings: ProjectRootMappings, projectFiles: ExternalObject<ProjectFiles>, globalFiles: ExternalObject<Array<FileData>>, updatedFiles: Record<string, string>, deletedFiles: Array<string>): UpdatedWorkspaceFiles
@@ -102,15 +141,16 @@ export declare class WorkspaceContext {
 
 export interface CachedResult {
   code: number
-  terminalOutput: string
+  terminalOutput?: string
   outputsPath: string
+  size?: number
 }
 
-export declare export function closeDbConnection(connection: ExternalObject<NxDbConnection>): void
+export declare export declare function closeDbConnection(connection: ExternalObject<NxDbConnection>): void
 
-export declare export function connectToNxDb(cacheDir: string, nxVersion: string, dbName?: string | undefined | null): ExternalObject<NxDbConnection>
+export declare export declare function connectToNxDb(cacheDir: string, nxVersion: string, dbName?: string | undefined | null): ExternalObject<NxDbConnection>
 
-export declare export function copy(src: string, dest: string): void
+export declare export declare function copy(src: string, dest: string): number
 
 export interface DepsOutputsInput {
   dependentTasksOutputFiles: string
@@ -127,7 +167,7 @@ export declare const enum EventType {
   create = 'create'
 }
 
-export declare export function expandOutputs(directory: string, entries: Array<string>): Array<string>
+export declare export declare function expandOutputs(directory: string, entries: Array<string>): Array<string>
 
 export interface ExternalDependenciesInput {
   externalDependencies: Array<string>
@@ -153,19 +193,21 @@ export interface FileSetInput {
   fileset: string
 }
 
-export declare export function findImports(projectFileMap: Record<string, Array<string>>): Array<ImportResult>
+export declare export declare function findImports(projectFileMap: Record<string, Array<string>>): Array<ImportResult>
+
+export declare export declare function getBinaryTarget(): string
 
-export declare export function getBinaryTarget(): string
+export declare export declare function getDefaultMaxCacheSize(cachePath: string): number
 
 /**
  * Expands the given outputs into a list of existing files.
  * This is used when hashing outputs
  */
-export declare export function getFilesForOutputs(directory: string, entries: Array<string>): Array<string>
+export declare export declare function getFilesForOutputs(directory: string, entries: Array<string>): Array<string>
 
-export declare export function getTransformableOutputs(outputs: Array<string>): Array<string>
+export declare export declare function getTransformableOutputs(outputs: Array<string>): Array<string>
 
-export declare export function hashArray(input: Array<string>): string
+export declare export declare function hashArray(input: Array<string | undefined | null>): string
 
 export interface HashDetails {
   value: string
@@ -183,7 +225,7 @@ export interface HasherOptions {
   selectivelyHashTsConfig: boolean
 }
 
-export declare export function hashFile(file: string): string | null
+export declare export declare function hashFile(file: string): string | null
 
 export interface InputsInput {
   input: string
@@ -223,7 +265,9 @@ export interface ProjectGraph {
   externalNodes: Record<string, ExternalNode>
 }
 
-export declare export function remove(src: string): void
+export declare export declare function remove(src: string): void
+
+export declare export declare function restoreTerminal(): void
 
 export interface RuntimeInput {
   runtime: string
@@ -243,6 +287,9 @@ export interface Task {
   target: TaskTarget
   outputs: Array<string>
   projectRoot?: string
+  startTime?: number
+  endTime?: number
+  continuous?: boolean
 }
 
 export interface TaskGraph {
@@ -251,6 +298,13 @@ export interface TaskGraph {
   dependencies: Record<string, Array<string>>
 }
 
+export interface TaskResult {
+  task: Task
+  status: string
+  code: number
+  terminalOutput?: string
+}
+
 export interface TaskRun {
   hash: string
   status: string
@@ -259,26 +313,47 @@ export interface TaskRun {
   end: number
 }
 
+export declare const enum TaskStatus {
+  Success = 0,
+  Failure = 1,
+  Skipped = 2,
+  LocalCacheKeptExisting = 3,
+  LocalCache = 4,
+  RemoteCache = 5,
+  NotStarted = 6,
+  InProgress = 7,
+  Shared = 8
+}
+
 export interface TaskTarget {
   project: string
   target: string
   configuration?: string
 }
 
-export declare export function testOnlyTransferFileMap(projectFiles: Record<string, Array<FileData>>, nonProjectFiles: Array<FileData>): NxWorkspaceFilesExternals
+export declare export declare function testOnlyTransferFileMap(projectFiles: Record<string, Array<FileData>>, nonProjectFiles: Array<FileData>): NxWorkspaceFilesExternals
 
 /**
  * Transfer the project graph from the JS world to the Rust world, so that we can pass the project graph via memory quicker
  * This wont be needed once the project graph is created in Rust
  */
-export declare export function transferProjectGraph(projectGraph: ProjectGraph): ExternalObject<ProjectGraph>
+export declare export declare function transferProjectGraph(projectGraph: ProjectGraph): ExternalObject<ProjectGraph>
+
+export interface TuiCliArgs {
+  targets?: string[] | undefined
+  tuiAutoExit?: boolean | number | undefined
+}
+
+export interface TuiConfig {
+  autoExit?: boolean | number | undefined
+}
 
 export interface UpdatedWorkspaceFiles {
   fileMap: FileMap
   externalReferences: NxWorkspaceFilesExternals
 }
 
-export declare export function validateOutputs(outputs: Array<string>): void
+export declare export declare function validateOutputs(outputs: Array<string>): void
 
 export interface WatchEvent {
   path: string