nx 21.0.0-canary.20250430-07b881d → 21.0.0-rc.0

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

@@ -1,48 +1,66 @@
 "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;
+    if (['static', 'stream', 'dynamic-legacy'].includes(nxArgs.outputStyle)) {
+        // If the user has specified a non-TUI output style, we disable the TUI
+        return false;
     }
-    // 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 (nxArgs.outputStyle === 'dynamic' || nxArgs.outputStyle === 'tui') {
+        return true;
     }
-    // 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)();
+    // 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)() ||
+        // 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;
     }
     // 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/pseudo-terminal.d.ts

@@ -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;

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

@@ -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;

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

@@ -47,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) => {
@@ -124,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
@@ -205,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) {

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-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);
@@ -422,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/ignore.d.ts

@@ -1,8 +1,2 @@
 import ignore from 'ignore';
-/**
- * An array of glob patterns that should always be ignored.
- */
-export declare const ALWAYS_IGNORE: string[];
-export declare function getIgnoredGlobs(root?: string, prependRoot?: boolean): string[];
-export declare function getAlwaysIgnore(root?: string): string[];
 export declare function getIgnoreObject(root?: string): ReturnType<typeof ignore>;

package/src/utils/ignore.js

@@ -1,75 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALWAYS_IGNORE = void 0;
-exports.getIgnoredGlobs = getIgnoredGlobs;
-exports.getAlwaysIgnore = getAlwaysIgnore;
 exports.getIgnoreObject = getIgnoreObject;
-const node_fs_1 = require("node:fs");
 const ignore_1 = require("ignore");
 const fileutils_1 = require("./fileutils");
-const path_1 = require("./path");
 const workspace_root_1 = require("./workspace-root");
-/**
- * An array of glob patterns that should always be ignored.
- */
-exports.ALWAYS_IGNORE = getAlwaysIgnore();
-function getIgnoredGlobs(root = workspace_root_1.workspaceRoot, prependRoot = true) {
-    const files = ['.gitignore', '.nxignore'];
-    if (prependRoot) {
-        return [
-            ...getAlwaysIgnore(root),
-            ...files.flatMap((f) => getIgnoredGlobsFromFile((0, path_1.joinPathFragments)(root, f), root)),
-        ];
-    }
-    else {
-        return [
-            ...getAlwaysIgnore(),
-            ...files.flatMap((f) => getIgnoredGlobsFromFile((0, path_1.joinPathFragments)(root, f))),
-        ];
-    }
-}
-function getAlwaysIgnore(root) {
-    const paths = [
-        'node_modules',
-        '**/node_modules',
-        '.git',
-        '.nx',
-        '.vscode',
-        '.yarn/cache',
-    ];
-    return root ? paths.map((x) => (0, path_1.joinPathFragments)(root, x)) : paths;
-}
 function getIgnoreObject(root = workspace_root_1.workspaceRoot) {
     const ig = (0, ignore_1.default)();
     ig.add((0, fileutils_1.readFileIfExisting)(`${root}/.gitignore`));
     ig.add((0, fileutils_1.readFileIfExisting)(`${root}/.nxignore`));
     return ig;
 }
-function getIgnoredGlobsFromFile(file, root) {
-    try {
-        const results = [];
-        const contents = (0, node_fs_1.readFileSync)(file, 'utf-8');
-        const lines = contents.split('\n');
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('#')) {
-                continue;
-            }
-            else if (trimmed.startsWith('/')) {
-                if (root) {
-                    results.push((0, path_1.joinPathFragments)(root, trimmed));
-                }
-                else {
-                    results.push((0, path_1.joinPathFragments)('.', trimmed));
-                }
-            }
-            else {
-                results.push(trimmed);
-            }
-        }
-        return results;
-    }
-    catch (e) {
-        return [];
-    }
-}

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/utils/params.js

@@ -349,15 +349,11 @@ function setDefaultsInObject(opts, properties, definitions) {
     });
 }
 function setPropertyDefault(opts, propName, schema, definitions) {
+    let defaultValueToSet;
     if (schema.$ref) {
         schema = resolveDefinition(schema.$ref, definitions);
     }
-    if (schema.type !== 'object' && schema.type !== 'array') {
-        if (opts[propName] === undefined && schema.default !== undefined) {
-            opts[propName] = schema.default;
-        }
-    }
-    else if (schema.type === 'array') {
+    if (schema.type === 'array') {
         const items = schema.items || {};
         if (opts[propName] &&
             Array.isArray(opts[propName]) &&
@@ -365,19 +361,29 @@ function setPropertyDefault(opts, propName, schema, definitions) {
             opts[propName].forEach((valueInArray) => setDefaultsInObject(valueInArray, items.properties || {}, definitions));
         }
         else if (!opts[propName] && schema.default) {
-            opts[propName] = schema.default;
+            defaultValueToSet = schema.default;
         }
     }
     else {
-        const wasUndefined = opts[propName] === undefined;
-        if (wasUndefined) {
-            // We need an object to set values onto
-            opts[propName] = {};
-        }
-        setDefaultsInObject(opts[propName], schema.properties || {}, definitions);
-        // If the property was initially undefined but no properties were added, we remove it again instead of having an {}
-        if (wasUndefined && Object.keys(opts[propName]).length === 0) {
-            delete opts[propName];
+        if (opts[propName] === undefined && schema.default !== undefined) {
+            defaultValueToSet = schema.default;
+        }
+        if (schema.type === 'object') {
+            const wasUndefined = opts[propName] === undefined;
+            if (!wasUndefined) {
+                setDefaultsInObject(opts[propName], schema.properties || {}, definitions);
+            }
+        }
+    }
+    if (defaultValueToSet !== undefined) {
+        try {
+            validateProperty(propName, defaultValueToSet, schema, definitions);
+            opts[propName] = defaultValueToSet;
+        }
+        catch (e) {
+            // If the default value is invalid, we don't set it...
+            // this should honestly never be needed... but some notable
+            // 3rd party schema's are invalid.
         }
     }
 }

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