@depup/nx 22.6.4-depup.2 → 23.1.0-depup.0

package/dist/src/command-line/migrate/resolve-package-version.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRegistryResolutionEnabled = isRegistryResolutionEnabled;
+exports.resetResolvePackageVersionState = resetResolvePackageVersionState;
+exports.resolvePackageVersionRespectingMinReleaseAge = resolvePackageVersionRespectingMinReleaseAge;
+const configuration_1 = require("../../config/configuration");
+const is_ci_1 = require("../../utils/is-ci");
+const logger_1 = require("../../utils/logger");
+const output_1 = require("../../utils/output");
+const catalog_1 = require("../../utils/catalog");
+const package_manager_1 = require("../../utils/package-manager");
+const workspace_root_1 = require("../../utils/workspace-root");
+const errors_1 = require("../../utils/min-release-age/errors");
+const policy_1 = require("../../utils/min-release-age/policy");
+const pnpm_exclude_writer_1 = require("../../utils/min-release-age/pnpm-exclude-writer");
+const resolve_1 = require("../../utils/min-release-age/resolve");
+const safe_prompt_1 = require("./safe-prompt");
+/**
+ * Whether nx migrate should resolve versions via the npm registry (fast) rather
+ * than via a real package-manager install. Precedence, highest first:
+ *
+ * 1. `NX_MIGRATE_USE_REGISTRY_RESOLUTION` ('true' -> enabled, 'false' -> disabled)
+ * 2. legacy `NX_MIGRATE_SKIP_REGISTRY_FETCH` (deprecated, removed in Nx 24;
+ *    'true' -> disabled, 'false' -> enabled)
+ * 3. nx.json `migrate.useRegistryResolution`
+ * 4. default: enabled
+ */
+function isRegistryResolutionEnabled(root = workspace_root_1.workspaceRoot) {
+    warnIfLegacyRegistryEnvVarSet();
+    const explicit = parseBooleanFlag(process.env.NX_MIGRATE_USE_REGISTRY_RESOLUTION);
+    if (explicit !== undefined) {
+        return explicit;
+    }
+    // Legacy env is inverted: SKIP_REGISTRY_FETCH=true disables resolution.
+    const legacy = parseBooleanFlag(process.env.NX_MIGRATE_SKIP_REGISTRY_FETCH);
+    if (legacy !== undefined) {
+        return !legacy;
+    }
+    return (0, configuration_1.readNxJson)(root)?.migrate?.useRegistryResolution ?? true;
+}
+function parseBooleanFlag(value) {
+    return value === 'true' ? true : value === 'false' ? false : undefined;
+}
+// NX_MIGRATE_SKIP_REGISTRY_FETCH is the inverted, legacy predecessor of
+// NX_MIGRATE_USE_REGISTRY_RESOLUTION: deprecated in Nx 23, removed in Nx 24.
+// Warn once whenever it is present (even when the new var overrides it) so users
+// migrate off it and clean up configs where it lingers - a dormant value would
+// silently re-activate if the new var were later removed.
+function warnIfLegacyRegistryEnvVarSet() {
+    if (legacyRegistryEnvVarDeprecationWarned ||
+        process.env.NX_MIGRATE_SKIP_REGISTRY_FETCH === undefined) {
+        return;
+    }
+    legacyRegistryEnvVarDeprecationWarned = true;
+    const bodyLines = [
+        'Use NX_MIGRATE_USE_REGISTRY_RESOLUTION (or migrate.useRegistryResolution in nx.json) instead, then remove NX_MIGRATE_SKIP_REGISTRY_FETCH from your environment.',
+    ];
+    if (process.env.NX_MIGRATE_USE_REGISTRY_RESOLUTION !== undefined) {
+        bodyLines.push('It is currently being overridden by NX_MIGRATE_USE_REGISTRY_RESOLUTION.');
+    }
+    output_1.output.warn({
+        title: 'NX_MIGRATE_SKIP_REGISTRY_FETCH is deprecated and will be removed in Nx 24.',
+        bodyLines,
+    });
+}
+// The cooldown policy is constant for a migrate run; read it once.
+let cachedPolicyPromise;
+// Dedup the "resolved X instead of Y" notice across repeated specs.
+const reportedChangedOutcomes = new Set();
+// Strict-mode approval is a once-per-run decision (mirrors pnpm prompting once).
+let strictApprovalGranted = false;
+// The deprecated NX_MIGRATE_SKIP_REGISTRY_FETCH heads-up is shown once per run.
+let legacyRegistryEnvVarDeprecationWarned = false;
+/** Test-only: clear the module-level caches between cases. */
+function resetResolvePackageVersionState() {
+    cachedPolicyPromise = undefined;
+    reportedChangedOutcomes.clear();
+    strictApprovalGranted = false;
+    legacyRegistryEnvVarDeprecationWarned = false;
+}
+function getPolicy() {
+    cachedPolicyPromise ??= (0, policy_1.readMinReleaseAgePolicy)();
+    return cachedPolicyPromise;
+}
+/**
+ * The single resolution entry point for ALL nx migrate version resolutions. It
+ * resolves a package spec to a concrete version while honoring the effective
+ * minimum-release-age (cooldown) policy of the user's package manager, matching
+ * how that PM at its detected version would resolve. Falls back to a real PM
+ * install when the policy can't be reasoned about, or when registry resolution
+ * is opted out.
+ */
+async function resolvePackageVersionRespectingMinReleaseAge(packageName, version, options) {
+    // A speculative lookup (e.g. populating multi-major prompt choices) sets this
+    // to false so resolving a version the user has not chosen yet never prompts,
+    // writes pnpm excludes, or triggers a real install.
+    const applySideEffects = options?.applySideEffects ?? true;
+    // A probe can never install, so the registry-resolution opt-out (which only
+    // picks install vs. registry for the real resolution) does not apply to it: it
+    // is always registry-based. Resolve read-only while still reproducing an active
+    // cooldown so the probe predicts the same version a real install would accept.
+    if (!applySideEffects) {
+        return resolveProbe(packageName, version);
+    }
+    if (!isRegistryResolutionEnabled()) {
+        return (0, package_manager_1.resolvePackageVersionUsingInstallation)(packageName, version);
+    }
+    const result = await getPolicy();
+    if (result.outcome === 'inactive') {
+        return (0, package_manager_1.resolvePackageVersionUsingRegistry)(packageName, version);
+    }
+    if (result.outcome === 'ambiguous') {
+        logger_1.logger.verbose(`Cannot determine the minimum-release-age policy (${result.reason}); falling back to a package-manager install to resolve ${packageName}@${version}.`);
+        return (0, package_manager_1.resolvePackageVersionUsingInstallation)(packageName, version);
+    }
+    return resolveWithPolicy(packageName, version, result.policy, true);
+}
+/**
+ * Read-only resolution for speculative lookups (never installs, never prompts,
+ * never writes excludes). Reproduces an active cooldown policy off the registry
+ * so the probe's pick matches what a real install would accept. Degrades to the
+ * raw latest-in-range when there is no policy to reproduce (inactive) or it
+ * cannot be reasoned about (ambiguous) - the same read-only answer the real
+ * resolution would refine via a package-manager install.
+ */
+async function resolveProbe(packageName, version) {
+    const result = await getPolicy();
+    if (result.outcome !== 'active') {
+        return (0, package_manager_1.resolvePackageVersionUsingRegistry)(packageName, version);
+    }
+    return resolveWithPolicy(packageName, version, result.policy, false);
+}
+async function resolveWithPolicy(packageName, version, policy, applySideEffects) {
+    try {
+        const spec = (0, catalog_1.resolveCatalogReferenceIfNeeded)(packageName, version);
+        const outcome = await (0, resolve_1.resolveCompliantVersion)(packageName, spec, policy);
+        if (applySideEffects && outcome.version !== outcome.unconstrained) {
+            reportChangedOutcome(packageName, spec, outcome.version, outcome.unconstrained, policy);
+        }
+        // An immature loose pick is returned as-is. nx does not write the
+        // minimumReleaseAgeExclude entry here: migrate does not replace the install,
+        // so the real `pnpm install` (>=11.1.3) auto-writes it itself.
+        return outcome.version;
+    }
+    catch (e) {
+        // A side-effect-free probe never installs/prompts/writes, so any failure -
+        // a violation or an unknown error - just means the version is unavailable.
+        if (!applySideEffects) {
+            throw e;
+        }
+        if (e instanceof errors_1.MinReleaseAgeViolationError) {
+            return handleViolation(packageName, e, policy);
+        }
+        // Unknown failure (registry hiccup, parse error): try a real install, but
+        // surface the original error if that also fails.
+        try {
+            return await (0, package_manager_1.resolvePackageVersionUsingInstallation)(packageName, version);
+        }
+        catch {
+            throw e;
+        }
+    }
+}
+function reportChangedOutcome(packageName, spec, picked, unconstrained, policy) {
+    const key = `${packageName}@${spec}`;
+    if (reportedChangedOutcomes.has(key)) {
+        return;
+    }
+    reportedChangedOutcomes.add(key);
+    output_1.output.log({
+        title: `Resolved ${packageName}@${picked} instead of ${unconstrained}: ${policy.sourceDescription}.`,
+    });
+}
+async function handleViolation(packageName, error, policy) {
+    const isPnpmStrict = policy.behavior.packageManager === 'pnpm' &&
+        policy.behavior.strict &&
+        policy.behavior.writesExcludes;
+    if (!isPnpmStrict) {
+        throw error;
+    }
+    // An unknown tag yields a violation with no blocked candidates (nothing to
+    // approve); surface the original no-matching-version error rather than
+    // prompting over an empty list.
+    if (error.blocked.length === 0) {
+        throw error;
+    }
+    // pnpm gates its prompt on stdin (the surface enquirer reads); match that
+    // rather than stdout, which diverges when output is piped.
+    const canPrompt = !!process.stdin.isTTY && !(0, is_ci_1.isCI)();
+    if (!canPrompt) {
+        throw error;
+    }
+    // pnpm's loose resolver picks the lowest in-range version (a single exact/tag
+    // target otherwise); strict fails on exactly that pick. error.blocked is
+    // sorted newest-first, so the resolver's pick is the last entry. Mirror the
+    // loose path: prompt for, exclude, and return that one version.
+    const resolved = error.blocked[error.blocked.length - 1];
+    const blockedLine = `  ${packageName}@${resolved.version} (published ${formatPublishAge(resolved.publishedAt)})`;
+    // pnpm prompts once for the whole run; remember an approval for later picks.
+    if (!strictApprovalGranted) {
+        const { approved } = await (0, safe_prompt_1.migratePrompt)([
+            {
+                name: 'approved',
+                type: 'confirm',
+                initial: false,
+                message: `The following version does not meet the ${policy.sourceDescription} constraint:\n${blockedLine}\nInstall anyway and add it to minimumReleaseAgeExclude in pnpm-workspace.yaml?`,
+            },
+        ]);
+        if (!approved) {
+            // Deny must surface as a violation: migrate.ts only rethrows
+            // MinReleaseAgeViolationError, so a plain Error would silently fall back
+            // to a real PM install and defeat the deny gate. Shape it like pnpm's
+            // ERR_PNPM_MINIMUM_RELEASE_AGE_DENIED.
+            throw new errors_1.MinReleaseAgeViolationError({
+                packageManager: error.packageManager,
+                packageName: error.packageName,
+                spec: error.spec,
+                pmShapedDetail: 'Aborted: the immature versions were not approved.',
+                blocked: error.blocked,
+                remediation: [
+                    `Add ${packageName} (optionally with a version) to minimumReleaseAgeExclude in pnpm-workspace.yaml, or re-run without minimumReleaseAgeStrict to allow these versions.`,
+                ],
+            });
+        }
+        strictApprovalGranted = true;
+    }
+    (0, pnpm_exclude_writer_1.appendMinimumReleaseAgeExcludes)(workspace_root_1.workspaceRoot, [
+        `${packageName}@${resolved.version}`,
+    ]);
+    return resolved.version;
+}
+// Renders a registry ISO publish timestamp as a human age for the strict prompt
+// (e.g. "6 hours ago"), falling back to the raw value when it is not parseable.
+function formatPublishAge(publishedAt) {
+    const elapsedMs = Date.now() - Date.parse(publishedAt);
+    if (!Number.isFinite(elapsedMs) || elapsedMs < 0) {
+        return publishedAt;
+    }
+    const minutes = Math.floor(elapsedMs / 60_000);
+    if (minutes < 60) {
+        return `${minutes} minute${minutes === 1 ? '' : 's'} ago`;
+    }
+    const hours = Math.floor(elapsedMs / 3_600_000);
+    if (hours < 48) {
+        return `${hours} hour${hours === 1 ? '' : 's'} ago`;
+    }
+    const days = Math.floor(elapsedMs / 86_400_000);
+    return `${days} day${days === 1 ? '' : 's'} ago`;
+}

package/dist/src/command-line/migrate/run-migration-process.js

@@ -0,0 +1,109 @@
+const { runNxOrAngularMigration, ChangedDepInstaller } = require('./migrate');
+const { commitMigrationIfRequested } = require('./migrate-commits');
+const { execSync } = require('child_process');
+
+async function runMigrationProcess() {
+  const [
+    ,
+    ,
+    workspacePath,
+    migrationId,
+    migrationPackage,
+    migrationName,
+    migrationVersion,
+    createCommits,
+    commitPrefix,
+  ] = process.argv;
+
+  const migration = {
+    id: migrationId,
+    package: migrationPackage,
+    name: migrationName,
+    version: migrationVersion,
+  };
+
+  const configuration = {
+    createCommits: createCommits === 'true',
+    commitPrefix: commitPrefix || 'chore: [nx migration] ',
+  };
+
+  try {
+    const gitRefBefore = execSync('git rev-parse HEAD', {
+      cwd: workspacePath,
+      encoding: 'utf-8',
+      windowsHide: true,
+    }).trim();
+
+    // Snapshot package.json deps now so we can detect post-migration drift
+    // and run a single install, whether commits are on or off.
+    const installer = new ChangedDepInstaller(workspacePath);
+    const installDepsIfChanged = () => installer.installDepsIfChanged();
+
+    const { changes: fileChanges, nextSteps } = await runNxOrAngularMigration(
+      workspacePath,
+      migration,
+      false
+    );
+
+    if (configuration.createCommits) {
+      const commitResult = await commitMigrationIfRequested(
+        workspacePath,
+        migration,
+        true,
+        configuration.commitPrefix,
+        installDepsIfChanged
+      );
+      if (commitResult.status === 'failed') {
+        // Single-migration UI child surfaces the failure via stdout (logged
+        // inside commitMigrationIfRequested) and continues with success-
+        // with-warning. The executor's absorption flow does not apply here:
+        // there is no later migration that could pick up this migration's
+        // diff, so the working tree is left in its post-migration state
+        // for the user to commit or revert through the UI.
+      }
+    } else {
+      await installDepsIfChanged();
+    }
+
+    const gitRefAfter = execSync('git rev-parse HEAD', {
+      cwd: workspacePath,
+      encoding: 'utf-8',
+      windowsHide: true,
+    }).trim();
+
+    // Report success
+    process.stdout.write(
+      JSON.stringify({
+        type: 'success',
+        fileChanges: fileChanges.map((change) => ({
+          path: change.path,
+          type: change.type,
+        })),
+        gitRefAfter,
+        nextSteps,
+      })
+    );
+
+    process.exit(0);
+  } catch (error) {
+    // Report failure
+    process.stdout.write(
+      JSON.stringify({
+        type: 'error',
+        message: error.message,
+      })
+    );
+
+    process.exit(1);
+  }
+}
+
+runMigrationProcess().catch((error) => {
+  process.stdout.write(
+    JSON.stringify({
+      type: 'error',
+      message: error.message,
+    })
+  );
+  process.exit(1);
+});

package/dist/src/command-line/migrate/safe-prompt.d.ts

@@ -0,0 +1,33 @@
+import { prompt as enquirerPrompt } from 'enquirer';
+/**
+ * Whether `nx migrate` may show interactive prompts: requires a TTY on stdin,
+ * not running in CI, and the user not having passed `--no-interactive`.
+ */
+export declare function canPrompt(interactive: boolean | undefined): boolean;
+/**
+ * Drop-in replacement for enquirer's `prompt()` that hardens cancel
+ * handling for every interactive prompt under `nx migrate`.
+ *
+ * Why: enquirer's built-in cancel path (`Prompt.cancel` → `close` →
+ * `keypress.js` `off` → `readline.pause`) races on `Interface.pause()`
+ * when triggered more than once in quick succession (mashed Ctrl+C),
+ * throwing `ERR_USE_AFTER_CLOSE` from an unhandled async chain that
+ * `await prompt(...)` cannot catch.
+ *
+ * In raw mode, Ctrl+C does NOT generate a SIGINT signal (the kernel's
+ * `ISIG` flag is cleared while enquirer's keypress listener is active);
+ * instead the 0x03 byte flows through `combos.js` and dispatches the
+ * `cancel` action. So a `process.on('SIGINT', ...)` handler is the wrong
+ * mechanism here — it never fires.
+ *
+ * The right hook is enquirer's per-prompt `options.cancel` override. When
+ * present, `Prompt.keypress` (lib/prompt.js:42) calls our handler INSTEAD
+ * of `this.cancel`, so enquirer's broken cleanup never runs. Both Ctrl+C
+ * (byte 0x03) and Esc map to the `cancel` action, so this single override
+ * covers both paths.
+ *
+ * The handler emits a single-line notice via `output.warn` and exits with
+ * POSIX status 130 (128 + SIGINT). Synchronous exit is correct here: the
+ * user explicitly asked to abort, there's no recovery state to preserve.
+ */
+export declare function migratePrompt<T = any>(questions: Parameters<typeof enquirerPrompt>[0]): Promise<T>;

package/dist/src/command-line/migrate/safe-prompt.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canPrompt = canPrompt;
+exports.migratePrompt = migratePrompt;
+const enquirer_1 = require("enquirer");
+const is_ci_1 = require("../../utils/is-ci");
+const output_1 = require("../../utils/output");
+/**
+ * Whether `nx migrate` may show interactive prompts: requires a TTY on stdin,
+ * not running in CI, and the user not having passed `--no-interactive`.
+ */
+function canPrompt(interactive) {
+    return !!process.stdin.isTTY && !(0, is_ci_1.isCI)() && interactive !== false;
+}
+/**
+ * Drop-in replacement for enquirer's `prompt()` that hardens cancel
+ * handling for every interactive prompt under `nx migrate`.
+ *
+ * Why: enquirer's built-in cancel path (`Prompt.cancel` → `close` →
+ * `keypress.js` `off` → `readline.pause`) races on `Interface.pause()`
+ * when triggered more than once in quick succession (mashed Ctrl+C),
+ * throwing `ERR_USE_AFTER_CLOSE` from an unhandled async chain that
+ * `await prompt(...)` cannot catch.
+ *
+ * In raw mode, Ctrl+C does NOT generate a SIGINT signal (the kernel's
+ * `ISIG` flag is cleared while enquirer's keypress listener is active);
+ * instead the 0x03 byte flows through `combos.js` and dispatches the
+ * `cancel` action. So a `process.on('SIGINT', ...)` handler is the wrong
+ * mechanism here — it never fires.
+ *
+ * The right hook is enquirer's per-prompt `options.cancel` override. When
+ * present, `Prompt.keypress` (lib/prompt.js:42) calls our handler INSTEAD
+ * of `this.cancel`, so enquirer's broken cleanup never runs. Both Ctrl+C
+ * (byte 0x03) and Esc map to the `cancel` action, so this single override
+ * covers both paths.
+ *
+ * The handler emits a single-line notice via `output.warn` and exits with
+ * POSIX status 130 (128 + SIGINT). Synchronous exit is correct here: the
+ * user explicitly asked to abort, there's no recovery state to preserve.
+ */
+async function migratePrompt(questions) {
+    const cancel = () => {
+        // `\n\r` → next line at column 0 (enquirer left the TTY in raw mode,
+        //   so a bare LF would not carry an implicit CR).
+        // `\x1B[J` → clear from cursor to end of screen. Wipes enquirer's
+        //   leftover choice / input rendering below the row where we'll
+        //   write our message so the exit output isn't shadowed by orphaned
+        //   prompt fragments.
+        process.stdout.write('\n\r\x1B[J');
+        output_1.output.warn({ title: 'nx migrate interrupted by user.' });
+        process.exit(130);
+    };
+    const withCancel = (q) => ({ ...q, cancel });
+    const injected = Array.isArray(questions)
+        ? questions.map(withCancel)
+        : withCancel(questions);
+    return (await (0, enquirer_1.prompt)(injected));
+}

package/dist/src/command-line/migrate/update-filters.d.ts

@@ -0,0 +1,11 @@
+import type { PackageJsonUpdateForPackage as PackageUpdate } from '../../config/misc-interfaces';
+import type { PackageJson } from '../../utils/package-json';
+/**
+ * Drop entries from `packageUpdates` that would either downgrade the package
+ * (move resolved version backward) or rewrite a specifier that is already
+ * exactly pinned to the resolved version (a no-op write). Keep genuine
+ * upgrades and narrowing rewrites where the user's range covers a version
+ * lower than what's resolved (the migrator's traditional "lock to recommended
+ * exact pin" behavior).
+ */
+export declare function filterDowngradedUpdates(packageUpdates: Record<string, PackageUpdate>, packageJson: PackageJson | null, getInstalledVersion: (packageName: string) => string | null): Record<string, PackageUpdate>;

package/dist/src/command-line/migrate/update-filters.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterDowngradedUpdates = filterDowngradedUpdates;
+const semver_1 = require("semver");
+const version_utils_1 = require("./version-utils");
+/**
+ * Drop entries from `packageUpdates` that would either downgrade the package
+ * (move resolved version backward) or rewrite a specifier that is already
+ * exactly pinned to the resolved version (a no-op write). Keep genuine
+ * upgrades and narrowing rewrites where the user's range covers a version
+ * lower than what's resolved (the migrator's traditional "lock to recommended
+ * exact pin" behavior).
+ */
+function filterDowngradedUpdates(packageUpdates, packageJson, getInstalledVersion) {
+    const result = {};
+    for (const [name, update] of Object.entries(packageUpdates)) {
+        const resolved = getInstalledVersion(name);
+        if (!resolved) {
+            // Not installed; let downstream logic decide whether to add it.
+            result[name] = update;
+            continue;
+        }
+        const proposed = (0, version_utils_1.normalizeVersion)(update.version);
+        const resolvedNorm = (0, version_utils_1.normalizeVersion)(resolved);
+        if ((0, semver_1.gt)(proposed, resolvedNorm)) {
+            result[name] = update;
+            continue;
+        }
+        if ((0, semver_1.lt)(proposed, resolvedNorm)) {
+            continue;
+        }
+        // proposed === resolved: keep when narrowing a looser specifier to an
+        // exact pin; drop when the specifier is already exact at resolved.
+        const specifier = packageJson?.dependencies?.[name] ?? packageJson?.devDependencies?.[name];
+        if (!specifier) {
+            continue;
+        }
+        // Skip specifiers that aren't semver ranges (workspace:/npm:/git/file).
+        const floor = (0, semver_1.validRange)(specifier) ? (0, semver_1.minVersion)(specifier) : null;
+        if (floor && (0, semver_1.lt)(floor.version, resolvedNorm)) {
+            result[name] = update;
+        }
+    }
+    return result;
+}

package/dist/src/command-line/migrate/version-utils.d.ts

@@ -0,0 +1,5 @@
+export declare const DIST_TAGS: readonly ['latest', 'next', 'canary'];
+export type DistTag = (typeof DIST_TAGS)[number];
+export declare function isLegacyEra(targetVersion: string): boolean;
+export declare function normalizeVersion(version: string): string;
+export declare function normalizeVersionWithTagCheck(pkg: string, version: string): Promise<string>;

package/dist/src/command-line/migrate/version-utils.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DIST_TAGS = void 0;
+exports.isLegacyEra = isLegacyEra;
+exports.normalizeVersion = normalizeVersion;
+exports.normalizeVersionWithTagCheck = normalizeVersionWithTagCheck;
+const semver_1 = require("semver");
+const resolve_package_version_1 = require("./resolve-package-version");
+exports.DIST_TAGS = ['latest', 'next', 'canary'];
+const LEGACY_ERA_BOUNDARY = '14.0.0-beta.0';
+// Pre-14 (legacy) installs used `@nrwl/workspace` as the canonical Nx package.
+// Non-semver values (e.g. dist-tags or the literal `'latest'` sentinel before
+// tag resolution) are treated as modern era.
+function isLegacyEra(targetVersion) {
+    return (0, semver_1.valid)(targetVersion) && (0, semver_1.lt)(targetVersion, LEGACY_ERA_BOUNDARY);
+}
+function normalizeVersion(version) {
+    const [semver, ...prereleaseTagParts] = version.split('-');
+    // Handle versions like 1.0.0-beta-next.2
+    const prereleaseTag = prereleaseTagParts.join('-');
+    const [major, minor, patch] = semver.split('.');
+    const newSemver = `${major || 0}.${minor || 0}.${patch || 0}`;
+    const newVersion = prereleaseTag
+        ? `${newSemver}-${prereleaseTag}`
+        : newSemver;
+    const withoutPatch = `${major || 0}.${minor || 0}.0`;
+    const withoutPatchAndMinor = `${major || 0}.0.0`;
+    const variationsToCheck = [
+        newVersion,
+        newSemver,
+        withoutPatch,
+        withoutPatchAndMinor,
+    ];
+    for (const variation of variationsToCheck) {
+        try {
+            if ((0, semver_1.gt)(variation, '0.0.0')) {
+                return variation;
+            }
+        }
+        catch { }
+    }
+    return '0.0.0';
+}
+async function normalizeVersionWithTagCheck(pkg, version) {
+    // Treat non-parseable inputs (e.g. dist-tags like `latest`/`next`) as
+    // registry references and resolve them. Throws on registry failure;
+    // callers that need to tolerate registry outages must wrap.
+    if (version && !(0, semver_1.parse)(version)) {
+        return (0, resolve_package_version_1.resolvePackageVersionRespectingMinReleaseAge)(pkg, version);
+    }
+    return normalizeVersion(version);
+}

package/dist/src/command-line/new/command-object.d.ts

@@ -0,0 +1,2 @@
+import { CommandModule } from 'yargs';
+export declare const yargsNewCommand: CommandModule;

package/dist/src/command-line/new/command-object.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsNewCommand = void 0;
+const handle_import_1 = require("../../utils/handle-import");
+exports.yargsNewCommand = {
+    command: 'new [_..]',
+    describe: false,
+    builder: (yargs) => withNewOptions(yargs),
+    handler: async (args) => {
+        args._ = args._.slice(1);
+        process.exit(await (await (0, handle_import_1.handleImport)('./new.js', __dirname)).newWorkspace(args['nxWorkspaceRoot'], args));
+    },
+};
+function withNewOptions(yargs) {
+    return yargs
+        .option('nxWorkspaceRoot', {
+        describe: 'The folder where the new workspace is going to be created.',
+        type: 'string',
+        required: true,
+    })
+        .option('interactive', {
+        describe: 'When false disables interactive input prompts for options.',
+        type: 'boolean',
+        default: true,
+    });
+}

package/dist/src/command-line/new/new.d.ts

@@ -0,0 +1,3 @@
+export declare function newWorkspace(cwd: string, args: {
+    [k: string]: any;
+}): Promise<number>;

package/dist/src/command-line/nx-cloud/apply-locally/apply-locally.d.ts

@@ -0,0 +1,4 @@
+export interface ApplyLocallyArgs {
+    verbose?: boolean;
+}
+export declare function applyLocallyHandler(args: ApplyLocallyArgs): Promise<number>;

package/dist/src/command-line/nx-cloud/apply-locally/command-object.d.ts

@@ -0,0 +1,2 @@
+import { CommandModule } from 'yargs';
+export declare const yargsApplyLocallyCommand: CommandModule;

package/dist/src/command-line/nx-cloud/apply-locally/command-object.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsApplyLocallyCommand = void 0;
+const shared_options_1 = require("../../yargs-utils/shared-options");
+const handle_import_1 = require("../../../utils/handle-import");
+exports.yargsApplyLocallyCommand = {
+    command: 'apply-locally [options]',
+    describe: 'Applies a self-healing CI fix locally. This command is an alias for `nx-cloud apply-locally`.',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs)
+        .help(false)
+        .showHelpOnFail(false)
+        .option('help', { describe: 'Show help.', type: 'boolean' }),
+    handler: async (args) => {
+        process.exit(await (await (0, handle_import_1.handleImport)('./apply-locally.js', __dirname)).applyLocallyHandler(args));
+    },
+};

package/dist/src/command-line/nx-cloud/complete-run/command-object.d.ts

@@ -0,0 +1,2 @@
+import { CommandModule } from 'yargs';
+export declare const yargsStopAllAgentsCommand: CommandModule;

package/dist/src/command-line/nx-cloud/complete-run/command-object.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsStopAllAgentsCommand = void 0;
+const handle_import_1 = require("../../../utils/handle-import");
+const shared_options_1 = require("../../yargs-utils/shared-options");
+exports.yargsStopAllAgentsCommand = {
+    command: 'stop-all-agents [options]',
+    aliases: ['complete-ci-run'],
+    describe: 'Terminates all dedicated agents associated with this CI pipeline execution. This command is an alias for [`nx-cloud stop-all-agents`](/docs/reference/nx-cloud-cli#nx-cloud-stop-all-agents).',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs)
+        .help(false)
+        .showHelpOnFail(false)
+        .option('help', { describe: 'Show help.', type: 'boolean' }),
+    handler: async (args) => {
+        process.exit(await (await (0, handle_import_1.handleImport)('./stop-all-agents.js', __dirname)).stopAllAgentsHandler(args));
+    },
+};

package/dist/src/command-line/nx-cloud/complete-run/stop-all-agents.d.ts

@@ -0,0 +1,4 @@
+export interface StopAllAgentsArgs {
+    verbose?: boolean;
+}
+export declare function stopAllAgentsHandler(args: StopAllAgentsArgs): Promise<number>;

package/dist/src/command-line/nx-cloud/connect/command-object.d.ts

@@ -0,0 +1,3 @@
+import { CommandModule } from 'yargs';
+export declare const yargsConnectCommand: CommandModule;
+export declare const yargsViewLogsCommand: CommandModule;