nx 20.8.4 → 22.7.7

package/dist/src/tasks-runner/utils.js

@@ -0,0 +1,450 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDependencyConfigs = getDependencyConfigs;
+exports.normalizeDependencyConfigDefinition = normalizeDependencyConfigDefinition;
+exports.normalizeDependencyConfigProjects = normalizeDependencyConfigProjects;
+exports.expandDependencyConfigSyntaxSugar = expandDependencyConfigSyntaxSugar;
+exports.expandWildcardTargetConfiguration = expandWildcardTargetConfiguration;
+exports.readProjectAndTargetFromTargetString = readProjectAndTargetFromTargetString;
+exports.getOutputs = getOutputs;
+exports.normalizeTargetDependencyWithStringProjects = normalizeTargetDependencyWithStringProjects;
+exports.validateOutputs = validateOutputs;
+exports.transformLegacyOutputs = transformLegacyOutputs;
+exports.getOutputsForTargetAndConfiguration = getOutputsForTargetAndConfiguration;
+exports.interpolate = interpolate;
+exports.getTargetConfigurationForTask = getTargetConfigurationForTask;
+exports.getExecutorNameForTask = getExecutorNameForTask;
+exports.expandInitiatingTasksThroughNoop = expandInitiatingTasksThroughNoop;
+exports.getExecutorForTask = getExecutorForTask;
+exports.getCustomHasher = getCustomHasher;
+exports.removeTasksFromTaskGraph = removeTasksFromTaskGraph;
+exports.calculateReverseDeps = calculateReverseDeps;
+exports.getCliPath = getCliPath;
+exports.getPrintableCommandArgsForTask = getPrintableCommandArgsForTask;
+exports.getSerializedArgsForTask = getSerializedArgsForTask;
+exports.shouldStreamOutput = shouldStreamOutput;
+exports.isCacheableTask = isCacheableTask;
+exports.unparse = unparse;
+exports.createTaskId = createTaskId;
+const minimatch_1 = require("minimatch");
+const node_path_1 = require("node:path");
+const posix_1 = require("node:path/posix");
+const executor_utils_1 = require("../command-line/run/executor-utils");
+const native_1 = require("../native");
+const fileutils_1 = require("../utils/fileutils");
+const find_matching_projects_1 = require("../utils/find-matching-projects");
+const globs_1 = require("../utils/globs");
+const path_1 = require("../utils/path");
+const serialize_overrides_into_command_line_1 = require("../utils/serialize-overrides-into-command-line");
+const split_target_1 = require("../utils/split-target");
+const workspace_root_1 = require("../utils/workspace-root");
+const is_tui_enabled_1 = require("./is-tui-enabled");
+function getDependencyConfigs({ project, target }, extraTargetDependencies, projectGraph, allTargetNames) {
+    const dependencyConfigs = (projectGraph.nodes[project].data?.targets[target]?.dependsOn ??
+        // This is passed into `run-command` from programmatic invocations
+        extraTargetDependencies[target] ??
+        []).flatMap((config) => normalizeDependencyConfigDefinition(config, project, projectGraph, allTargetNames));
+    return dependencyConfigs;
+}
+function normalizeDependencyConfigDefinition(definition, currentProject, graph, allTargetNames) {
+    return expandWildcardTargetConfiguration(normalizeDependencyConfigProjects(expandDependencyConfigSyntaxSugar(definition, graph, currentProject), currentProject, graph), allTargetNames);
+}
+function normalizeDependencyConfigProjects(dependencyConfig, currentProject, graph) {
+    const noStringConfig = normalizeTargetDependencyWithStringProjects(dependencyConfig);
+    if (noStringConfig.projects) {
+        dependencyConfig.projects = (0, find_matching_projects_1.findMatchingProjects)(noStringConfig.projects, graph.nodes);
+    }
+    else if (!noStringConfig.dependencies) {
+        dependencyConfig.projects = [currentProject];
+    }
+    return dependencyConfig;
+}
+function expandDependencyConfigSyntaxSugar(dependencyConfigString, graph, currentProject) {
+    if (typeof dependencyConfigString !== 'string') {
+        return dependencyConfigString;
+    }
+    const [dependencies, targetString] = dependencyConfigString.startsWith('^')
+        ? [true, dependencyConfigString.substring(1)]
+        : [false, dependencyConfigString];
+    // Support for `project:target` syntax doesn't make sense for
+    // dependencies, so we only support `target` syntax for dependencies.
+    if (dependencies) {
+        return {
+            target: targetString,
+            dependencies: true,
+        };
+    }
+    const { projects, target } = readProjectAndTargetFromTargetString(targetString, graph.nodes, currentProject);
+    return projects ? { projects, target } : { target };
+}
+// Weakmap let's the cache get cleared by garbage collector if allTargetNames is no longer used
+const patternResultCache = new WeakMap();
+function findMatchingTargets(pattern, allTargetNames) {
+    let cache = patternResultCache.get(allTargetNames);
+    if (!cache) {
+        cache = new Map();
+        patternResultCache.set(allTargetNames, cache);
+    }
+    const cachedResult = cache.get(pattern);
+    if (cachedResult) {
+        return cachedResult;
+    }
+    const matcher = minimatch_1.minimatch.filter(pattern);
+    const matchingTargets = allTargetNames.filter((t) => matcher(t));
+    cache.set(pattern, matchingTargets);
+    return matchingTargets;
+}
+function expandWildcardTargetConfiguration(dependencyConfig, allTargetNames) {
+    if (!(0, globs_1.isGlobPattern)(dependencyConfig.target)) {
+        return [dependencyConfig];
+    }
+    const matchingTargets = findMatchingTargets(dependencyConfig.target, allTargetNames);
+    return matchingTargets.map((t) => ({
+        ...dependencyConfig,
+        target: t,
+    }));
+}
+function readProjectAndTargetFromTargetString(targetString, projects, currentProject) {
+    // Support for both `project:target` and `target:with:colons` syntax
+    const [maybeProject, ...segments] = (0, split_target_1.splitTargetFromNodes)(targetString, projects, { silent: true, currentProject });
+    if (!segments.length) {
+        // if no additional segments are provided, then the string references
+        // a target of the same project
+        return { target: maybeProject };
+    }
+    else if (maybeProject in projects) {
+        // Only the first segment could be a project. If it is, the rest is a target.
+        // If its not, then the whole targetString was a target with colons in its name.
+        return { projects: [maybeProject], target: segments.join(':') };
+    }
+    else {
+        // If the first segment is a project, then we have a specific project. Otherwise, we don't.
+        return { target: targetString };
+    }
+}
+function getOutputs(p, target, overrides) {
+    return getOutputsForTargetAndConfiguration(target, overrides, p[target.project]);
+}
+function normalizeTargetDependencyWithStringProjects(dependencyConfig) {
+    if (typeof dependencyConfig.projects === 'string') {
+        /** LERNA SUPPORT START - Remove in v20 */
+        // Lerna uses `dependencies` in `prepNxOptions`, so we need to maintain
+        // support for it until lerna can be updated to use the syntax.
+        //
+        // This should have been removed in v17, but the updates to lerna had not
+        // been made yet.
+        //
+        // TODO(@agentender): Remove this part in v20
+        if (dependencyConfig.projects === 'self') {
+            delete dependencyConfig.projects;
+        }
+        else if (dependencyConfig.projects === 'dependencies') {
+            dependencyConfig.dependencies = true;
+            delete dependencyConfig.projects;
+            /** LERNA SUPPORT END - Remove in v20 */
+        }
+        else {
+            dependencyConfig.projects = [dependencyConfig.projects];
+        }
+    }
+    return dependencyConfig;
+}
+class InvalidOutputsError extends Error {
+    constructor(outputs, invalidOutputs) {
+        super(InvalidOutputsError.createMessage(invalidOutputs));
+        this.outputs = outputs;
+        this.invalidOutputs = invalidOutputs;
+    }
+    static createMessage(invalidOutputs) {
+        const invalidOutputsList = '\n - ' + Array.from(invalidOutputs).join('\n - ');
+        return `The following outputs are invalid:${invalidOutputsList}\nPlease run "nx repair" to repair your configuration`;
+    }
+}
+function assertOutputsAreValidType(outputs) {
+    if (!Array.isArray(outputs)) {
+        throw new Error("The 'outputs' field must be an array");
+    }
+    const typesArray = [];
+    let hasInvalidType = false;
+    for (const output of outputs) {
+        if (typeof output !== 'string') {
+            hasInvalidType = true;
+        }
+        typesArray.push(typeof output);
+    }
+    if (hasInvalidType) {
+        throw new Error(`The 'outputs' field must contain only strings, but received types: [${typesArray.join(', ')}]`);
+    }
+}
+function validateOutputs(outputs) {
+    assertOutputsAreValidType(outputs);
+    (0, native_1.validateOutputs)(outputs);
+}
+function transformLegacyOutputs(projectRoot, outputs) {
+    const transformableOutputs = new Set((0, native_1.getTransformableOutputs)(outputs));
+    if (transformableOutputs.size === 0) {
+        return outputs;
+    }
+    return outputs.map((output) => {
+        if (!transformableOutputs.has(output)) {
+            return output;
+        }
+        let [isNegated, outputPath] = output.startsWith('!')
+            ? [true, output.substring(1)]
+            : [false, output];
+        const relativePath = (0, fileutils_1.isRelativePath)(outputPath)
+            ? output
+            : (0, node_path_1.relative)(projectRoot, outputPath);
+        const isWithinProject = !relativePath.startsWith('..');
+        return ((isNegated ? '!' : '') +
+            (0, path_1.joinPathFragments)(isWithinProject ? '{projectRoot}' : '{workspaceRoot}', isWithinProject ? relativePath : outputPath));
+    });
+}
+/**
+ * Returns the list of outputs that will be cached.
+ */
+function getOutputsForTargetAndConfiguration(taskTargetOrTask, overridesOrNode, node) {
+    const taskTarget = 'id' in taskTargetOrTask ? taskTargetOrTask.target : taskTargetOrTask;
+    const overrides = 'id' in taskTargetOrTask ? taskTargetOrTask.overrides : overridesOrNode;
+    node = 'id' in taskTargetOrTask ? overridesOrNode : node;
+    const { target, configuration } = taskTarget;
+    const targetConfiguration = node.data.targets[target];
+    const options = {
+        ...targetConfiguration?.options,
+        ...targetConfiguration?.configurations?.[configuration],
+        ...overrides,
+    };
+    if (targetConfiguration?.outputs) {
+        validateOutputs(targetConfiguration.outputs);
+        const result = new Set();
+        for (const output of targetConfiguration.outputs) {
+            const interpolatedOutput = interpolate(output, {
+                projectRoot: node.data.root,
+                projectName: node.name,
+                project: { ...node.data, name: node.name }, // this is legacy
+                options,
+            });
+            if (!!interpolatedOutput &&
+                !interpolatedOutput.match(/{(projectRoot|workspaceRoot|(options.*))}/)) {
+                result.add(interpolatedOutput);
+            }
+        }
+        return Array.from(result);
+    }
+    // Keep backwards compatibility in case `outputs` doesn't exist
+    if (options.outputPath) {
+        return Array.isArray(options.outputPath)
+            ? options.outputPath
+            : [options.outputPath];
+    }
+    else if (target === 'build' || target === 'prepare') {
+        return [
+            `dist/${node.data.root}`,
+            `${node.data.root}/dist`,
+            `${node.data.root}/build`,
+            `${node.data.root}/public`,
+        ];
+    }
+    else {
+        return [];
+    }
+}
+/**
+ * Matches portions of a string which need to be interpolated.
+ * Matches anything within curly braces, excluding the braces.
+ */
+const replacementRegex = /{([\s\S]+?)}/g;
+function interpolate(template, data) {
+    // Path is absolute or doesn't need interpolation
+    if (template.startsWith('/') || !replacementRegex.test(template)) {
+        return template;
+    }
+    if (template.includes('{workspaceRoot}', 1)) {
+        throw new Error(`Output '${template}' is invalid. {workspaceRoot} can only be used at the beginning of the expression.`);
+    }
+    if (data.projectRoot == '.' && template.includes('{projectRoot}', 1)) {
+        throw new Error(`Output '${template}' is invalid. When {projectRoot} is '.', it can only be used at the beginning of the expression.`);
+    }
+    const parts = template.split('/').map((s) => _interpolate(s, data));
+    return (0, posix_1.join)(...parts).replace('{workspaceRoot}/', '');
+}
+function _interpolate(template, data) {
+    let res = template;
+    if (data.projectRoot == '.') {
+        res = res.replace('{projectRoot}', '');
+    }
+    return res.replace(replacementRegex, (match) => {
+        let value = data;
+        let path = match.slice(1, -1).trim().split('.');
+        for (let idx = 0; idx < path.length; idx++) {
+            if (!value[path[idx]]) {
+                return match;
+            }
+            value = value[path[idx]];
+        }
+        return value;
+    });
+}
+function getTargetConfigurationForTask(task, projectGraph) {
+    const project = projectGraph.nodes[task.target.project].data;
+    return project.targets[task.target.target];
+}
+function getExecutorNameForTask(task, projectGraph) {
+    return getTargetConfigurationForTask(task, projectGraph)?.executor;
+}
+/**
+ * Expand a set of initiating task IDs by walking through any `nx:noop` tasks
+ * and replacing them with their direct dependencies + continuous dependencies.
+ * Non-noop tasks are kept as-is; cycles are safe.
+ *
+ * An `nx:noop` executor returns immediately, so if it is the only thing
+ * anchoring a continuous child, the child gets killed by
+ * `cleanUpUnneededContinuousTasks` the moment the noop completes. Treating the
+ * noop's dependencies as the real anchors preserves the intended orchestration.
+ */
+function expandInitiatingTasksThroughNoop(initiatingTasks, taskGraph, projectGraph) {
+    const expanded = new Set();
+    const visited = new Set();
+    const queue = initiatingTasks.map((t) => t.id);
+    while (queue.length > 0) {
+        const taskId = queue.shift();
+        if (visited.has(taskId))
+            continue;
+        visited.add(taskId);
+        const task = taskGraph.tasks[taskId];
+        if (!task)
+            continue;
+        if (getExecutorNameForTask(task, projectGraph) === 'nx:noop') {
+            for (const dep of taskGraph.dependencies[taskId] ?? []) {
+                queue.push(dep);
+            }
+            for (const dep of taskGraph.continuousDependencies[taskId] ?? []) {
+                queue.push(dep);
+            }
+        }
+        else {
+            expanded.add(taskId);
+        }
+    }
+    return expanded;
+}
+function getExecutorForTask(task, projects) {
+    const executor = projects[task.target.project]?.targets?.[task.target.target]?.executor;
+    const [nodeModule, executorName] = (0, executor_utils_1.parseExecutor)(executor);
+    return (0, executor_utils_1.getExecutorInformation)(nodeModule, executorName, workspace_root_1.workspaceRoot, projects);
+}
+function getCustomHasher(task, projects) {
+    const factory = getExecutorForTask(task, projects).hasherFactory;
+    return factory ? factory() : null;
+}
+function removeTasksFromTaskGraph(graph, ids) {
+    const newGraph = removeIdsFromTaskGraph(graph, ids, graph.tasks);
+    return {
+        dependencies: newGraph.dependencies,
+        continuousDependencies: newGraph.continuousDependencies,
+        roots: newGraph.roots,
+        tasks: newGraph.mapWithIds,
+    };
+}
+function removeIdsFromTaskGraph(graph, ids, mapWithIds) {
+    const filteredMapWithIds = {};
+    const dependencies = {};
+    const continuousDependencies = {};
+    const removedSet = new Set(ids);
+    for (let id of Object.keys(mapWithIds)) {
+        if (!removedSet.has(id)) {
+            filteredMapWithIds[id] = mapWithIds[id];
+            dependencies[id] = graph.dependencies[id].filter((depId) => !removedSet.has(depId));
+            continuousDependencies[id] = graph.continuousDependencies[id].filter((depId) => !removedSet.has(depId));
+        }
+    }
+    return {
+        mapWithIds: filteredMapWithIds,
+        dependencies: dependencies,
+        continuousDependencies,
+        roots: Object.keys(filteredMapWithIds).filter((k) => dependencies[k].length === 0 && continuousDependencies[k].length === 0),
+    };
+}
+function calculateReverseDeps(taskGraph) {
+    const reverseTaskDeps = {};
+    Object.keys(taskGraph.tasks).forEach((t) => {
+        reverseTaskDeps[t] = [];
+    });
+    Object.keys(taskGraph.dependencies).forEach((taskId) => {
+        taskGraph.dependencies[taskId].forEach((d) => {
+            reverseTaskDeps[d].push(taskId);
+        });
+    });
+    Object.keys(taskGraph.continuousDependencies).forEach((taskId) => {
+        taskGraph.continuousDependencies[taskId].forEach((d) => {
+            reverseTaskDeps[d].push(taskId);
+        });
+    });
+    return reverseTaskDeps;
+}
+function getCliPath() {
+    return require.resolve(`../../bin/run-executor.js`);
+}
+function getPrintableCommandArgsForTask(task) {
+    const args = task.overrides['__overrides_unparsed__'];
+    const target = task.target.target.includes(':')
+        ? `"${task.target.target}"`
+        : task.target.target;
+    const config = task.target.configuration
+        ? `:${task.target.configuration}`
+        : '';
+    return ['run', `${task.target.project}:${target}${config}`, ...args];
+}
+function getSerializedArgsForTask(task, isVerbose) {
+    return [
+        JSON.stringify({
+            targetDescription: task.target,
+            overrides: task.overrides,
+            isVerbose: isVerbose,
+        }),
+    ];
+}
+function shouldStreamOutput(task, initiatingProject) {
+    // For now, disable streaming output on the JS side when running the TUI
+    if ((0, is_tui_enabled_1.isTuiEnabled)())
+        return false;
+    if (process.env.NX_STREAM_OUTPUT === 'true')
+        return true;
+    if (process.env.NX_STREAM_OUTPUT === 'false')
+        return false;
+    if (longRunningTask(task))
+        return true;
+    if (task.target.project === initiatingProject)
+        return true;
+    return false;
+}
+function isCacheableTask(task, options) {
+    if (task.cache !== undefined) {
+        return task.cache;
+    }
+    const cacheable = options.cacheableOperations || options.cacheableTargets;
+    return (cacheable &&
+        cacheable.indexOf(task.target.target) > -1 &&
+        !longRunningTask(task));
+}
+function longRunningTask(task) {
+    const t = task.target.target;
+    return (task.continuous ||
+        (!!task.overrides['watch'] && task.overrides['watch'] !== 'false') ||
+        t.endsWith(':watch') ||
+        t.endsWith('-watch') ||
+        t === 'serve' ||
+        t === 'dev' ||
+        t === 'start');
+}
+// TODO: vsavkin remove when nx-cloud doesn't depend on it
+function unparse(options) {
+    return (0, serialize_overrides_into_command_line_1.serializeOverridesIntoCommandLine)(options);
+}
+function createTaskId(project, target, configuration) {
+    let id = `${project}:${target}`;
+    if (configuration) {
+        id += `:${configuration}`;
+    }
+    return id;
+}

package/dist/src/utils/ab-testing.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Meta payload types for recordStat telemetry (matches CNW format).
+ */
+export interface RecordStatMetaStart {
+    type: 'start';
+    [key: string]: string | boolean;
+}
+export interface RecordStatMetaComplete {
+    type: 'complete';
+    [key: string]: string | boolean;
+}
+export interface RecordStatMetaError {
+    type: 'error';
+    errorCode: string;
+    errorMessage: string;
+    [key: string]: string | boolean;
+}
+export type RecordStatMeta = RecordStatMetaStart | RecordStatMetaComplete | RecordStatMetaError;
+export type MessageOptionKey = 'yes' | 'skip' | 'never';
+interface MessageData {
+    code: string;
+    message: string;
+    initial: number;
+    choices: Array<{
+        value: string;
+        name: string;
+        hint?: string;
+    }>;
+    footer: string;
+    hint?: string;
+}
+declare const messageOptions: Record<string, MessageData[]>;
+export type MessageKey = keyof typeof messageOptions;
+export declare class PromptMessages {
+    private selectedMessages;
+    getPrompt(key: MessageKey): MessageData;
+    codeOfSelectedPromptMessage(key: string): string;
+}
+export declare const messages: PromptMessages;
+/**
+ * We are incrementing a counter to track how often create-nx-workspace is used in CI
+ * vs dev environments. No personal information is collected.
+ */
+export declare function recordStat(opts: {
+    command: string;
+    nxVersion: string;
+    useCloud: boolean;
+    meta?: RecordStatMeta;
+}): Promise<void>;
+export {};

package/dist/src/utils/ab-testing.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messages = exports.PromptMessages = void 0;
+exports.recordStat = recordStat;
+const tslib_1 = require("tslib");
+const node_child_process_1 = require("node:child_process");
+const is_ci_1 = require("./is-ci");
+const package_manager_1 = require("./package-manager");
+const get_cloud_options_1 = require("../nx-cloud/utilities/get-cloud-options");
+const pc = tslib_1.__importStar(require("picocolors"));
+const messageOptions = {
+    setupNxCloud: [
+        {
+            code: 'cloud-ci-providers-speed',
+            message: 'Speed up GitHub Actions, GitLab CI, and more with Nx Cloud?',
+            initial: 0,
+            choices: [
+                { value: 'yes', name: 'Yes' },
+                { value: 'skip', name: 'Skip for now' },
+                { value: 'never', name: pc.dim("No, don't ask again") },
+            ],
+            footer: '\nFree for small teams. Remote caching and task distribution. 2-minute setup: https://nx.dev/nx-cloud',
+        },
+        {
+            code: 'cloud-self-healing-remote-cache',
+            message: `Would you like to enable AI-powered Self-Healing CI and Remote Caching?`,
+            initial: 0,
+            choices: [
+                { value: 'yes', name: 'Yes' },
+                { value: 'skip', name: 'Skip for now' },
+                { value: 'never', name: pc.dim("No, don't ask again") },
+            ],
+            footer: '\nLearn about it at https://nx.dev/nx-cloud',
+            hint: `\n(it's free and can be disabled any time)`,
+        },
+    ],
+    setupViewLogs: [
+        {
+            code: 'connect-to-view-logs',
+            message: `To view the logs, Nx needs to connect your workspace to Nx Cloud and upload the most recent run details`,
+            initial: 0,
+            choices: [
+                {
+                    value: 'yes',
+                    name: 'Yes',
+                    hint: 'Connect to Nx Cloud and upload the run details',
+                },
+                { value: 'skip', name: 'No' },
+            ],
+            footer: '\nRead more about Nx Cloud at https://nx.dev/nx-cloud',
+            hint: `\n(it's free and can be disabled any time)`,
+        },
+    ],
+};
+class PromptMessages {
+    constructor() {
+        this.selectedMessages = {};
+    }
+    getPrompt(key) {
+        if (this.selectedMessages[key] === undefined) {
+            if (process.env.NX_GENERATE_DOCS_PROCESS === 'true') {
+                this.selectedMessages[key] = 0;
+            }
+            else {
+                this.selectedMessages[key] = Math.floor(Math.random() * messageOptions[key].length);
+            }
+        }
+        return messageOptions[key][this.selectedMessages[key]];
+    }
+    codeOfSelectedPromptMessage(key) {
+        if (this.selectedMessages[key] === undefined)
+            return null;
+        return messageOptions[key][this.selectedMessages[key]].code;
+    }
+}
+exports.PromptMessages = PromptMessages;
+exports.messages = new PromptMessages();
+/**
+ * We are incrementing a counter to track how often create-nx-workspace is used in CI
+ * vs dev environments. No personal information is collected.
+ */
+async function recordStat(opts) {
+    try {
+        if (!shouldRecordStats()) {
+            return;
+        }
+        const axios = require('axios');
+        await (axios['default'] ?? axios)
+            .create({
+            baseURL: (0, get_cloud_options_1.getCloudUrl)(),
+            timeout: 400,
+        })
+            .post('/nx-cloud/stats', {
+            command: opts.command,
+            isCI: (0, is_ci_1.isCI)(),
+            useCloud: opts.useCloud,
+            meta: opts.meta
+                ? JSON.stringify({ ...opts.meta, nxVersion: opts.nxVersion })
+                : opts.nxVersion,
+        });
+    }
+    catch (e) {
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            console.error(e);
+        }
+    }
+}
+function shouldRecordStats() {
+    const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    if (!pmc.getRegistryUrl) {
+        // Fallback on true as Package management doesn't support reading config for registry.
+        // currently Bun doesn't support fetching config settings https://github.com/oven-sh/bun/issues/7140
+        return true;
+    }
+    try {
+        const stdout = (0, node_child_process_1.execSync)(pmc.getRegistryUrl, {
+            encoding: 'utf-8',
+            windowsHide: true,
+        });
+        const url = new URL(stdout.trim());
+        // don't record stats when testing locally
+        return url.hostname !== 'localhost';
+    }
+    catch {
+        // fallback to true if we can't detect the registry
+        return true;
+    }
+}

package/dist/src/utils/analytics-prompt.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Prompts user for analytics preference if not already set in nx.json.
+ * Only prompts in interactive terminals, not in CI.
+ */
+export declare function ensureAnalyticsPreferenceSet(): Promise<void>;
+export declare function promptForAnalyticsPreference(): Promise<boolean>;
+/**
+ * Generates a deterministic workspace ID.
+ * Priority: nxCloudId > git remote URL (hashed).
+ * Returns null if neither is available (no telemetry).
+ */
+export declare function generateWorkspaceId(cwd?: string): string | null;