nx 21.0.0-canary.20250501-8f50358 → 21.0.0-canary.20250503-675e6ed

package/src/daemon/server/watcher.js

@@ -5,16 +5,10 @@ exports.watchOutputFiles = watchOutputFiles;
 exports.convertChangeEventsToLogMessage = convertChangeEventsToLogMessage;
 const workspace_root_1 = require("../../utils/workspace-root");
 const path_1 = require("path");
-const socket_utils_1 = require("../socket-utils");
 const shutdown_utils_1 = require("./shutdown-utils");
 const path_2 = require("../../utils/path");
-const ignore_1 = require("../../utils/ignore");
 const cache_1 = require("../cache");
 const server_1 = require("./server");
-const ALWAYS_IGNORE = [
-    ...(0, ignore_1.getAlwaysIgnore)(workspace_root_1.workspaceRoot),
-    (0, socket_utils_1.getFullOsSocketPath)(),
-];
 async function watchWorkspace(server, cb) {
     const { Watcher } = await Promise.resolve().then(() => require('../../native'));
     const watcher = new Watcher(workspace_root_1.workspaceRoot);

package/src/executors/run-commands/running-tasks.d.ts

@@ -17,7 +17,7 @@ export declare class ParallelRunningTasks implements RunningTask {
     onOutput(cb: (terminalOutput: string) => void): void;
     onExit(cb: (code: number, terminalOutput: string) => void): void;
     send(message: Serializable): void;
-    kill(signal?: NodeJS.Signals | number): Promise<void>;
+    kill(signal?: NodeJS.Signals): Promise<void>;
     private run;
 }
 export declare class SeriallyRunningTasks implements RunningTask {
@@ -36,7 +36,7 @@ export declare class SeriallyRunningTasks implements RunningTask {
     onExit(cb: (code: number, terminalOutput: string) => void): void;
     onOutput(cb: (terminalOutput: string) => void): void;
     send(message: Serializable): void;
-    kill(signal?: NodeJS.Signals | number): void | Promise<void>;
+    kill(signal?: NodeJS.Signals): void | Promise<void>;
     private run;
     private createProcess;
 }

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

@@ -231,14 +231,24 @@ class RunningNodeProcess {
     }
     kill(signal) {
         return new Promise((res, rej) => {
-            treeKill(this.childProcess.pid, signal, (err) => {
-                if (err) {
-                    rej(err);
+            if (process.platform === 'win32' || process.platform === 'darwin') {
+                if (this.childProcess.kill(signal)) {
+                    res();
                 }
                 else {
-                    res();
+                    rej('Unable to kill process');
                 }
-            });
+            }
+            else {
+                treeKill(this.childProcess.pid, signal, (err) => {
+                    if (err) {
+                        rej(err);
+                    }
+                    else {
+                        res();
+                    }
+                });
+            }
         });
     }
     triggerOutputListeners(output) {

package/src/generators/utils/nx-json.d.ts

@@ -1,9 +1,8 @@
 import type { NxJsonConfiguration } from '../../config/nx-json';
 import type { Tree } from '../tree';
 /**
- * @deprecated You must pass a {@link Tree}. This will be removed in Nx 21.
+ * Reads nx.json
  */
-export declare function readNxJson(): NxJsonConfiguration | null;
 export declare function readNxJson(tree: Tree): NxJsonConfiguration | null;
 /**
  * Update nx.json

package/src/generators/utils/nx-json.js

@@ -4,24 +4,18 @@ exports.readNxJson = readNxJson;
 exports.updateNxJson = updateNxJson;
 const path_1 = require("path");
 const json_1 = require("./json");
-const nx_json_1 = require("../../config/nx-json");
 /**
  * Reads nx.json
  */
 function readNxJson(tree) {
-    if (tree) {
-        if (!tree.exists('nx.json')) {
-            return null;
-        }
-        let nxJson = (0, json_1.readJson)(tree, 'nx.json');
-        if (nxJson.extends) {
-            nxJson = { ...readNxJsonExtends(tree, nxJson.extends), ...nxJson };
-        }
-        return nxJson;
+    if (!tree.exists('nx.json')) {
+        return null;
     }
-    else {
-        return (0, nx_json_1.readNxJson)();
+    let nxJson = (0, json_1.readJson)(tree, 'nx.json');
+    if (nxJson.extends) {
+        nxJson = { ...readNxJsonExtends(tree, nxJson.extends), ...nxJson };
     }
+    return nxJson;
 }
 /**
  * Update nx.json

package/src/native/index.d.ts

@@ -26,7 +26,7 @@ export declare class AppLifeCycle {
 
 export declare class ChildProcess {
   getParserAndWriter(): ExternalObject<[ParserArc, WriterArc]>
-  kill(): void
+  kill(signal?: NodeJS.Signals): void
   onExit(callback: (message: string) => void): void
   onOutput(callback: (message: string) => void): void
   cleanup(): void
@@ -89,12 +89,12 @@ export declare class RunningTasksService {
 
 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
+  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, commandLabel?: string | 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, execArgv: Array<string> | undefined | null, quiet: boolean): ChildProcess
+  fork(id: string, forkScript: string, pseudoIpcPath: string, commandDir: string | undefined | null, jsEnv: Record<string, string> | undefined | null, execArgv: Array<string> | undefined | null, quiet: boolean, commandLabel?: string | undefined | null): ChildProcess
 }
 
 export declare class TaskDetails {

package/src/nx-cloud/update-manager.d.ts

@@ -17,3 +17,4 @@ export declare function verifyOrUpdateNxCloudClient(options: CloudTaskRunnerOpti
     nxCloudClient: NxCloudClient;
     version: string;
 } | null>;
+export declare function getBundleInstallDefaultLocation(): string;

package/src/nx-cloud/update-manager.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NxCloudClientUnavailableError = exports.NxCloudEnterpriseOutdatedError = void 0;
 exports.verifyOrUpdateNxCloudClient = verifyOrUpdateNxCloudClient;
+exports.getBundleInstallDefaultLocation = getBundleInstallDefaultLocation;
 const fs_1 = require("fs");
 const zlib_1 = require("zlib");
 const path_1 = require("path");

package/src/nx-cloud/utilities/client.d.ts

@@ -5,6 +5,6 @@ export declare class UnknownCommandError extends Error {
     constructor(command: string, availableCommands: string[]);
 }
 export declare function getCloudClient(options: CloudTaskRunnerOptions): Promise<{
-    invoke: (command: string) => void;
+    invoke: (command: string, exit?: boolean) => void;
     availableCommands: string[];
 }>;

package/src/nx-cloud/utilities/client.js

@@ -17,13 +17,20 @@ async function getCloudClient(options) {
     const paths = (0, resolution_helpers_1.findAncestorNodeModules)(__dirname, []);
     nxCloudClient.configureLightClientRequire()(paths);
     return {
-        invoke: (command) => {
+        invoke: (command, exit = true) => {
             if (command in nxCloudClient.commands) {
                 nxCloudClient.commands[command]()
-                    .then(() => process.exit(0))
+                    .then(() => {
+                    if (exit) {
+                        process.exit(0);
+                    }
+                })
                     .catch((e) => {
                     console.error(e);
-                    process.exit(1);
+                    if (exit) {
+                        process.exit(1);
+                    }
+                    throw e;
                 });
             }
             else {

package/src/tasks-runner/fork.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const path_1 = require("path");
 const pseudo_ipc_1 = require("./pseudo-ipc");
+const exit_codes_1 = require("../utils/exit-codes");
 const pseudoIPCPath = process.argv[2];
 const forkId = process.argv[3];
 const script = (0, path_1.join)(__dirname, '../../bin/run-executor.js');
@@ -28,3 +29,17 @@ childProcess.on('exit', (code) => {
     pseudoIPC.close();
     process.exit(code);
 });
+// Terminate the child process when exiting
+process.on('exit', () => {
+    childProcess.kill();
+});
+process.on('SIGINT', () => {
+    childProcess.kill('SIGTERM');
+    process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
+});
+process.on('SIGTERM', () => {
+    childProcess.kill('SIGTERM');
+});
+process.on('SIGHUP', () => {
+    childProcess.kill('SIGTERM');
+});

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

@@ -122,6 +122,7 @@ class ForkedProcessTaskRunner {
             execArgv: process.execArgv,
             jsEnv: env,
             quiet: !streamOutput,
+            commandLabel: `nx run ${task.id}`,
         });
         p.send({
             targetDescription: task.target,

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

@@ -18,10 +18,5 @@ export declare function initTasksRunner(nxArgs: NxArgs): Promise<{
         taskResults: Record<string, TaskResult>;
     }>;
 }>;
-export declare function runDiscreteTasks(tasks: Task[], projectGraph: ProjectGraph, taskGraphForHashing: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Promise<{
-    task: Task;
-    code: number;
-    status: import("./tasks-runner").TaskStatus;
-    terminalOutput?: string;
-}>[]>;
+export declare function runDiscreteTasks(tasks: Task[], projectGraph: ProjectGraph, taskGraphForHashing: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Array<Promise<TaskResult[]>>>;
 export declare function runContinuousTasks(tasks: Task[], projectGraph: ProjectGraph, taskGraphForHashing: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Record<string, Promise<RunningTask>>>;

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

@@ -107,12 +107,32 @@ async function createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJs
     (0, run_command_1.setEnvVarsBasedOnArgs)(nxArgs, true);
     const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, [], projectGraph, taskGraph, nxJson, nxArgs, false, client_1.daemonClient, undefined, taskGraphForHashing);
     await orchestrator.init();
-    orchestrator.processTasks(tasks.map((task) => task.id));
+    orchestrator.processAllScheduledTasks();
     return orchestrator;
 }
 async function runDiscreteTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
     const orchestrator = await createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle);
-    return tasks.map((task, index) => orchestrator.applyFromCacheOrRunTask(true, task, index));
+    let groupId = 0;
+    let nextBatch = orchestrator.nextBatch();
+    let batchResults = [];
+    /**
+     * Set of task ids that were part of batches
+     */
+    const batchTasks = new Set();
+    while (nextBatch) {
+        for (const task in nextBatch.taskGraph.tasks) {
+            batchTasks.add(task);
+        }
+        batchResults.push(orchestrator.applyFromCacheOrRunBatch(true, nextBatch, groupId++));
+        nextBatch = orchestrator.nextBatch();
+    }
+    const taskResults = tasks
+        // Filter out tasks which were not part of batches
+        .filter((task) => !batchTasks.has(task.id))
+        .map((task) => orchestrator
+        .applyFromCacheOrRunTask(true, task, groupId++)
+        .then((r) => [r]));
+    return [...batchResults, ...taskResults];
 }
 async function runContinuousTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
     const orchestrator = await createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle);

package/src/tasks-runner/is-tui-enabled.js

@@ -28,14 +28,23 @@ function shouldUseTui(nxJson, nxArgs, skipCapabilityCheck = process.env.NX_TUI_S
     if (!isCapable) {
         return false;
     }
-    // The environment variable takes precedence over the nx.json config
-    if (typeof process.env.NX_TUI === 'string') {
-        return process.env.NX_TUI === 'true';
-    }
     if (['static', 'stream', 'dynamic-legacy'].includes(nxArgs.outputStyle)) {
         // If the user has specified a non-TUI output style, we disable the TUI
         return false;
     }
+    if (nxArgs.outputStyle === 'dynamic' || nxArgs.outputStyle === 'tui') {
+        return true;
+    }
+    // The environment variable takes precedence over the nx.json config, but
+    // are lower priority than the CLI args as they are less likely to change
+    // between runs, whereas the CLI args are specified by the user for each run.
+    if (typeof process.env.NX_TUI === 'string') {
+        return process.env.NX_TUI === 'true';
+    }
+    // BELOW THIS LINE ARE "repo specific" checks, instead of "user specific" checks.
+    // "user specific" checks are specified by the current user rather than the repo
+    // settings which are applied for all users of the repo... so they are more specific
+    // and take priority.
     if (
     // Interactive TUI doesn't make sense on CI
     (0, is_ci_1.isCI)() ||
@@ -46,9 +55,6 @@ function shouldUseTui(nxJson, nxArgs, skipCapabilityCheck = process.env.NX_TUI_S
         native_1.IS_WASM) {
         return false;
     }
-    if (nxArgs.outputStyle === 'dynamic' || nxArgs.outputStyle === 'tui') {
-        return true;
-    }
     // Respect user config
     if (typeof nxJson.tui?.enabled === 'boolean') {
         return Boolean(nxJson.tui?.enabled);

package/src/tasks-runner/life-cycles/tui-summary-life-cycle.js

@@ -108,7 +108,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
             }
             lines = [output_1.output.colors.green(lines.join(node_os_1.EOL))];
         }
-        else if (totalCompletedTasks + stoppedTasks.size === totalTasks) {
+        else if (inProgressTasks.size === 0) {
             let text = `Ran target ${output_1.output.bold(targets[0])} for project ${output_1.output.bold(initiatingProject)}`;
             if (tasks.length > 1) {
                 text += ` and ${output_1.output.bold(tasks.length - 1)} task(s) they depend on`;
@@ -122,22 +122,17 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
                     .forEach((arg) => taskOverridesLines.push(arg));
             }
             const viewLogs = (0, view_logs_utils_1.viewLogsFooterRows)(totalFailedTasks);
-            lines = [
-                output_1.output.colors.red([
-                    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)}${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,
-                ].join(node_os_1.EOL)),
-            ];
+            lines.push(output_1.output.colors.red([
+                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)}${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,
+            ].join(node_os_1.EOL)));
         }
         else {
-            lines = [
-                ...output_1.output.getVerticalSeparatorLines('red'),
-                output_1.output.applyNxPrefix('red', output_1.output.colors.red(`Cancelled running target ${output_1.output.bold(targets[0])} for project ${output_1.output.bold(initiatingProject)}`) + output_1.output.dim(` (${timeTakenText})`)),
-            ];
+            lines.push(output_1.output.applyNxPrefix('red', output_1.output.colors.red(`Cancelled running target ${output_1.output.bold(targets[0])} for project ${output_1.output.bold(initiatingProject)}`) + output_1.output.dim(` (${timeTakenText})`)));
         }
         // adds some vertical space after the summary to avoid bunching against terminal
         lines.push('');
@@ -145,12 +140,13 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
     };
     const printRunManySummary = () => {
         console.log('');
-        const lines = [];
+        const lines = [''];
         const failure = totalSuccessfulTasks + stoppedTasks.size !== totalTasks;
         for (const taskId of taskIdsInOrderOfCompletion) {
             const { terminalOutput, taskStatus } = tasksToTerminalOutputs[taskId];
             if (taskStatus === 'failure') {
                 output_1.output.logCommandOutput(taskId, taskStatus, terminalOutput);
+                output_1.output.addNewline();
                 lines.push(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${output_1.output.colors.gray('nx run ')}${taskId}`);
             }
             else {

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

@@ -12,7 +12,7 @@ export declare class PseudoTerminal {
     static isSupported(): boolean;
     constructor(rustPseudoTerminal: RustPseudoTerminal);
     init(): Promise<void>;
-    shutdown(): void;
+    shutdown(s?: NodeJS.Signals): void;
     runCommand(command: string, { cwd, execArgv, jsEnv, quiet, tty, }?: {
         cwd?: string;
         execArgv?: string[];
@@ -20,11 +20,12 @@ export declare class PseudoTerminal {
         quiet?: boolean;
         tty?: boolean;
     }): PseudoTtyProcess;
-    fork(id: string, script: string, { cwd, execArgv, jsEnv, quiet, }: {
+    fork(id: string, script: string, { cwd, execArgv, jsEnv, quiet, commandLabel, }: {
         cwd?: string;
         execArgv?: string[];
         jsEnv?: Record<string, string>;
         quiet?: boolean;
+        commandLabel?: string;
     }): Promise<PseudoTtyProcessWithSend>;
     sendMessageToChildren(message: Serializable): void;
     onMessageFromChildren(callback: (message: Serializable) => void): void;
@@ -43,7 +44,7 @@ export declare class PseudoTtyProcess implements RunningTask {
     }>;
     onExit(callback: (code: number) => void): void;
     onOutput(callback: (message: string) => void): void;
-    kill(): void;
+    kill(s?: NodeJS.Signals): void;
     getParserAndWriter(): import("../native").ExternalObject<[ParserArc, WriterArc]>;
 }
 export declare class PseudoTtyProcessWithSend extends PseudoTtyProcess {

package/src/tasks-runner/pseudo-terminal.js

@@ -9,13 +9,13 @@ const pseudo_ipc_1 = require("./pseudo-ipc");
 // Register single event listeners for all pseudo-terminal instances
 const pseudoTerminalShutdownCallbacks = [];
 process.on('SIGINT', () => {
-    pseudoTerminalShutdownCallbacks.forEach((cb) => cb());
+    pseudoTerminalShutdownCallbacks.forEach((cb) => cb('SIGINT'));
 });
 process.on('SIGTERM', () => {
-    pseudoTerminalShutdownCallbacks.forEach((cb) => cb());
+    pseudoTerminalShutdownCallbacks.forEach((cb) => cb('SIGTERM'));
 });
 process.on('SIGHUP', () => {
-    pseudoTerminalShutdownCallbacks.forEach((cb) => cb());
+    pseudoTerminalShutdownCallbacks.forEach((cb) => cb('SIGHUP'));
 });
 process.on('exit', () => {
     pseudoTerminalShutdownCallbacks.forEach((cb) => cb());
@@ -47,10 +47,10 @@ class PseudoTerminal {
         await this.pseudoIPC.init();
         this.initialized = true;
     }
-    shutdown() {
+    shutdown(s) {
         for (const cp of this.childProcesses) {
             try {
-                cp.kill();
+                cp.kill(s);
             }
             catch { }
         }
@@ -63,11 +63,11 @@ class PseudoTerminal {
         this.childProcesses.add(cp);
         return cp;
     }
-    async fork(id, script, { cwd, execArgv, jsEnv, quiet, }) {
+    async fork(id, script, { cwd, execArgv, jsEnv, quiet, commandLabel, }) {
         if (!this.initialized) {
             throw new Error('Call init() before forking processes');
         }
-        const cp = new PseudoTtyProcessWithSend(this.rustPseudoTerminal, this.rustPseudoTerminal.fork(id, script, this.pseudoIPCPath, cwd, jsEnv, execArgv, quiet), id, this.pseudoIPC);
+        const cp = new PseudoTtyProcessWithSend(this.rustPseudoTerminal, this.rustPseudoTerminal.fork(id, script, this.pseudoIPCPath, cwd, jsEnv, execArgv, quiet, commandLabel), id, this.pseudoIPC);
         this.childProcesses.add(cp);
         await this.pseudoIPC.waitForChildReady(id);
         return cp;
@@ -112,10 +112,10 @@ class PseudoTtyProcess {
     onOutput(callback) {
         this.outputCallbacks.push(callback);
     }
-    kill() {
+    kill(s) {
         if (this.isAlive) {
             try {
-                this.childProcess.kill();
+                this.childProcess.kill(s);
             }
             catch {
                 // when the child process completes before we explicitly call kill, this will throw

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

@@ -168,20 +168,14 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
             // The cloud client calls console.log when NX_VERBOSE_LOGGING is set to true
             console.log = createPatchedConsoleMethod(originalConsoleLog);
             console.error = createPatchedConsoleMethod(originalConsoleError);
-            renderIsDone = new Promise((resolve) => {
-                appLifeCycle.__init(() => {
-                    resolve();
-                });
-            })
-                .then(() => {
+            globalThis.tuiOnProcessExit = () => {
                 restoreTerminal();
-            })
-                .finally(() => {
                 // Revert the patched methods
                 process.stdout.write = originalStdoutWrite;
                 process.stderr.write = originalStderrWrite;
                 console.log = originalConsoleLog;
                 console.error = originalConsoleError;
+                process.stdout.write('\n');
                 // Print the intercepted Nx Cloud logs
                 for (const log of interceptedNxCloudLogs) {
                     const logString = log.toString().trimStart();
@@ -190,6 +184,18 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
                         process.stdout.write('\n');
                     }
                 }
+            };
+            renderIsDone = new Promise((resolve) => {
+                appLifeCycle.__init(() => {
+                    resolve();
+                });
+            }).finally(() => {
+                restoreTerminal();
+                // Revert the patched methods
+                process.stdout.write = originalStdoutWrite;
+                process.stderr.write = originalStderrWrite;
+                console.log = originalConsoleLog;
+                console.error = originalConsoleError;
             });
         }
         return {
@@ -575,7 +581,7 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
         ...runnerOptions,
         lifeCycle: compositedLifeCycle,
     }, {
-        initiatingProject: nxArgs.outputStyle === 'compact' ? null : initiatingProject,
+        initiatingProject,
         initiatingTasks,
         projectGraph,
         nxJson,

package/src/tasks-runner/running-tasks/batch-process.d.ts

@@ -10,5 +10,5 @@ export declare class BatchProcess {
     onResults(cb: (results: BatchResults) => void): void;
     getResults(): Promise<BatchResults>;
     send(message: Serializable): void;
-    kill(signal?: NodeJS.Signals | number): void;
+    kill(signal?: NodeJS.Signals): void;
 }

package/src/tasks-runner/running-tasks/node-child-process.d.ts

@@ -15,7 +15,7 @@ export declare class NodeChildProcessWithNonDirectOutput implements RunningTask
         terminalOutput: string;
     }>;
     send(message: Serializable): void;
-    kill(signal?: NodeJS.Signals | number): void;
+    kill(signal?: NodeJS.Signals): void;
 }
 export declare class NodeChildProcessWithDirectOutput implements RunningTask {
     private childProcess;
@@ -33,5 +33,5 @@ export declare class NodeChildProcessWithDirectOutput implements RunningTask {
     }>;
     waitForExit(): Promise<void>;
     getTerminalOutput(): string;
-    kill(signal?: NodeJS.Signals | number): void;
+    kill(signal?: NodeJS.Signals): void;
 }

package/src/tasks-runner/running-tasks/running-task.d.ts

@@ -5,7 +5,7 @@ export declare abstract class RunningTask {
         terminalOutput: string;
     }>;
     abstract onExit(cb: (code: number) => void): void;
-    abstract kill(signal?: NodeJS.Signals | number): Promise<void> | void;
+    abstract kill(signal?: NodeJS.Signals): Promise<void> | void;
     abstract onOutput?(cb: (output: string) => void): void;
     abstract send?(message: Serializable): void;
 }

package/src/tasks-runner/task-orchestrator.d.ts

@@ -5,8 +5,10 @@ import { DaemonClient } from '../daemon/client/client';
 import { TaskHasher } from '../hasher/task-hasher';
 import { NxArgs } from '../utils/command-line-utils';
 import { DefaultTasksRunnerOptions } from './default-tasks-runner';
+import { TaskResult } from './life-cycle';
 import { RunningTask } from './running-tasks/running-task';
 import { TaskStatus } from './tasks-runner';
+import { Batch } from './tasks-schedule';
 import { SharedRunningTask } from './running-tasks/shared-running-task';
 export declare class TaskOrchestrator {
     private readonly hasher;
@@ -41,21 +43,17 @@ export declare class TaskOrchestrator {
     run(): Promise<{
         [id: string]: TaskStatus;
     }>;
+    nextBatch(): Batch;
     private executeNextBatchOfTasksUsingTaskSchedule;
-    processTasks(taskIds: string[]): void;
+    private processTasks;
     private processTask;
     private processScheduledBatch;
-    private processAllScheduledTasks;
+    processAllScheduledTasks(): void;
     private applyCachedResults;
     private applyCachedResult;
-    private applyFromCacheOrRunBatch;
+    applyFromCacheOrRunBatch(doNotSkipCache: boolean, batch: Batch, groupId: number): Promise<TaskResult[]>;
     private runBatch;
-    applyFromCacheOrRunTask(doNotSkipCache: boolean, task: Task, groupId: number): Promise<{
-        task: Task;
-        code: number;
-        status: TaskStatus;
-        terminalOutput?: string;
-    }>;
+    applyFromCacheOrRunTask(doNotSkipCache: boolean, task: Task, groupId: number): Promise<TaskResult>;
     private runTask;
     private runTaskInForkedProcess;
     startContinuousTask(task: Task, groupId: number): Promise<RunningTask | SharedRunningTask>;

package/src/tasks-runner/task-orchestrator.js

@@ -60,14 +60,14 @@ class TaskOrchestrator {
         // Init the ForkedProcessTaskRunner, TasksSchedule, and Cache
         await Promise.all([
             this.forkedProcessTaskRunner.init(),
-            this.tasksSchedule.init(),
+            this.tasksSchedule.init().then(() => {
+                return this.tasksSchedule.scheduleNextTasks();
+            }),
             'init' in this.cache ? this.cache.init() : null,
         ]);
     }
     async run() {
         await this.init();
-        // initial scheduling
-        await this.tasksSchedule.scheduleNextTasks();
         perf_hooks_1.performance.mark('task-execution:start');
         const threadCount = getThreadCount(this.options, this.taskGraph);
         const threads = [];
@@ -96,6 +96,9 @@ class TaskOrchestrator {
         await this.cleanup();
         return this.completedTasks;
     }
+    nextBatch() {
+        return this.tasksSchedule.nextBatch();
+    }
     async executeNextBatchOfTasksUsingTaskSchedule() {
         // completed all the tasks
         if (!this.tasksSchedule.hasTasks() || this.bailed) {
@@ -104,7 +107,7 @@ class TaskOrchestrator {
         const doNotSkipCache = this.options.skipNxCache === false ||
             this.options.skipNxCache === undefined;
         this.processAllScheduledTasks();
-        const batch = this.tasksSchedule.nextBatch();
+        const batch = this.nextBatch();
         if (batch) {
             const groupId = this.closeGroup();
             await this.applyFromCacheOrRunBatch(doNotSkipCache, batch, groupId);
@@ -202,7 +205,9 @@ class TaskOrchestrator {
         // Wait for batch to be processed
         await this.processedBatches.get(batch);
         await this.preRunSteps(tasks, { groupId });
-        let results = doNotSkipCache ? await this.applyCachedResults(tasks) : [];
+        let results = doNotSkipCache
+            ? await this.applyCachedResults(tasks)
+            : [];
         // Run tasks that were not cached
         if (results.length !== taskEntries.length) {
             const unrunTaskGraph = (0, utils_1.removeTasksFromTaskGraph)(batch.taskGraph, results.map(({ task }) => task.id));
@@ -225,6 +230,7 @@ class TaskOrchestrator {
         // Batch is done, mark it as completed
         const applyFromCacheOrRunBatchEnd = perf_hooks_1.performance.mark('TaskOrchestrator-apply-from-cache-or-run-batch:end');
         perf_hooks_1.performance.measure('TaskOrchestrator-apply-from-cache-or-run-batch', applyFromCacheOrRunBatchStart.name, applyFromCacheOrRunBatchEnd.name);
+        return results;
     }
     async runBatch(batch, env) {
         const runBatchStart = perf_hooks_1.performance.mark('TaskOrchestrator-run-batch:start');
@@ -234,6 +240,7 @@ class TaskOrchestrator {
             const batchResultEntries = Object.entries(results);
             return batchResultEntries.map(([taskId, result]) => ({
                 ...result,
+                code: result.success ? 0 : 1,
                 task: {
                     ...this.taskGraph.tasks[taskId],
                     startTime: result.startTime,
@@ -246,6 +253,7 @@ class TaskOrchestrator {
         catch (e) {
             return batch.taskGraph.roots.map((rootTaskId) => ({
                 task: this.taskGraph.tasks[rootTaskId],
+                code: 1,
                 status: 'failure',
             }));
         }