nx 21.0.0-canary.20250429-cf4a1f3 → 21.0.0-canary.20250501-8f50358

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

@@ -1,48 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTuiEnabled = isTuiEnabled;
-const devkit_internals_1 = require("../devkit-internals");
+exports.shouldUseTui = shouldUseTui;
+const native_1 = require("../native");
 const is_ci_1 = require("../utils/is-ci");
 let tuiEnabled = undefined;
-function isTuiEnabled(nxJson, skipCapableCheck = false) {
-    if (tuiEnabled !== undefined) {
-        return tuiEnabled;
-    }
+/**
+ * @returns If tui is enabled
+ */
+function isTuiEnabled() {
+    return process.env.NX_TUI === 'true';
+}
+/**
+ * Determines if the TUI should be enabled for the current environment.
+ *
+ * **Note:** This function should almost never be called directly. Instead, use the `isTuiEnabled` function.
+ *
+ * @param nxJson `nx.json`
+ * @param nxArgs CLI Flags passed into Nx
+ * @param skipCapabilityCheck Mainly used for unit tests.
+ * @returns `true` if the TUI should be enabled, `false` otherwise.
+ */
+function shouldUseTui(nxJson, nxArgs, skipCapabilityCheck = process.env.NX_TUI_SKIP_CAPABILITY_CHECK === 'true') {
     // If the current terminal/environment is not capable of displaying the TUI, we don't run it
     const isWindows = process.platform === 'win32';
-    const isCapable = skipCapableCheck || (process.stderr.isTTY && isUnicodeSupported());
+    const isCapable = skipCapabilityCheck || (process.stderr.isTTY && isUnicodeSupported());
     if (!isCapable) {
-        tuiEnabled = false;
-        process.env.NX_TUI = 'false';
-        return tuiEnabled;
+        return false;
     }
     // The environment variable takes precedence over the nx.json config
     if (typeof process.env.NX_TUI === 'string') {
-        tuiEnabled = process.env.NX_TUI === 'true';
-        return tuiEnabled;
+        return process.env.NX_TUI === 'true';
     }
-    // Windows is not working well right now, temporarily disable it on Windows even if it has been specified as enabled
-    // TODO(@JamesHenry): Remove this check once Windows issues are fixed.
-    if ((0, is_ci_1.isCI)() || isWindows) {
-        tuiEnabled = false;
-        process.env.NX_TUI = 'false';
-        return tuiEnabled;
+    if (['static', 'stream', 'dynamic-legacy'].includes(nxArgs.outputStyle)) {
+        // If the user has specified a non-TUI output style, we disable the TUI
+        return false;
     }
-    // Only read from disk if nx.json config is not already provided (and we have not been able to determine tuiEnabled based on the above checks)
-    if (!nxJson) {
-        nxJson = (0, devkit_internals_1.readNxJsonFromDisk)();
+    if (
+    // Interactive TUI doesn't make sense on CI
+    (0, is_ci_1.isCI)() ||
+        // TODO(@JamesHenry): Remove this check once Windows issues are fixed.
+        // Windows is not working well right now, temporarily disable it on Windows even if it has been specified as enabled
+        isWindows ||
+        // WASM needs further testing
+        native_1.IS_WASM) {
+        return false;
+    }
+    if (nxArgs.outputStyle === 'dynamic' || nxArgs.outputStyle === 'tui') {
+        return true;
     }
     // Respect user config
     if (typeof nxJson.tui?.enabled === 'boolean') {
-        tuiEnabled = Boolean(nxJson.tui?.enabled);
-    }
-    else {
-        // Default to enabling the TUI if the system is capable of displaying it
-        tuiEnabled = true;
+        return Boolean(nxJson.tui?.enabled);
     }
-    // Also set the environment variable for consistency and ease of checking on the rust side, for example
-    process.env.NX_TUI = tuiEnabled.toString();
-    return tuiEnabled;
+    // Default to enabling the TUI if the system is capable of displaying it
+    return true;
 }
 // Credit to https://github.com/sindresorhus/is-unicode-supported/blob/e0373335038856c63034c8eef6ac43ee3827a601/index.js
 function isUnicodeSupported() {

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

@@ -20,10 +20,10 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
     let totalSuccessfulTasks = 0;
     let totalFailedTasks = 0;
     let totalCompletedTasks = 0;
-    let totalStoppedTasks = 0;
     let timeTakenText;
     const failedTasks = new Set();
     const inProgressTasks = new Set();
+    const stoppedTasks = new Set();
     const tasksToTerminalOutputs = {};
     const taskIdsInOrderOfCompletion = [];
     lifeCycle.startTasks = (tasks) => {
@@ -37,7 +37,8 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
     };
     lifeCycle.setTaskStatus = (taskId, taskStatus) => {
         if (taskStatus === 9 /* NativeTaskStatus.Stopped */) {
-            totalStoppedTasks++;
+            stoppedTasks.add(taskId);
+            inProgressTasks.delete(taskId);
         }
     };
     lifeCycle.endTasks = (taskResults) => {
@@ -83,7 +84,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
     };
     const printRunOneSummary = () => {
         let lines = [];
-        const failure = totalSuccessfulTasks + totalStoppedTasks !== totalTasks;
+        const failure = totalSuccessfulTasks + stoppedTasks.size !== totalTasks;
         // Prints task outputs in the order they were completed
         // above the summary, since run-one should print all task results.
         for (const taskId of taskIdsInOrderOfCompletion) {
@@ -107,7 +108,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
             }
             lines = [output_1.output.colors.green(lines.join(node_os_1.EOL))];
         }
-        else if (totalCompletedTasks + totalStoppedTasks === totalTasks) {
+        else if (totalCompletedTasks + stoppedTasks.size === totalTasks) {
             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`;
@@ -129,7 +130,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
                     `${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 {
@@ -145,7 +146,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
     const printRunManySummary = () => {
         console.log('');
         const lines = [];
-        const failure = totalSuccessfulTasks + totalStoppedTasks !== totalTasks;
+        const failure = totalSuccessfulTasks + stoppedTasks.size !== totalTasks;
         for (const taskId of taskIdsInOrderOfCompletion) {
             const { terminalOutput, taskStatus } = tasksToTerminalOutputs[taskId];
             if (taskStatus === 'failure') {
@@ -157,7 +158,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
             }
         }
         lines.push(...output_1.output.getVerticalSeparatorLines(failure ? 'red' : 'green'));
-        if (totalSuccessfulTasks + totalStoppedTasks === totalTasks) {
+        if (totalSuccessfulTasks + stoppedTasks.size === totalTasks) {
             const successSummaryRows = [];
             const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
             const taskOverridesRows = [];

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

@@ -8,6 +8,7 @@ export declare class PseudoTerminal {
     private pseudoIPCPath;
     private pseudoIPC;
     private initialized;
+    private childProcesses;
     static isSupported(): boolean;
     constructor(rustPseudoTerminal: RustPseudoTerminal);
     init(): Promise<void>;

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

@@ -38,6 +38,7 @@ class PseudoTerminal {
         this.pseudoIPCPath = (0, socket_utils_1.getForkedProcessOsSocketPath)(process.pid.toString() + '-' + id++);
         this.pseudoIPC = new pseudo_ipc_1.PseudoIPCServer(this.pseudoIPCPath);
         this.initialized = false;
+        this.childProcesses = new Set();
     }
     async init() {
         if (this.initialized) {
@@ -47,18 +48,27 @@ class PseudoTerminal {
         this.initialized = true;
     }
     shutdown() {
+        for (const cp of this.childProcesses) {
+            try {
+                cp.kill();
+            }
+            catch { }
+        }
         if (this.initialized) {
             this.pseudoIPC.close();
         }
     }
     runCommand(command, { cwd, execArgv, jsEnv, quiet, tty, } = {}) {
-        return new PseudoTtyProcess(this.rustPseudoTerminal, this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, execArgv, quiet, tty));
+        const cp = new PseudoTtyProcess(this.rustPseudoTerminal, this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, execArgv, quiet, tty));
+        this.childProcesses.add(cp);
+        return cp;
     }
     async fork(id, script, { cwd, execArgv, jsEnv, quiet, }) {
         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);
+        this.childProcesses.add(cp);
         await this.pseudoIPC.waitForChildReady(id);
         return cp;
     }

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

@@ -17,7 +17,6 @@ const create_task_hasher_1 = require("../hasher/create-task-hasher");
 const hash_task_1 = require("../hasher/hash-task");
 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");
@@ -48,7 +47,8 @@ const originalConsoleError = console.error.bind(console);
 async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides) {
     const overridesWithoutHidden = { ...overrides };
     delete overridesWithoutHidden['__overrides_unparsed__'];
-    if ((0, is_tui_enabled_1.isTuiEnabled)(nxJson)) {
+    const isRunOne = initiatingProject != null;
+    if ((0, is_tui_enabled_1.isTuiEnabled)()) {
         const interceptedNxCloudLogs = [];
         const createPatchedConsoleMethod = (originalMethod) => {
             return (...args) => {
@@ -125,7 +125,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
         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);
+            appLifeCycle = new AppLifeCycle(tasks, initiatingTasks.map((t) => t.id), isRunOne ? 0 /* RunMode.RunOne */ : 1 /* RunMode.RunMany */, 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
@@ -206,7 +206,6 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
         };
     }
     const { runnerOptions } = getRunner(nxArgs, nxJson);
-    const isRunOne = initiatingProject != null;
     const useDynamicOutput = shouldUseDynamicLifeCycle(tasks, runnerOptions, nxArgs.outputStyle);
     if (isRunOne) {
         if (useDynamicOutput) {
@@ -241,6 +240,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
 }
 function createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies, projectNames, nxArgs, overrides, extraOptions) {
     const taskGraph = (0, create_task_graph_1.createTaskGraph)(projectGraph, extraTargetDependencies, projectNames, nxArgs.targets, nxArgs.configuration, overrides, extraOptions.excludeTaskDependencies);
+    (0, task_graph_utils_1.assertTaskGraphDoesNotContainInvalidTargets)(taskGraph);
     const cycle = (0, task_graph_utils_1.findCycle)(taskGraph);
     if (cycle) {
         if (process.env.NX_IGNORE_CYCLES === 'true' || nxArgs.nxIgnoreCycles) {
@@ -712,14 +712,6 @@ function getRunner(nxArgs, nxJson) {
     }
     const modulePath = getTasksRunnerPath(runner, nxJson);
     try {
-        if (isCustomRunnerPath(modulePath)) {
-            output_1.output.warn({
-                title: `Custom task runners will be replaced by a new API starting with Nx 21.`,
-                bodyLines: [
-                    `For more information, see https://nx.dev/deprecated/custom-tasks-runner`,
-                ],
-            });
-        }
         const tasksRunner = loadTasksRunner(modulePath);
         return {
             tasksRunner,
@@ -732,18 +724,12 @@ function getRunner(nxArgs, nxJson) {
 }
 const defaultTasksRunnerPath = require.resolve('./default-tasks-runner');
 function getTasksRunnerPath(runner, nxJson) {
-    let modulePath = nxJson.tasksRunnerOptions?.[runner]?.runner;
-    if (modulePath) {
-        if ((0, fileutils_1.isRelativePath)(modulePath)) {
-            return (0, node_path_1.join)(workspace_root_1.workspaceRoot, modulePath);
-        }
-        return modulePath;
-    }
     const isCloudRunner = 
     // No tasksRunnerOptions for given --runner
     nxJson.nxCloudAccessToken ||
         // No runner prop in tasks runner options, check if access token is set.
         nxJson.tasksRunnerOptions?.[runner]?.options?.accessToken ||
+        ['nx-cloud', '@nrwl/nx-cloud'].includes(nxJson.tasksRunnerOptions?.[runner]?.runner) ||
         // Cloud access token specified in env var.
         process.env.NX_CLOUD_ACCESS_TOKEN ||
         // Nx Cloud ID specified in nxJson
@@ -792,11 +778,3 @@ function getRunnerOptions(runner, nxJson, nxArgs, isCloudDefault) {
     }
     return result;
 }
-function isCustomRunnerPath(modulePath) {
-    return ![
-        'nx-cloud',
-        '@nrwl/nx-cloud',
-        'nx/tasks-runners/default',
-        defaultTasksRunnerPath,
-    ].includes(modulePath);
-}

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

@@ -4,6 +4,7 @@ export declare class NodeChildProcessWithNonDirectOutput implements RunningTask
     private childProcess;
     private terminalOutput;
     private exitCallbacks;
+    private exitCode;
     constructor(childProcess: ChildProcess, { streamOutput, prefix }: {
         streamOutput: boolean;
         prefix: string;

package/src/tasks-runner/running-tasks/node-child-process.js

@@ -35,6 +35,7 @@ class NodeChildProcessWithNonDirectOutput {
         this.childProcess.on('exit', (code, signal) => {
             if (code === null)
                 code = (0, exit_codes_1.signalToCode)(signal);
+            this.exitCode = code;
             for (const cb of this.exitCallbacks) {
                 cb(code, this.terminalOutput);
             }
@@ -56,6 +57,12 @@ class NodeChildProcessWithNonDirectOutput {
         this.exitCallbacks.push(cb);
     }
     async getResults() {
+        if (typeof this.exitCode === 'number') {
+            return {
+                code: this.exitCode,
+                terminalOutput: this.terminalOutput,
+            };
+        }
         return new Promise((res) => {
             this.onExit((code, terminalOutput) => {
                 res({ code, terminalOutput });

package/src/tasks-runner/task-graph-utils.d.ts

@@ -6,6 +6,7 @@ import { TaskGraph } from '../config/task-graph';
  */
 export declare function findCycle(graph: {
     dependencies: Record<string, string[]>;
+    continuousDependencies?: Record<string, string[]>;
 }): string[] | null;
 /**
  * This function finds all cycles in the graph.
@@ -13,9 +14,11 @@ export declare function findCycle(graph: {
  */
 export declare function findCycles(graph: {
     dependencies: Record<string, string[]>;
+    continuousDependencies?: Record<string, string[]>;
 }): Set<string> | null;
 export declare function makeAcyclic(graph: {
     roots: string[];
     dependencies: Record<string, string[]>;
 }): void;
 export declare function validateNoAtomizedTasks(taskGraph: TaskGraph, projectGraph: ProjectGraph): void;
+export declare function assertTaskGraphDoesNotContainInvalidTargets(taskGraph: TaskGraph): void;

package/src/tasks-runner/task-graph-utils.js

@@ -4,12 +4,16 @@ exports.findCycle = findCycle;
 exports.findCycles = findCycles;
 exports.makeAcyclic = makeAcyclic;
 exports.validateNoAtomizedTasks = validateNoAtomizedTasks;
+exports.assertTaskGraphDoesNotContainInvalidTargets = assertTaskGraphDoesNotContainInvalidTargets;
 const output_1 = require("../utils/output");
 function _findCycle(graph, id, visited, path) {
     if (visited[id])
         return null;
     visited[id] = true;
-    for (const d of graph.dependencies[id]) {
+    for (const d of [
+        ...graph.dependencies[id],
+        ...(graph.continuousDependencies?.[id] ?? []),
+    ]) {
         if (path.includes(d))
             return [...path, d];
         const cycle = _findCycle(graph, d, visited, [...path, d]);
@@ -57,9 +61,11 @@ function _makeAcyclic(graph, id, visited, path) {
         return;
     visited[id] = true;
     const deps = graph.dependencies[id];
-    for (const d of [...deps]) {
+    const continuousDeps = graph.continuousDependencies?.[id] ?? [];
+    for (const d of [...deps, ...continuousDeps]) {
         if (path.includes(d)) {
             deps.splice(deps.indexOf(d), 1);
+            continuousDeps.splice(continuousDeps.indexOf(d), 1);
         }
         else {
             _makeAcyclic(graph, d, visited, [...path, d]);
@@ -109,3 +115,26 @@ function validateNoAtomizedTasks(taskGraph, projectGraph) {
     }
     process.exit(1);
 }
+function assertTaskGraphDoesNotContainInvalidTargets(taskGraph) {
+    const invalidTasks = [];
+    for (const task of Object.values(taskGraph.tasks)) {
+        if (task.parallelism === false &&
+            taskGraph.continuousDependencies[task.id].length > 0) {
+            invalidTasks.push(task);
+        }
+    }
+    if (invalidTasks.length > 0) {
+        throw new NonParallelTaskDependsOnContinuousTasksError(invalidTasks, taskGraph);
+    }
+}
+class NonParallelTaskDependsOnContinuousTasksError extends Error {
+    constructor(invalidTasks, taskGraph) {
+        let message = 'The following tasks do not support parallelism but depend on continuous tasks:';
+        for (const task of invalidTasks) {
+            message += `\n - ${task.id} -> ${taskGraph.continuousDependencies[task.id].join(', ')}`;
+        }
+        super(message);
+        this.invalidTasks = invalidTasks;
+        this.name = 'NonParallelTaskDependsOnContinuousTasksError';
+    }
+}

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

@@ -38,9 +38,11 @@ class TaskOrchestrator {
         this.taskGraphForHashing = taskGraphForHashing;
         this.taskDetails = (0, hash_task_1.getTaskDetails)();
         this.cache = (0, cache_1.getCache)(this.options);
-        this.tuiEnabled = (0, is_tui_enabled_1.isTuiEnabled)(this.nxJson);
+        this.tuiEnabled = (0, is_tui_enabled_1.isTuiEnabled)();
         this.forkedProcessTaskRunner = new forked_process_task_runner_1.ForkedProcessTaskRunner(this.options, this.tuiEnabled);
-        this.runningTasksService = new native_1.RunningTasksService((0, db_connection_1.getDbConnection)());
+        this.runningTasksService = !native_1.IS_WASM
+            ? new native_1.RunningTasksService((0, db_connection_1.getDbConnection)())
+            : null;
         this.tasksSchedule = new tasks_schedule_1.TasksSchedule(this.projectGraph, this.taskGraph, this.options);
         // region internal state
         this.batchEnv = (0, task_env_1.getEnvVariablesForBatchProcess)(this.options.skipNxCache, this.options.captureStderr);
@@ -173,7 +175,7 @@ class TaskOrchestrator {
         // No output files to restore
         !!outputs.length &&
             // Remote caches are restored to output dirs when applied and using db cache
-            (!cachedResult.remote || !(0, cache_1.dbCacheEnabled)(this.nxJson)) &&
+            (!cachedResult.remote || !(0, cache_1.dbCacheEnabled)()) &&
             // Output files have not been touched since last run
             (await this.shouldCopyOutputsFromCache(outputs, task.hash));
         if (shouldCopyOutputsFromCache) {
@@ -194,6 +196,7 @@ class TaskOrchestrator {
     // endregion Applying Cache
     // region Batch
     async applyFromCacheOrRunBatch(doNotSkipCache, batch, groupId) {
+        const applyFromCacheOrRunBatchStart = perf_hooks_1.performance.mark('TaskOrchestrator-apply-from-cache-or-run-batch:start');
         const taskEntries = Object.entries(batch.taskGraph.tasks);
         const tasks = taskEntries.map(([, task]) => task);
         // Wait for batch to be processed
@@ -219,8 +222,12 @@ class TaskOrchestrator {
                 taskGraph: (0, utils_1.removeTasksFromTaskGraph)(batch.taskGraph, tasksCompleted.map(([taskId]) => taskId)),
             }, groupId);
         }
+        // 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);
     }
     async runBatch(batch, env) {
+        const runBatchStart = perf_hooks_1.performance.mark('TaskOrchestrator-run-batch:start');
         try {
             const batchProcess = await this.forkedProcessTaskRunner.forkProcessForBatch(batch, this.projectGraph, this.taskGraph, env);
             const results = await batchProcess.getResults();
@@ -242,6 +249,10 @@ class TaskOrchestrator {
                 status: 'failure',
             }));
         }
+        finally {
+            const runBatchEnd = perf_hooks_1.performance.mark('TaskOrchestrator-run-batch:end');
+            perf_hooks_1.performance.measure('TaskOrchestrator-run-batch', runBatchStart.name, runBatchEnd.name);
+        }
     }
     // endregion Batch
     // region Single Task
@@ -413,7 +424,8 @@ class TaskOrchestrator {
         }
     }
     async startContinuousTask(task, groupId) {
-        if (this.runningTasksService.getRunningTasks([task.id]).length) {
+        if (this.runningTasksService &&
+            this.runningTasksService.getRunningTasks([task.id]).length) {
             await this.preRunSteps([task], { groupId });
             if (this.tuiEnabled) {
                 this.options.lifeCycle.setTaskStatus(task.id, 8 /* NativeTaskStatus.Shared */);

package/src/utils/is-ci.d.ts

@@ -1 +1 @@
-export declare function isCI(): boolean;
+export declare function isCI(): string | boolean;

package/src/utils/is-ci.js

@@ -2,7 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isCI = isCI;
 function isCI() {
-    return ((process.env.CI && process.env.CI !== 'false') ||
+    if (process.env.CI === 'false') {
+        return false;
+    }
+    return (process.env.CI ||
         process.env.TF_BUILD === 'true' ||
         process.env.GITHUB_ACTIONS === 'true' ||
         process.env.BUILDKITE === 'true' ||

package/src/utils/package-manager.d.ts

@@ -44,6 +44,7 @@ export declare function getPackageManagerCommand(packageManager?: PackageManager
  * but it can also be passed in explicitly.
  */
 export declare function getPackageManagerVersion(packageManager?: PackageManager, cwd?: string): string;
+export declare function parseVersionFromPackageManagerField(requestedPackageManager: string, packageManagerFieldValue: string | undefined): null | string;
 /**
  * Checks for a project level npmrc file by crawling up the file tree until
  * hitting a package.json file, as this is how npm finds them as well.

package/src/utils/package-manager.js

@@ -4,6 +4,7 @@ exports.detectPackageManager = detectPackageManager;
 exports.isWorkspacesEnabled = isWorkspacesEnabled;
 exports.getPackageManagerCommand = getPackageManagerCommand;
 exports.getPackageManagerVersion = getPackageManagerVersion;
+exports.parseVersionFromPackageManagerField = parseVersionFromPackageManagerField;
 exports.findFileInPackageJsonDirectory = findFileInPackageJsonDirectory;
 exports.modifyYarnRcYmlToFitNewDirectory = modifyYarnRcYmlToFitNewDirectory;
 exports.modifyYarnRcToFitNewDirectory = modifyYarnRcToFitNewDirectory;
@@ -175,30 +176,42 @@ function getPackageManagerCommand(packageManager = detectPackageManager(), root
  */
 function getPackageManagerVersion(packageManager = detectPackageManager(), cwd = process.cwd()) {
     let version;
-    try {
-        version = (0, child_process_1.execSync)(`${packageManager} --version`, {
-            cwd,
-            encoding: 'utf-8',
-            windowsHide: true,
-        }).trim();
+    if ((0, fs_1.existsSync)((0, path_1.join)(cwd, 'package.json'))) {
+        const packageManagerEntry = (0, fileutils_1.readJsonFile)((0, path_1.join)(cwd, 'package.json'))?.packageManager;
+        version = parseVersionFromPackageManagerField(packageManager, packageManagerEntry);
     }
-    catch {
-        if ((0, fs_1.existsSync)((0, path_1.join)(cwd, 'package.json'))) {
-            const packageVersion = (0, fileutils_1.readJsonFile)((0, path_1.join)(cwd, 'package.json'))?.packageManager;
-            if (packageVersion) {
-                const [packageManagerFromPackageJson, versionFromPackageJson] = packageVersion.split('@');
-                if (packageManagerFromPackageJson === packageManager &&
-                    versionFromPackageJson) {
-                    version = versionFromPackageJson;
-                }
-            }
+    if (!version) {
+        try {
+            version = (0, child_process_1.execSync)(`${packageManager} --version`, {
+                cwd,
+                encoding: 'utf-8',
+                windowsHide: true,
+            }).trim();
         }
+        catch { }
     }
     if (!version) {
         throw new Error(`Cannot determine the version of ${packageManager}.`);
     }
     return version;
 }
+function parseVersionFromPackageManagerField(requestedPackageManager, packageManagerFieldValue) {
+    if (!packageManagerFieldValue)
+        return null;
+    const [packageManagerFromPackageJson, versionFromPackageJson] = packageManagerFieldValue.split('@');
+    if (versionFromPackageJson &&
+        // If it's a URL, it's not a valid range by default, unless users set `COREPACK_ENABLE_UNSAFE_CUSTOM_URLS=1`.
+        // In the unsafe case, there's no way to reliably pare out the version since it could be anything, e.g. http://mydomain.com/bin/yarn.js.
+        // See: https://github.com/nodejs/corepack/blob/2b43f26/sources/corepackUtils.ts#L110-L112
+        !URL.canParse(versionFromPackageJson) &&
+        packageManagerFromPackageJson === requestedPackageManager &&
+        versionFromPackageJson) {
+        // The range could have a validation hash attached, like "3.2.3+sha224.953c8233f7a92884eee2de69a1b92d1f2ec1655e66d08071ba9a02fa".
+        // We just want to parse out the "<major>.<minor>.<patch>". Semver treats "+" as a build, which is not included in the resulting version.
+        return (0, semver_1.parse)(versionFromPackageJson)?.version ?? null;
+    }
+    return null;
+}
 /**
  * Checks for a project level npmrc file by crawling up the file tree until
  * hitting a package.json file, as this is how npm finds them as well.

package/src/command-line/release/utils/github.d.ts

@@ -1,32 +0,0 @@
-import { NxReleaseChangelogConfiguration } from '../../../config/nx-json';
-import { Reference } from './git';
-import { ReleaseVersion } from './shared';
-export type RepoSlug = `${string}/${string}`;
-interface GithubRequestConfig {
-    repo: string;
-    hostname: string;
-    apiBaseUrl: string;
-    token: string | null;
-}
-interface GithubRelease {
-    id?: string;
-    tag_name: string;
-    target_commitish?: string;
-    name?: string;
-    body?: string;
-    draft?: boolean;
-    prerelease?: boolean;
-    make_latest?: 'legacy' | boolean;
-}
-export interface GithubRepoData {
-    hostname: string;
-    slug: RepoSlug;
-    apiBaseUrl: string;
-}
-export declare function getGitHubRepoData(remoteName: string, createReleaseConfig: NxReleaseChangelogConfiguration['createRelease']): GithubRepoData | null;
-export declare function createOrUpdateGithubRelease(createReleaseConfig: NxReleaseChangelogConfiguration['createRelease'], releaseVersion: ReleaseVersion, changelogContents: string, latestCommit: string, { dryRun }: {
-    dryRun: boolean;
-}): Promise<void>;
-export declare function getGithubReleaseByTag(config: GithubRequestConfig, tag: string): Promise<GithubRelease>;
-export declare function formatReferences(references: Reference[], repoData: GithubRepoData): string;
-export {};