nx 21.0.0-beta.1 → 21.0.0-beta.2

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

@@ -3,25 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommand = runCommand;
 exports.runCommandForTasks = runCommandForTasks;
 exports.invokeTasksRunner = invokeTasksRunner;
+exports.constructLifeCycles = constructLifeCycles;
 exports.getRunner = getRunner;
 exports.getRunnerOptions = getRunnerOptions;
 const enquirer_1 = require("enquirer");
+const node_path_1 = require("node:path");
+const node_util_1 = require("node:util");
 const ora = require("ora");
-const path_1 = require("path");
 const nx_json_1 = require("../config/nx-json");
 const client_1 = require("../daemon/client/client");
 const create_task_hasher_1 = require("../hasher/create-task-hasher");
 const hash_task_1 = require("../hasher/hash-task");
 const native_1 = require("../native");
+const tasks_execution_hooks_1 = require("../project-graph/plugins/tasks-execution-hooks");
 const project_graph_1 = require("../project-graph/project-graph");
 const fileutils_1 = require("../utils/fileutils");
+const handle_errors_1 = require("../utils/handle-errors");
 const is_ci_1 = require("../utils/is-ci");
 const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
+const nx_key_1 = require("../utils/nx-key");
 const output_1 = require("../utils/output");
-const handle_errors_1 = require("../utils/handle-errors");
 const sync_generators_1 = require("../utils/sync-generators");
 const workspace_root_1 = require("../utils/workspace-root");
 const create_task_graph_1 = require("./create-task-graph");
+const is_tui_enabled_1 = require("./is-tui-enabled");
 const life_cycle_1 = require("./life-cycle");
 const dynamic_run_many_terminal_output_life_cycle_1 = require("./life-cycles/dynamic-run-many-terminal-output-life-cycle");
 const dynamic_run_one_terminal_output_life_cycle_1 = require("./life-cycles/dynamic-run-one-terminal-output-life-cycle");
@@ -31,19 +36,172 @@ const store_run_information_life_cycle_1 = require("./life-cycles/store-run-info
 const task_history_life_cycle_1 = require("./life-cycles/task-history-life-cycle");
 const task_history_life_cycle_old_1 = require("./life-cycles/task-history-life-cycle-old");
 const task_profiling_life_cycle_1 = require("./life-cycles/task-profiling-life-cycle");
-const task_timings_life_cycle_1 = require("./life-cycles/task-timings-life-cycle");
 const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
+const task_timings_life_cycle_1 = require("./life-cycles/task-timings-life-cycle");
+const tui_summary_life_cycle_1 = require("./life-cycles/tui-summary-life-cycle");
 const task_graph_utils_1 = require("./task-graph-utils");
 const utils_1 = require("./utils");
 const chalk = require("chalk");
-const powerpack_1 = require("../utils/powerpack");
-const tasks_execution_hooks_1 = require("../project-graph/plugins/tasks-execution-hooks");
-async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides) {
+const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+const originalStderrWrite = process.stderr.write.bind(process.stderr);
+const originalConsoleLog = console.log.bind(console);
+const originalConsoleError = console.error.bind(console);
+async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides) {
+    const overridesWithoutHidden = { ...overrides };
+    delete overridesWithoutHidden['__overrides_unparsed__'];
+    if ((0, is_tui_enabled_1.isTuiEnabled)(nxJson)) {
+        const interceptedNxCloudLogs = [];
+        const createPatchedConsoleMethod = (originalMethod) => {
+            return (...args) => {
+                // Check if the log came from the Nx Cloud client, otherwise invoke the original write method
+                const stackTrace = new Error().stack;
+                const isNxCloudLog = stackTrace.includes((0, node_path_1.join)(workspace_root_1.workspaceRoot, '.nx', 'cache', 'cloud'));
+                if (!isNxCloudLog) {
+                    return originalMethod(...args);
+                }
+                // No-op the Nx Cloud client logs
+            };
+        };
+        // The cloud client calls console.log when NX_VERBOSE_LOGGING is set to true
+        console.log = createPatchedConsoleMethod(originalConsoleLog);
+        console.error = createPatchedConsoleMethod(originalConsoleError);
+        const patchedWrite = (_chunk, _encoding, callback) => {
+            // Preserve original behavior around callback and return value, just in case
+            if (callback) {
+                callback();
+            }
+            return true;
+        };
+        process.stdout.write = patchedWrite;
+        process.stderr.write = patchedWrite;
+        const { AppLifeCycle, restoreTerminal } = await Promise.resolve().then(() => require('../native'));
+        let appLifeCycle;
+        const isRunOne = initiatingProject != null;
+        const pinnedTasks = [];
+        const taskText = tasks.length === 1 ? 'task' : 'tasks';
+        const projectText = projectNames.length === 1 ? 'project' : 'projects';
+        let titleText = '';
+        if (isRunOne) {
+            const mainTaskId = (0, create_task_graph_1.createTaskId)(initiatingProject, nxArgs.targets[0], nxArgs.configuration);
+            pinnedTasks.push(mainTaskId);
+            const mainContinuousDependencies = taskGraph.continuousDependencies[mainTaskId];
+            if (mainContinuousDependencies.length > 0) {
+                pinnedTasks.push(mainContinuousDependencies[0]);
+            }
+            const [project, target] = mainTaskId.split(':');
+            titleText = `${target} ${project}`;
+            if (tasks.length > 1) {
+                titleText += `, and ${tasks.length - 1} requisite ${taskText}`;
+            }
+        }
+        else {
+            titleText =
+                nxArgs.targets.join(', ') +
+                    ` for ${projectNames.length} ${projectText}`;
+            if (tasks.length > projectNames.length) {
+                titleText += `, and ${tasks.length - projectNames.length} requisite ${taskText}`;
+            }
+        }
+        let resolveRenderIsDonePromise;
+        // Default renderIsDone that will be overridden if the TUI is used
+        let renderIsDone = new Promise((resolve) => (resolveRenderIsDonePromise = resolve));
+        const { lifeCycle: tsLifeCycle, printSummary } = (0, tui_summary_life_cycle_1.getTuiTerminalSummaryLifeCycle)({
+            projectNames,
+            tasks,
+            args: nxArgs,
+            overrides: overridesWithoutHidden,
+            initiatingProject,
+            resolveRenderIsDonePromise,
+        });
+        if (tasks.length === 0) {
+            renderIsDone = renderIsDone.then(() => {
+                // Revert the patched methods
+                process.stdout.write = originalStdoutWrite;
+                process.stderr.write = originalStderrWrite;
+                console.log = originalConsoleLog;
+                console.error = originalConsoleError;
+                printSummary();
+            });
+        }
+        const lifeCycles = [tsLifeCycle];
+        // Only run the TUI if there are tasks to run
+        if (tasks.length > 0) {
+            appLifeCycle = new AppLifeCycle(tasks, pinnedTasks, nxArgs ?? {}, nxJson.tui ?? {}, titleText);
+            lifeCycles.unshift(appLifeCycle);
+            /**
+             * Patch stdout.write and stderr.write methods to pass Nx Cloud client logs to the TUI via the lifecycle
+             */
+            const createPatchedLogWrite = (originalWrite) => {
+                // @ts-ignore
+                return (chunk, encoding, callback) => {
+                    // Check if the log came from the Nx Cloud client, otherwise invoke the original write method
+                    const stackTrace = new Error().stack;
+                    const isNxCloudLog = stackTrace.includes((0, node_path_1.join)(workspace_root_1.workspaceRoot, '.nx', 'cache', 'cloud'));
+                    if (isNxCloudLog) {
+                        interceptedNxCloudLogs.push(chunk);
+                        // Do not bother to store logs with only whitespace characters, they aren't relevant for the TUI
+                        const trimmedChunk = chunk.toString().trim();
+                        if (trimmedChunk.length) {
+                            // Remove ANSI escape codes, the TUI will control the formatting
+                            appLifeCycle?.__setCloudMessage((0, node_util_1.stripVTControlCharacters)(trimmedChunk));
+                        }
+                    }
+                    // Preserve original behavior around callback and return value, just in case
+                    if (callback) {
+                        callback();
+                    }
+                    return true;
+                };
+            };
+            const createPatchedConsoleMethod = (originalMethod) => {
+                return (...args) => {
+                    // Check if the log came from the Nx Cloud client, otherwise invoke the original write method
+                    const stackTrace = new Error().stack;
+                    const isNxCloudLog = stackTrace.includes((0, node_path_1.join)(workspace_root_1.workspaceRoot, '.nx', 'cache', 'cloud'));
+                    if (!isNxCloudLog) {
+                        return originalMethod(...args);
+                    }
+                    // No-op the Nx Cloud client logs
+                };
+            };
+            process.stdout.write = createPatchedLogWrite(originalStdoutWrite);
+            process.stderr.write = createPatchedLogWrite(originalStderrWrite);
+            // 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(() => {
+                restoreTerminal();
+            })
+                .finally(() => {
+                // Revert the patched methods
+                process.stdout.write = originalStdoutWrite;
+                process.stderr.write = originalStderrWrite;
+                console.log = originalConsoleLog;
+                console.error = originalConsoleError;
+                printSummary();
+                // Print the intercepted Nx Cloud logs
+                for (const log of interceptedNxCloudLogs) {
+                    const logString = log.toString().trimStart();
+                    process.stdout.write(logString);
+                    if (logString) {
+                        process.stdout.write('\n');
+                    }
+                }
+            });
+        }
+        return {
+            lifeCycle: new life_cycle_1.CompositeLifeCycle(lifeCycles),
+            renderIsDone,
+        };
+    }
     const { runnerOptions } = getRunner(nxArgs, nxJson);
     const isRunOne = initiatingProject != null;
     const useDynamicOutput = shouldUseDynamicLifeCycle(tasks, runnerOptions, nxArgs.outputStyle);
-    const overridesWithoutHidden = { ...overrides };
-    delete overridesWithoutHidden['__overrides_unparsed__'];
     if (isRunOne) {
         if (useDynamicOutput) {
             return await (0, dynamic_run_one_terminal_output_life_cycle_1.createRunOneDynamicOutputRenderer)({
@@ -129,7 +287,7 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
     const projectNames = projectsToRun.map((t) => t.name);
     const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
     const tasks = Object.values(taskGraph.tasks);
-    const { lifeCycle, renderIsDone } = await getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides);
+    const { lifeCycle, renderIsDone } = await getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides);
     const taskResults = await invokeTasksRunner({
         tasks,
         projectGraph,
@@ -141,12 +299,12 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
         initiatingProject,
     });
     await renderIsDone;
-    await (0, powerpack_1.printPowerpackLicense)();
+    await (0, nx_key_1.printNxKey)();
     return taskResults;
 }
 async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions) {
     let taskGraph = createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies ?? {}, projectNames, nxArgs, overrides, extraOptions);
-    if (nxArgs.skipSync) {
+    if (nxArgs.skipSync || (0, is_ci_1.isCI)()) {
         return { projectGraph, taskGraph };
     }
     // collect unique syncGenerators from the tasks
@@ -166,9 +324,8 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
     const outOfSyncTitle = 'The workspace is out of sync';
     const resultBodyLines = (0, sync_generators_1.getSyncGeneratorSuccessResultsMessageLines)(results);
     const fixMessage = 'Make sure to run `nx sync` to apply the identified changes or set `sync.applyChanges` to `true` in your `nx.json` to apply them automatically when running tasks in interactive environments.';
-    const willErrorOnCiMessage = 'This will result in an error in CI.';
-    if ((0, is_ci_1.isCI)() || !process.stdout.isTTY) {
-        // If the user is running in CI or is running in a non-TTY environment we
+    if (!process.stdout.isTTY) {
+        // If the user is running a non-TTY environment we
         // throw an error to stop the execution of the tasks.
         if (areAllResultsFailures) {
             output_1.output.error({
@@ -216,7 +373,6 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
                 ...resultBodyLines,
                 '',
                 'Your workspace is set to not apply the identified changes automatically (`sync.applyChanges` is set to `false` in your `nx.json`).',
-                willErrorOnCiMessage,
                 fixMessage,
             ],
         });
@@ -235,10 +391,12 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
         title: outOfSyncTitle,
         bodyLines: [
             ...resultBodyLines,
-            '',
-            nxJson.sync?.applyChanges === true
-                ? 'Proceeding to sync the identified changes automatically (`sync.applyChanges` is set to `true` in your `nx.json`).'
-                : willErrorOnCiMessage,
+            ...(nxJson.sync?.applyChanges === true
+                ? [
+                    '',
+                    'Proceeding to sync the identified changes automatically (`sync.applyChanges` is set to `true` in your `nx.json`).',
+                ]
+                : []),
         ],
     });
     const applyChanges = nxJson.sync?.applyChanges === true ||
@@ -535,10 +693,9 @@ function getRunner(nxArgs, nxJson) {
     try {
         if (isCustomRunnerPath(modulePath)) {
             output_1.output.warn({
-                title: `Custom task runners will no longer be supported in Nx 21.`,
+                title: `Custom task runners will be replaced by a new API starting with Nx 21.`,
                 bodyLines: [
-                    `Use Nx Cloud or the Nx Powerpack caches instead.`,
-                    `For more information, see https://nx.dev/nx-enterprise/powerpack/custom-caching`,
+                    `For more information, see https://nx.dev/deprecated/custom-tasks-runner`,
                 ],
             });
         }
@@ -557,7 +714,7 @@ function getTasksRunnerPath(runner, nxJson) {
     let modulePath = nxJson.tasksRunnerOptions?.[runner]?.runner;
     if (modulePath) {
         if ((0, fileutils_1.isRelativePath)(modulePath)) {
-            return (0, path_1.join)(workspace_root_1.workspaceRoot, modulePath);
+            return (0, node_path_1.join)(workspace_root_1.workspaceRoot, modulePath);
         }
         return modulePath;
     }

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

@@ -1,10 +1,7 @@
 import { Task } from '../config/task-graph';
 export declare function getEnvVariablesForBatchProcess(skipNxCache: boolean, captureStderr: boolean): NodeJS.ProcessEnv;
 export declare function getTaskSpecificEnv(task: Task): NodeJS.ProcessEnv;
-export declare function getEnvVariablesForTask(task: Task, taskSpecificEnv: NodeJS.ProcessEnv, forceColor: string, skipNxCache: boolean, captureStderr: boolean, outputPath: string, streamOutput: boolean): {
-    [x: string]: string;
-    TZ?: string;
-};
+export declare function getEnvVariablesForTask(task: Task, taskSpecificEnv: NodeJS.ProcessEnv, forceColor: string, skipNxCache: boolean, captureStderr: boolean, outputPath: string, streamOutput: boolean): NodeJS.ProcessEnv;
 /**
  * This function loads a .env file and expands the variables in it.
  * @param filename the .env file to load

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

@@ -75,6 +75,8 @@ function getNxEnvVariablesForTask(task, forceColor, skipNxCache, captureStderr,
     return {
         ...getNxEnvVariablesForForkedProcess(forceColor, skipNxCache, captureStderr, outputPath, streamOutput),
         ...env,
+        // Ensure the TUI does not get spawned within the TUI if ever tasks invoke Nx again
+        NX_TUI: 'false',
     };
 }
 /**

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

@@ -1,11 +1,12 @@
-import { TaskHasher } from '../hasher/task-hasher';
-import { DefaultTasksRunnerOptions } from './default-tasks-runner';
-import { TaskStatus } from './tasks-runner';
+import { NxJsonConfiguration } from '../config/nx-json';
 import { ProjectGraph } from '../config/project-graph';
-import { TaskGraph } from '../config/task-graph';
+import { Task, TaskGraph } from '../config/task-graph';
 import { DaemonClient } from '../daemon/client/client';
-import { NxJsonConfiguration } from '../config/nx-json';
+import { TaskHasher } from '../hasher/task-hasher';
 import { NxArgs } from '../utils/command-line-utils';
+import { DefaultTasksRunnerOptions } from './default-tasks-runner';
+import { RunningTask } from './running-tasks/running-task';
+import { TaskStatus } from './tasks-runner';
 export declare class TaskOrchestrator {
     private readonly hasher;
     private readonly initiatingProject;
@@ -16,9 +17,12 @@ export declare class TaskOrchestrator {
     private readonly bail;
     private readonly daemon;
     private readonly outputStyle;
+    private readonly taskGraphForHashing;
     private taskDetails;
     private cache;
+    private readonly tuiEnabled;
     private forkedProcessTaskRunner;
+    private runningTasksService;
     private tasksSchedule;
     private batchEnv;
     private reverseTaskDeps;
@@ -30,24 +34,31 @@ export declare class TaskOrchestrator {
     private bailed;
     private runningContinuousTasks;
     private cleaningUp;
-    constructor(hasher: TaskHasher, initiatingProject: string | undefined, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: NxArgs & DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string);
+    constructor(hasher: TaskHasher, initiatingProject: string | undefined, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: NxArgs & DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string, taskGraphForHashing?: TaskGraph);
+    init(): Promise<void>;
     run(): Promise<{
         [id: string]: TaskStatus;
     }>;
     private executeNextBatchOfTasksUsingTaskSchedule;
-    private processScheduledTask;
+    processTask(taskId: string): Promise<NodeJS.ProcessEnv>;
     private processScheduledBatch;
     private processAllScheduledTasks;
     private applyCachedResults;
     private applyCachedResult;
     private applyFromCacheOrRunBatch;
     private runBatch;
-    private applyFromCacheOrRunTask;
+    applyFromCacheOrRunTask(doNotSkipCache: boolean, task: Task, groupId: number): Promise<{
+        task: Task;
+        code: number;
+        status: TaskStatus;
+        terminalOutput?: string;
+    }>;
     private runTask;
     private runTaskInForkedProcess;
-    private startContinuousTask;
+    startContinuousTask(task: Task, groupId: number): Promise<RunningTask>;
     private preRunSteps;
     private postRunSteps;
+    private scheduleNextTasksAndReleaseThreads;
     private complete;
     private pipeOutputCapture;
     private shouldCacheTaskResult;
@@ -57,3 +68,4 @@ export declare class TaskOrchestrator {
     private recordOutputsHash;
     private cleanup;
 }
+export declare function getThreadCount(options: NxArgs & DefaultTasksRunnerOptions, taskGraph: TaskGraph): number;