@ohos-ports/nx 23.3.0-beta.2 → 24.0.2-beta.0

package/dist/src/command-line/release/utils/version-plan-utils.js

@@ -3,43 +3,51 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateResolvedVersionPlansAgainstFilter = validateResolvedVersionPlansAgainstFilter;
 exports.getProjectsAffectedByVersionPlan = getProjectsAffectedByVersionPlan;
 exports.areAllVersionPlanProjectsFiltered = areAllVersionPlanProjectsFiltered;
-exports.getVersionPlanProjectsOutsideFilter = getVersionPlanProjectsOutsideFilter;
 /**
- * Validates that all projects in resolved version plans are included in the filtered projects.
- * This validation ensures that version plans don't contain projects that aren't being released.
+ * Validates that no version plan mixes projects being released with projects outside the release filter,
+ * as such a plan could neither be fully applied nor safely deleted.
  *
- * @param releaseGroups - The release groups to validate
+ * @param releaseGroups - All configured release groups, so that plans spanning groups outside the filter are caught
  * @param releaseGroupToFilteredProjects - Map of release groups to their filtered projects
  * @returns An error object if validation fails, null otherwise
  */
 function validateResolvedVersionPlansAgainstFilter(releaseGroups, releaseGroupToFilteredProjects) {
+    const projectsByPlanFile = new Map();
     for (const releaseGroup of releaseGroups) {
-        if (releaseGroup.resolvedVersionPlans &&
-            releaseGroup.resolvedVersionPlans.length > 0) {
-            const filteredProjects = releaseGroupToFilteredProjects.get(releaseGroup);
-            for (const plan of releaseGroup.resolvedVersionPlans) {
-                // check if version plan applies to filtered projects
-                if (!checkVersionPlanContainsFilteredProjects(plan, releaseGroup, filteredProjects)) {
-                    continue;
+        if (!releaseGroup.resolvedVersionPlans) {
+            continue;
+        }
+        const filteredProjects = releaseGroupToFilteredProjects.get(releaseGroup);
+        for (const plan of releaseGroup.resolvedVersionPlans) {
+            let projects = projectsByPlanFile.get(plan.fileName);
+            if (!projects) {
+                projects = { filtered: new Set(), outsideFilter: new Set() };
+                projectsByPlanFile.set(plan.fileName, projects);
+            }
+            for (const project of getProjectsAffectedByVersionPlan(plan, releaseGroup)) {
+                if (filteredProjects?.has(project)) {
+                    projects.filtered.add(project);
                 }
-                // Check if version plan contains projects outside the filter
-                const projectsOutsideFilter = getVersionPlanProjectsOutsideFilter(plan, releaseGroup, filteredProjects);
-                if (projectsOutsideFilter.length > 0) {
-                    // Error if version plan contains projects not in the filter
-                    return {
-                        title: `Version plan contains projects not included in the release filter`,
-                        bodyLines: [
-                            `The following projects in the version plan are not being released:`,
-                            ...projectsOutsideFilter.map((p) => `  - ${p}`),
-                            '',
-                            `Either include all projects from the version plan in your release command,`,
-                            `or create separate version plans for different sets of projects.`,
-                        ],
-                    };
+                else {
+                    projects.outsideFilter.add(project);
                 }
             }
         }
     }
+    for (const [fileName, { filtered, outsideFilter }] of projectsByPlanFile) {
+        if (filtered.size > 0 && outsideFilter.size > 0) {
+            return {
+                title: `Version plan contains projects not included in the release filter`,
+                bodyLines: [
+                    `The following projects in version plan '${fileName}' are not being released:`,
+                    ...Array.from(outsideFilter).map((p) => `  - ${p}`),
+                    '',
+                    `Either include all projects from the version plan in your release command,`,
+                    `or create separate version plans for different sets of projects.`,
+                ],
+            };
+        }
+    }
     return null;
 }
 /**
@@ -79,33 +87,3 @@ function areAllVersionPlanProjectsFiltered(plan, releaseGroup, filteredProjects)
     return (planProjects.size > 0 &&
         Array.from(planProjects).every((project) => filteredProjects.has(project)));
 }
-/**
- * Finds projects in a version plan that are NOT included in the filtered projects set.
- *
- * @param plan - The version plan to check
- * @param releaseGroup - The release group containing the version plan
- * @param filteredProjects - Set of projects that are being released (filtered)
- * @returns Array of project names that are in the version plan but not in the filter
- */
-function getVersionPlanProjectsOutsideFilter(plan, releaseGroup, filteredProjects) {
-    if (!filteredProjects) {
-        return [];
-    }
-    const planProjects = getProjectsAffectedByVersionPlan(plan, releaseGroup);
-    return Array.from(planProjects).filter((project) => !filteredProjects.has(project));
-}
-/**
- * Checks whether the version plan contains any of the filtered projects.
- *
- * @param plan - The version plan to check.
- * @param releaseGroup - The release group associated with the version plan.
- * @param filteredProjects - Set of projects that are being released (filtered).
- * @returns Returns true if the version plan contains any of the filtered projects, or if no filtered projects are provided.
- */
-function checkVersionPlanContainsFilteredProjects(plan, releaseGroup, filteredProjects) {
-    if (!filteredProjects) {
-        return true;
-    }
-    const planProjects = getProjectsAffectedByVersionPlan(plan, releaseGroup);
-    return Array.from(filteredProjects).some((project) => planProjects.has(project));
-}

package/dist/src/command-line/release/version/version-actions.js

@@ -5,6 +5,7 @@ exports.resolveVersionActionsForProject = resolveVersionActionsForProject;
 const node_path_1 = require("node:path");
 const register_1 = require("../../../plugins/js/utils/register");
 const utils_1 = require("../../../tasks-runner/utils");
+const interpolate_release_config_1 = require("../utils/interpolate-release-config");
 const workspace_root_1 = require("../../../utils/workspace-root");
 const config_1 = require("../config/config");
 const semver_1 = require("../utils/semver");
@@ -123,7 +124,7 @@ class VersionActions {
         const interpolatedManifestRoots = this.finalConfigForProject.manifestRootsToUpdate.map((manifestRoot) => {
             return {
                 ...manifestRoot,
-                path: (0, utils_1.interpolate)(manifestRoot.path, {
+                path: (0, interpolate_release_config_1.interpolateReleaseConfig)(manifestRoot.path, {
                     workspaceRoot: '',
                     projectRoot: this.projectGraphNode.data.root,
                     projectName: this.projectGraphNode.name,

package/dist/src/command-line/release/version.js

@@ -47,6 +47,9 @@ function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
         if (configError) {
             return await (0, config_1.handleNxReleaseConfigError)(configError);
         }
+        if (args.gitCommitMessage) {
+            (0, config_1.validateCommitMessageTokens)(args.gitCommitMessage);
+        }
         // --print-config exits directly as it is not designed to be combined with any other programmatic operations
         if (args.printConfig) {
             return (0, print_config_1.printConfigAndExit)({
@@ -96,9 +99,9 @@ function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
         }
         if (!args.specifier) {
             const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
-            await (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGraph.releaseGroups, Object.keys(projectGraph.nodes), args.verbose);
+            await (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGraph.allReleaseGroups, Object.keys(projectGraph.nodes), args.verbose);
             // Validate version plans against the filter after resolution
-            const versionPlanValidationError = (0, version_plan_utils_1.validateResolvedVersionPlansAgainstFilter)(releaseGraph.releaseGroups, releaseGraph.releaseGroupToFilteredProjects);
+            const versionPlanValidationError = (0, version_plan_utils_1.validateResolvedVersionPlansAgainstFilter)(releaseGraph.allReleaseGroups, releaseGraph.releaseGroupToFilteredProjects);
             if (versionPlanValidationError) {
                 output_1.output.error(versionPlanValidationError);
                 process.exit(1);

package/dist/src/command-line/reset/reset.js

@@ -6,6 +6,7 @@ const client_1 = require("../../daemon/client/client");
 const tmp_dir_1 = require("../../daemon/tmp-dir");
 const cache_directory_1 = require("../../utils/cache-directory");
 const output_1 = require("../../utils/output");
+const spinner_1 = require("../../utils/spinner");
 const native_file_cache_location_1 = require("../../native/native-file-cache-location");
 const workspace_root_1 = require("../../utils/workspace-root");
 const client_2 = require("../../nx-cloud/utilities/client");
@@ -19,80 +20,63 @@ const INCREMENTAL_BACKOFF_MAX_DURATION = 5000;
 // If an operation fails, wait 100ms before first retry.
 const INCREMENTAL_BACKOFF_FIRST_DELAY = 100;
 async function resetHandler(args) {
-    let errors = [];
+    const errors = [];
     const all = args.onlyDaemon === undefined &&
         args.onlyCache === undefined &&
         args.onlyWorkspaceData === undefined;
     const nxJson = (0, configuration_1.readNxJson)();
     const cloudEnabled = (0, nx_cloud_utils_1.isNxCloudUsed)(nxJson);
-    const startupMessage = all
-        ? 'Resetting the Nx cache and stopping the daemon.'
-        : 'Resetting:';
-    const bodyLines = [];
-    if (!all) {
-        if (args.onlyDaemon) {
-            bodyLines.push('- Nx Daemon and its workspace data');
-        }
-        if (args.onlyCache) {
-            bodyLines.push('- Cache directory');
-        }
-        if (args.onlyWorkspaceData) {
-            bodyLines.push('- Workspace data directory');
-        }
-        if (args.onlyCloud && cloudEnabled) {
-            bodyLines.push('- Nx Cloud Client');
-        }
-    }
-    output_1.output.note({ title: startupMessage, bodyLines });
     if (all || args.onlyDaemon) {
-        try {
-            await killDaemon();
-        }
-        catch (e) {
-            errors.push('Failed to stop the Nx Daemon.', e.toString());
-        }
-        try {
-            await cleanupDaemonWorkspaceData();
-        }
-        catch (e) {
-            errors.push('Failed to clean up the daemon workspace data directory.', e.toString());
-        }
+        await runResetStep(errors, {
+            start: 'Stopping the Nx Daemon',
+            success: 'Stopped the Nx Daemon',
+            failure: 'Failed to stop the Nx Daemon.',
+            run: killDaemon,
+        });
+        await runResetStep(errors, {
+            start: 'Removing the Nx Daemon workspace data',
+            success: 'Removed the Nx Daemon workspace data',
+            failure: 'Failed to clean up the daemon workspace data directory.',
+            run: cleanupDaemonWorkspaceData,
+        });
     }
     if (all || args.onlyCache) {
-        try {
-            await cleanupCacheEntries();
-        }
-        catch (e) {
-            errors.push('Failed to clean up the cache directory.', e.toString());
-        }
+        await runResetStep(errors, {
+            start: 'Removing the cache directory',
+            success: 'Removed the cache directory',
+            failure: 'Failed to clean up the cache directory.',
+            run: cleanupCacheEntries,
+        });
     }
     if (all || args.onlyWorkspaceData) {
-        try {
-            await cleanupNativeFileCache();
-        }
-        catch {
-            // ignore, deleting the native file cache is not critical and can fail if another process is locking the file
-        }
-        try {
-            await cleanupWorkspaceData();
-        }
-        catch (e) {
-            errors.push('Failed to clean up the workspace data directory.', e.toString());
-        }
+        await runResetStep(errors, {
+            start: 'Removing the workspace data directory',
+            success: 'Removed the workspace data directory',
+            failure: 'Failed to clean up the workspace data directory.',
+            run: async () => {
+                try {
+                    await cleanupNativeFileCache();
+                }
+                catch {
+                    // ignore, deleting the native file cache is not critical and can fail if another process is locking the file
+                }
+                await cleanupWorkspaceData();
+            },
+        });
     }
     if ((cloudEnabled && all) || args.onlyCloud) {
-        try {
-            await resetCloudClient();
-        }
-        catch (e) {
-            errors.push('Failed to clean up the Nx Cloud client.', e.toString());
-        }
-        try {
-            await removeInstalledNxCloudClient();
-        }
-        catch (e) {
-            errors.push('Failed to reset the Nx Cloud client.', e.toString());
-        }
+        await runResetStep(errors, {
+            start: 'Cleaning up the Nx Cloud client',
+            success: 'Cleaned up the Nx Cloud client',
+            failure: 'Failed to clean up the Nx Cloud client.',
+            run: resetCloudClient,
+        });
+        await runResetStep(errors, {
+            start: 'Removing the installed Nx Cloud client',
+            success: 'Removed the installed Nx Cloud client',
+            failure: 'Failed to reset the Nx Cloud client.',
+            run: removeInstalledNxCloudClient,
+        });
     }
     if (errors.length > 0) {
         output_1.output.error({
@@ -107,6 +91,18 @@ async function resetHandler(args) {
         });
     }
 }
+/** Records a failure in `errors` so the remaining steps still run. */
+async function runResetStep(errors, step) {
+    spinner_1.globalSpinner.start(step.start);
+    try {
+        await step.run();
+        spinner_1.globalSpinner.succeed(step.success);
+    }
+    catch (e) {
+        spinner_1.globalSpinner.fail(step.failure);
+        errors.push(step.failure, e.toString());
+    }
+}
 async function killDaemon() {
     if (client_1.daemonClient.enabled()) {
         return client_1.daemonClient.stop();

package/dist/src/command-line/run/executor-utils.js

@@ -44,6 +44,7 @@ projects) {
         const batchImplementationFactory = executorConfig.batchImplementation
             ? (0, schema_utils_1.getImplementationFactory)(executorConfig.batchImplementation, executorsDir, nodeModule, projects)
             : null;
+        // TODO(v25): remove custom hasher support.
         const hasherFactory = executorConfig.hasher
             ? (0, schema_utils_1.getImplementationFactory)(executorConfig.hasher, executorsDir, nodeModule, projects)
             : null;

package/dist/src/command-line/run/run-one.d.ts

@@ -1,5 +1,5 @@
 import { NxJsonConfiguration } from '../../config/nx-json';
-import { ProjectGraph } from '../../config/project-graph';
+import { ProjectGraph, ProjectGraphProjectNode } from '../../config/project-graph';
 import { TargetDependencyConfig } from '../../config/workspace-json-project-json';
 export declare function runOne(cwd: string, args: {
     [k: string]: any;
@@ -7,6 +7,25 @@ export declare function runOne(cwd: string, args: {
     excludeTaskDependencies: boolean;
     loadDotEnvFiles: boolean;
 }): Promise<void>;
+/**
+ * Builds the error shown when the project itself can't be found. Matches the
+ * attempted `project:target[:configuration]` against every runnable task id so
+ * a project typo (e.g. `webpai:build`) still surfaces the intended task
+ * (`webapi:build`).
+ */
+export declare function getCannotFindProjectError(projectGraph: ProjectGraph, projectName: string, target: string, configuration?: string): {
+    title: string;
+    bodyLines: string[];
+};
+/**
+ * Validates that `target` exists on the resolved project. When it does not,
+ * returns an error describing the available targets (and the closest match, if
+ * any) so the user can recover from a typo or discover what they can run.
+ */
+export declare function getRunOneTargetError(project: ProjectGraphProjectNode, target: string, configuration?: string): {
+    title: string;
+    bodyLines: string[];
+} | null;
 export declare function parseRunOneOptions(cwd: string, parsedArgs: {
     [k: string]: any;
 }, projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): {

package/dist/src/command-line/run/run-one.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runOne = runOne;
+exports.getCannotFindProjectError = getCannotFindProjectError;
+exports.getRunOneTargetError = getRunOneTargetError;
 exports.parseRunOneOptions = parseRunOneOptions;
 const calculate_default_project_name_1 = require("../../config/calculate-default-project-name");
 const configuration_1 = require("../../config/configuration");
@@ -11,6 +13,7 @@ const command_line_utils_1 = require("../../utils/command-line-utils");
 const find_matching_projects_1 = require("../../utils/find-matching-projects");
 const output_1 = require("../../utils/output");
 const split_target_1 = require("../../utils/split-target");
+const string_similarity_1 = require("../../utils/string-similarity");
 const workspace_root_1 = require("../../utils/workspace-root");
 const graph_1 = require("../graph/graph");
 const connect_to_nx_cloud_1 = require("../nx-cloud/connect/connect-to-nx-cloud");
@@ -28,7 +31,12 @@ async function runOne(cwd, args, extraTargetDependencies = {}, extraOptions = {
         configuration: opts.configuration,
         targets: [opts.target],
     }, 'run-one', { printWarnings: args.graph !== 'stdout' }, nxJson);
-    const { projects, projectName } = getProjects(projectGraph, opts.project);
+    const { projects, projectName } = getProjects(projectGraph, opts.project, opts.target, opts.configuration);
+    const targetError = getRunOneTargetError(projects[0], opts.target, opts.configuration);
+    if (targetError) {
+        output_1.output.error(targetError);
+        process.exit(1);
+    }
     if (nxArgs.help) {
         await (await (0, handle_import_1.handleImport)('./run.js', __dirname)).printTargetRunHelp({
             ...opts,
@@ -59,7 +67,7 @@ async function runOne(cwd, args, extraTargetDependencies = {}, extraOptions = {
         process.exit(status);
     }
 }
-function getProjects(projectGraph, projectName) {
+function getProjects(projectGraph, projectName, target, configuration) {
     if (projectGraph.nodes[projectName]) {
         return {
             projectName: projectName,
@@ -90,11 +98,151 @@ function getProjects(projectGraph, projectName) {
             process.exit(1);
         }
     }
-    output_1.output.error({
-        title: `Cannot find project '${projectName}'`,
-    });
+    output_1.output.error(getCannotFindProjectError(projectGraph, projectName, target, configuration));
     process.exit(1);
 }
+// Keep error output scannable: only show a handful of targets/suggestions.
+const MAX_LISTED_TARGETS = 5;
+const MAX_SUGGESTIONS = 3;
+/**
+ * Builds the list of all runnable `project:target` task ids in the workspace,
+ * used to suggest the right invocation when a project or target can't be found.
+ */
+function getProjectTargetIds(projectGraph) {
+    const ids = [];
+    for (const projectName of Object.keys(projectGraph.nodes)) {
+        const targets = projectGraph.nodes[projectName].data.targets ?? {};
+        for (const targetName of Object.keys(targets)) {
+            ids.push(`${projectName}:${targetName}`);
+        }
+    }
+    return ids;
+}
+/**
+ * A target (and even a configuration) name can legally contain ':'. When the
+ * user typos such a name, `splitTarget` splits on every ':' and parses the
+ * trailing segment(s) as separate parts (e.g. `nx:zzcustom:variantt` becomes
+ * project `nx`, target `zzcustom`, configuration `variantt`).
+ *
+ * To match the real name we therefore score the fully-rejoined specifier and
+ * every progressively shorter form, and keep whichever produced the closest
+ * candidate. Rejoining wins for colon-containing names, while the shorter forms
+ * keep matching genuine `target` + `configuration` typos (where the real target
+ * name does not carry the configuration suffix). Ties go to the longer form,
+ * which is the one that reproduces the name the user actually typed.
+ */
+function findClosestSpecifier(parts, candidates, limit = 1) {
+    const present = parts.filter((part) => !!part);
+    let best = [];
+    for (let end = present.length; end >= 1; end--) {
+        const matches = (0, string_similarity_1.rankSuggestions)(present.slice(0, end).join(':'), candidates);
+        if (matches.length &&
+            (!best.length || matches[0].distance < best[0].distance)) {
+            best = matches;
+        }
+    }
+    return best.slice(0, limit).map(({ candidate }) => candidate);
+}
+/**
+ * Finds the closest available target to what the user typed, staying
+ * config-aware. When a configuration was parsed off the specifier, the rejoined
+ * `target:configuration` is scored too, so a colon-containing real target name
+ * (e.g. `zzcustom:variant`) still matches. Both forms are scored and the closest
+ * candidate wins, ties going to the rejoined form -- mirroring
+ * `findClosestSpecifier`'s preference order. The bare-`target` tier reuses the
+ * precomputed `ranked` list (its head, gated by the suggestion threshold)
+ * instead of recomputing distances.
+ */
+function findClosestTarget(target, configuration, availableTargets, ranked) {
+    let best;
+    if (configuration) {
+        [best] = (0, string_similarity_1.rankSuggestions)(`${target}:${configuration}`, availableTargets);
+    }
+    const nearest = ranked[0];
+    if (nearest &&
+        (0, string_similarity_1.isWithinSuggestionThreshold)(target, nearest.candidate, nearest.distance) &&
+        (!best || nearest.distance < best.distance)) {
+        best = nearest;
+    }
+    return best?.candidate;
+}
+/**
+ * Lists up to `MAX_LISTED_TARGETS` targets from a list already ranked by how
+ * closely they resemble the target the user typed (closest first, ties broken
+ * alphabetically) so the most likely intended targets surface first.
+ * `closestMatch` is dropped because it is already surfaced separately as the
+ * "Did you mean" suggestion. Appends a "...and N more" line when the project has
+ * more targets than we show, and returns no lines at all when the suggestion was
+ * the project's only target -- a bare "Available targets:" header reads as "this
+ * project has none".
+ */
+function formatAvailableTargets(ranked, closestMatch) {
+    const targets = ranked
+        .map(({ candidate }) => candidate)
+        .filter((candidate) => candidate !== closestMatch);
+    if (!targets.length) {
+        return [];
+    }
+    const shown = targets.slice(0, MAX_LISTED_TARGETS);
+    const lines = ['Available targets:', ...shown.map((t) => `  - ${t}`)];
+    if (targets.length > shown.length) {
+        lines.push(`  ...and ${targets.length - shown.length} more`);
+    }
+    return lines;
+}
+/**
+ * Builds the error shown when the project itself can't be found. Matches the
+ * attempted `project:target[:configuration]` against every runnable task id so
+ * a project typo (e.g. `webpai:build`) still surfaces the intended task
+ * (`webapi:build`).
+ */
+function getCannotFindProjectError(projectGraph, projectName, target, configuration) {
+    const bodyLines = [];
+    const suggestions = findClosestSpecifier([projectName, target, configuration], getProjectTargetIds(projectGraph), MAX_SUGGESTIONS);
+    if (suggestions.length) {
+        bodyLines.push('Did you mean one of these?', ...suggestions.map((id) => `  - ${id}`));
+    }
+    return {
+        title: `Cannot find project '${projectName}'`,
+        bodyLines,
+    };
+}
+/**
+ * Validates that `target` exists on the resolved project. When it does not,
+ * returns an error describing the available targets (and the closest match, if
+ * any) so the user can recover from a typo or discover what they can run.
+ */
+function getRunOneTargetError(project, target, configuration) {
+    const availableTargets = Object.keys(project.data.targets ?? {});
+    if (availableTargets.includes(target)) {
+        return null;
+    }
+    const bodyLines = [];
+    // Rank the available targets by distance to the bare target ONCE. This drives
+    // the ordered "Available targets" block and doubles as the bare-target tier of
+    // the closest-match lookup, so distances are not computed twice.
+    const ranked = (0, string_similarity_1.rankByDistance)(target, availableTargets);
+    const closestMatch = findClosestTarget(target, configuration, availableTargets, ranked);
+    if (closestMatch) {
+        bodyLines.push(`Did you mean "${closestMatch}"?`);
+    }
+    if (!availableTargets.length) {
+        bodyLines.push(`The project "${project.name}" does not have any targets configured.`);
+    }
+    else {
+        const targetLines = formatAvailableTargets(ranked, closestMatch);
+        if (targetLines.length) {
+            if (bodyLines.length) {
+                bodyLines.push('');
+            }
+            bodyLines.push(...targetLines);
+        }
+    }
+    return {
+        title: `Cannot find target "${target}" for project "${project.name}"`,
+        bodyLines,
+    };
+}
 const targetAliases = {
     b: 'build',
     e: 'e2e',

package/dist/src/command-line/run/run.js

@@ -17,6 +17,7 @@ const configuration_1 = require("../../config/configuration");
 const async_iterator_1 = require("../../utils/async-iterator");
 const executor_utils_1 = require("./executor-utils");
 const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
+const executor_ready_signal_1 = require("../../tasks-runner/readiness/executor-ready-signal");
 const child_process_1 = require("child_process");
 function printRunHelp(opts, schema, plugin) {
     (0, print_help_1.printHelp)(`run ${opts.project}:${opts.target}`, schema, {
@@ -174,6 +175,6 @@ function run(cwd, root, targetDescription, overrides, isVerbose, taskGraph) {
     const projectGraph = (0, project_graph_1.readCachedProjectGraph)();
     return (0, handle_errors_1.handleErrors)(isVerbose, async () => {
         const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
-        return iteratorToProcessStatusCode(await runExecutorInternal(targetDescription, overrides, root, cwd, projectsConfigurations, (0, configuration_1.readNxJson)(), projectGraph, taskGraph, isVerbose));
+        return iteratorToProcessStatusCode((0, executor_ready_signal_1.signalReadyAtBaseUrl)(await runExecutorInternal(targetDescription, overrides, root, cwd, projectsConfigurations, (0, configuration_1.readNxJson)(), projectGraph, taskGraph, isVerbose)));
     });
 }

package/dist/src/command-line/show/projects.js

@@ -21,12 +21,12 @@ async function showProjectsHandler(args) {
         printWarnings: false,
     }, nxJson);
     const explainsTasks = args.affected &&
-        (0, affected_tasks_1.selectsAffectedTasks)() &&
+        (0, affected_tasks_1.selectsAffectedTasks)(nxJson) &&
         !!args.withTarget?.length &&
         !args.projects;
     if ((0, affected_reasons_1.isExplaining)(nxArgs.explain) && !explainsTasks) {
         throw new Error((0, affected_reasons_1.explainUnavailable)([
-            !(0, affected_tasks_1.selectsAffectedTasks)() && 'NX_LEGACY_AFFECTED=false',
+            !(0, affected_tasks_1.selectsAffectedTasks)(nxJson) && (0, affected_tasks_1.taskGranularityRequirement)(),
             !args.affected && '--affected',
             !args.withTarget?.length && 'targets passed with --withTarget (-t)',
         ].filter(Boolean), args.projects ? ['--projects'] : []));
@@ -35,7 +35,9 @@ async function showProjectsHandler(args) {
     if (args.affected) {
         const touchedFiles = await getTouchedFiles(nxArgs);
         // With a target, list projects owning an affected task for it, matching `affected -t`.
-        if ((0, affected_tasks_1.selectsAffectedTasks)() && args.withTarget?.length && !args.projects) {
+        if ((0, affected_tasks_1.selectsAffectedTasks)(nxJson) &&
+            args.withTarget?.length &&
+            !args.projects) {
             const affectedTasks = await (0, affected_tasks_1.computeAffectedTasks)({
                 projectGraph: graph,
                 nxJson,

package/dist/src/command-line/show/show-target/info.d.ts

@@ -1,4 +1,5 @@
-import type { InputDefinition } from '../../../config/workspace-json-project-json';
+import type { InputDefinition, ReadyWhen } from '../../../config/workspace-json-project-json';
+import { type UltracacheModeInCI } from '../../../ultracache/ci-status';
 import type { ShowTargetBaseOptions } from '../command-object';
 import { type ResolvedTarget } from './utils';
 export declare function showTargetInfoHandler(args: ShowTargetBaseOptions): Promise<void>;
@@ -13,9 +14,14 @@ declare function resolveTargetInfoData(t: ResolvedTarget): {
     customHasher?: boolean;
     dependsOn?: string[];
     _depSources?: number[];
+    _continuousDeps?: Record<string, {
+        inputsHashed: boolean;
+        waitsForReady: boolean;
+    }>;
     transitiveTasks?: string[];
     parallelism: boolean;
     continuous: boolean;
+    readyWhen?: ReadyWhen;
     cache: boolean;
     inputs?: (string | InputDefinition)[];
     _inputSources?: number[];
@@ -24,5 +30,8 @@ declare function resolveTargetInfoData(t: ResolvedTarget): {
     configurations?: string[];
     defaultConfiguration?: string;
     sourceMap?: Record<string, [file: string, plugin: string]>;
+    /** Set by the handler once Nx Cloud confirms the workspace is On. */
+    ultracacheInCI: UltracacheModeInCI | undefined;
+    ultracacheMode: UltracacheModeInCI;
 };
 export {};