@ohos-ports/nx 23.2.1-beta.0 → 23.3.0-beta.0

package/dist/src/ai/utils.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentDisplayMap = exports.supportedAgents = void 0;
+exports.getAgentConfigurations = getAgentConfigurations;
+exports.configureAgents = configureAgents;
+exports.agentConfigWriteBlockedLines = agentConfigWriteBlockedLines;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const configuration_1 = require("../config/configuration");
+const tree_1 = require("../generators/tree");
+const native_1 = require("../native");
+const fileutils_1 = require("../utils/fileutils");
+const is_sandbox_1 = require("../utils/is-sandbox");
+const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
+const output_1 = require("../utils/output");
+const constants_1 = require("./constants");
+const set_up_ai_agents_1 = tslib_1.__importDefault(require("./set-up-ai-agents/set-up-ai-agents"));
+// when adding new agents, be sure to also update the list in
+// packages/create-nx-workspace/src/create-workspace-options.ts
+exports.supportedAgents = [
+    'claude',
+    'codex',
+    'copilot',
+    'cursor',
+    'gemini',
+    'opencode',
+];
+exports.agentDisplayMap = {
+    claude: 'Claude Code',
+    gemini: 'Gemini',
+    codex: 'OpenAI Codex',
+    copilot: 'GitHub Copilot for VSCode',
+    cursor: 'Cursor',
+    opencode: 'OpenCode',
+};
+async function getAgentConfigurations(agentsToConsider, workspaceRoot) {
+    const nonConfiguredAgents = [];
+    const partiallyConfiguredAgents = [];
+    const fullyConfiguredAgents = [];
+    const disabledAgents = [];
+    for (const agent of agentsToConsider) {
+        const configuration = await getAgentConfiguration(agent, workspaceRoot);
+        if (configuration.disabled) {
+            disabledAgents.push(configuration);
+            continue;
+        }
+        if (configuration.mcp && configuration.rules) {
+            fullyConfiguredAgents.push(configuration);
+        }
+        else if (!configuration.mcp && !configuration.rules) {
+            nonConfiguredAgents.push(configuration);
+        }
+        else {
+            partiallyConfiguredAgents.push(configuration);
+        }
+    }
+    return {
+        nonConfiguredAgents,
+        partiallyConfiguredAgents,
+        fullyConfiguredAgents,
+        disabledAgents,
+    };
+}
+async function getAgentConfiguration(agent, workspaceRoot) {
+    let agentConfiguration;
+    switch (agent) {
+        case 'claude': {
+            // Claude uses a plugin from marketplace which includes the MCP server
+            const claudeSettingsPath = (0, path_1.resolve)(workspaceRoot, '.claude', 'settings.json');
+            let pluginConfigured;
+            try {
+                const settingsContents = (0, fileutils_1.readJsonFile)(claudeSettingsPath);
+                pluginConfigured =
+                    !!settingsContents?.['enabledPlugins']?.['nx@nx-claude-plugins'];
+            }
+            catch {
+                pluginConfigured = false;
+            }
+            const rulesPath = (0, constants_1.claudeMdPath)(workspaceRoot);
+            const rulesExists = (0, fs_1.existsSync)(rulesPath);
+            agentConfiguration = {
+                rules: rulesExists,
+                mcp: pluginConfigured,
+                rulesPath: rulesPath,
+                mcpPath: claudeSettingsPath,
+            };
+            break;
+        }
+        case 'gemini': {
+            const geminiRulePath = (0, constants_1.geminiMdPath)(workspaceRoot);
+            const geminiMdExists = (0, fs_1.existsSync)(geminiRulePath);
+            const settingsPath = (0, constants_1.geminiSettingsPath)(workspaceRoot);
+            let mcpConfigured;
+            const geminiSettings = (0, constants_1.parseGeminiSettings)(workspaceRoot);
+            const customContextFilePath = typeof geminiSettings?.contextFileName === 'string'
+                ? geminiSettings.contextFileName
+                : undefined;
+            const customContextFilePathExists = customContextFilePath
+                ? (0, fs_1.existsSync)((0, path_1.resolve)(workspaceRoot, customContextFilePath))
+                : false;
+            mcpConfigured = geminiSettings?.['mcpServers']?.['nx-mcp'];
+            agentConfiguration = {
+                rules: (!customContextFilePath && geminiMdExists) ||
+                    (customContextFilePath && customContextFilePathExists),
+                mcp: mcpConfigured,
+                rulesPath: customContextFilePath ?? geminiRulePath,
+                mcpPath: settingsPath,
+            };
+            break;
+        }
+        case 'copilot': {
+            const rulesPath = (0, constants_1.agentsMdPath)(workspaceRoot);
+            const hasInstalledVSCode = await (0, native_1.isEditorInstalled)(0 /* SupportedEditor.VSCode */);
+            const hasInstalledVSCodeInsiders = await (0, native_1.isEditorInstalled)(1 /* SupportedEditor.VSCodeInsiders */);
+            const hasInstalledNxConsoleForVSCode = hasInstalledVSCode &&
+                !(await (0, native_1.canInstallNxConsoleForEditor)(0 /* SupportedEditor.VSCode */));
+            const hasInstalledNxConsoleForVSCodeInsiders = hasInstalledVSCodeInsiders &&
+                !(await (0, native_1.canInstallNxConsoleForEditor)(1 /* SupportedEditor.VSCodeInsiders */));
+            const agentsMdExists = (0, fs_1.existsSync)(rulesPath);
+            agentConfiguration = {
+                mcp: hasInstalledNxConsoleForVSCode ||
+                    hasInstalledNxConsoleForVSCodeInsiders,
+                rules: agentsMdExists,
+                rulesPath,
+                mcpPath: null,
+                disabled: !hasInstalledVSCode && !hasInstalledVSCodeInsiders,
+            };
+            break;
+        }
+        case 'cursor': {
+            const rulesPath = (0, constants_1.agentsMdPath)(workspaceRoot);
+            const hasInstalledCursor = await (0, native_1.isEditorInstalled)(2 /* SupportedEditor.Cursor */);
+            const hasInstalledNxConsole = !(await (0, native_1.canInstallNxConsoleForEditor)(2 /* SupportedEditor.Cursor */));
+            const agentsMdExists = (0, fs_1.existsSync)(rulesPath);
+            agentConfiguration = {
+                mcp: hasInstalledCursor ? hasInstalledNxConsole : false,
+                rules: agentsMdExists,
+                rulesPath,
+                mcpPath: null,
+                disabled: !hasInstalledCursor,
+            };
+            break;
+        }
+        case 'codex': {
+            const rulesPath = (0, constants_1.agentsMdPath)(workspaceRoot);
+            const agentsMdExists = (0, fs_1.existsSync)(rulesPath);
+            const mcpPath = (0, constants_1.codexConfigTomlPath)(workspaceRoot);
+            let mcpConfigured;
+            if ((0, fs_1.existsSync)(mcpPath)) {
+                const tomlContents = (0, fs_1.readFileSync)(mcpPath, 'utf-8');
+                mcpConfigured = tomlContents.includes(constants_1.nxMcpTomlHeader);
+            }
+            else {
+                mcpConfigured = false;
+            }
+            agentConfiguration = {
+                mcp: mcpConfigured,
+                rules: agentsMdExists,
+                rulesPath,
+                mcpPath,
+            };
+            break;
+        }
+        case 'opencode': {
+            const rulesPath = (0, constants_1.agentsMdPath)(workspaceRoot);
+            const agentsMdExists = (0, fs_1.existsSync)(rulesPath);
+            const mcpPath = (0, constants_1.opencodeMcpPath)(workspaceRoot);
+            let mcpConfigured;
+            try {
+                const mcpContents = (0, fileutils_1.readJsonFile)(mcpPath);
+                // OpenCode uses 'mcp' property, not 'mcpServers'
+                mcpConfigured = !!mcpContents?.['mcp']?.['nx-mcp'];
+            }
+            catch {
+                mcpConfigured = false;
+            }
+            agentConfiguration = {
+                mcp: mcpConfigured,
+                rules: agentsMdExists,
+                rulesPath,
+                mcpPath,
+            };
+            break;
+        }
+    }
+    return {
+        ...agentConfiguration,
+        outdated: agentConfiguration.mcp &&
+            agentConfiguration.rules &&
+            (await agentWouldChangeWithGenerator(agent, workspaceRoot)),
+        name: agent,
+        displayName: exports.agentDisplayMap[agent],
+    };
+}
+async function agentWouldChangeWithGenerator(agent, workspaceRoot) {
+    const tree = new tree_1.FsTree(workspaceRoot, false);
+    const callback = await (0, set_up_ai_agents_1.default)(tree, {
+        directory: '.',
+        agents: [agent],
+        writeNxCloudRules: (0, nx_cloud_utils_1.isNxCloudUsed)((0, configuration_1.readNxJson)()),
+    }, true);
+    const modificationResults = await callback(true);
+    return (tree.listChanges().length > 0 || modificationResults.messages.length > 0);
+}
+async function configureAgents(agents, workspaceRoot, useLatest) {
+    const writeNxCloudRules = (0, nx_cloud_utils_1.isNxCloudUsed)((0, configuration_1.readNxJson)());
+    const tree = new tree_1.FsTree(workspaceRoot, false);
+    const callback = await (0, set_up_ai_agents_1.default)(tree, {
+        directory: '.',
+        agents,
+        writeNxCloudRules,
+    }, !useLatest);
+    // changes that are out of scope for the generator itself because they do more than modify the tree
+    (0, tree_1.flushChanges)(workspaceRoot, tree.listChanges());
+    const modificationResults = await callback();
+    modificationResults.messages.forEach((message) => output_1.output.log(message));
+    modificationResults.errors.forEach((error) => output_1.output.error(error));
+}
+/**
+ * Explains a permission error thrown while writing agent configuration files.
+ *
+ * The errno alone does not identify the cause. Agent harnesses (e.g. Claude
+ * Code) deny writes to their own settings files from sandboxed shell commands,
+ * so `nx configure-ai-agents` run through an agent's bash tool fails with EPERM
+ * where the same command succeeds in a terminal — but a root-owned
+ * `.claude/settings.json` left by an earlier `sudo nx`, or a read-only
+ * checkout, produces the same errno with an unrelated remedy. The sandbox
+ * explanation is therefore only offered where a sandbox or an agent is
+ * actually detected, and the underlying message is kept either way.
+ */
+function agentConfigWriteBlockedLines(error) {
+    const err = error;
+    const target = err?.path ?? 'an agent configuration file';
+    return [
+        `Writing ${target} failed: ${err?.message ?? 'permission denied'}`,
+        ...((0, is_sandbox_1.isSandbox)() || (0, native_1.isAiAgent)()
+            ? [
+                "Agent sandboxes protect their own settings files from writes made by sandboxed shell commands, so this command cannot finish when run through an agent's bash tool.",
+                'To complete the AI agent setup, run `nx configure-ai-agents` from a regular terminal and relaunch the agent harness.',
+            ]
+            : [
+                'Check the ownership and mode of that path: an earlier `sudo nx` run or a read-only checkout produces this.',
+            ]),
+    ];
+}

package/dist/src/analytics/analytics.d.ts

@@ -0,0 +1,16 @@
+import type { EventDimensions } from '../native';
+export declare const customDimensions: EventDimensions;
+export type EventParameters = Partial<Record<EventDimensions[keyof EventDimensions], string | number | boolean>>;
+/**
+ * Fraction of sessions that report perf spans. Stamping this rate on a
+ * measure's detail (as the sampleRate dimension) opts it into sampling; see
+ * is_sampled_in in native/telemetry/service.rs. Multiply GA counts by 1/rate.
+ */
+export declare const PERF_SPAN_SAMPLE_RATE = 0.1;
+export declare function startAnalytics(): Promise<void>;
+export declare function reportNxAddCommand(packageName: string, version: string): void;
+export declare function reportNxGenerateCommand(generator: string): void;
+export declare function reportCommandRunEvent(command: string, parameters?: Record<string, any>, args?: Record<string, any>): void;
+export declare function reportEvent(name: string, eventParameters?: EventParameters): void;
+export declare function argsToQueryString(args: Record<string, any>): string;
+export declare function flushAnalytics(): void;

package/dist/src/analytics/analytics.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PERF_SPAN_SAMPLE_RATE = exports.customDimensions = void 0;
+exports.startAnalytics = startAnalytics;
+exports.reportNxAddCommand = reportNxAddCommand;
+exports.reportNxGenerateCommand = reportNxGenerateCommand;
+exports.reportCommandRunEvent = reportCommandRunEvent;
+exports.reportEvent = reportEvent;
+exports.argsToQueryString = argsToQueryString;
+exports.flushAnalytics = flushAnalytics;
+const tslib_1 = require("tslib");
+const nx_json_1 = require("../config/nx-json");
+const analytics_enabled_1 = require("../utils/analytics-enabled");
+const workspace_root_1 = require("../utils/workspace-root");
+const versions_1 = require("../utils/versions");
+const native_1 = require("../native");
+const package_manager_1 = require("../utils/package-manager");
+const semver_1 = require("semver");
+const os = tslib_1.__importStar(require("os"));
+const crypto_1 = require("crypto");
+const machine_id_cache_1 = require("../utils/machine-id-cache");
+const is_ci_1 = require("../utils/is-ci");
+const workspace_id_1 = require("../utils/workspace-id");
+const db_connection_1 = require("../utils/db-connection");
+// Conditionally import telemetry functions only on non-WASM platforms
+let initializeTelemetry;
+let initializeTelemetryWithSessionId;
+let flushTelemetry;
+let trackEventNative;
+let trackPageViewNative;
+let getEventDimensions;
+if (!native_1.IS_WASM) {
+    const nativeModule = require('../native');
+    initializeTelemetry = nativeModule.initializeTelemetry;
+    initializeTelemetryWithSessionId =
+        nativeModule.initializeTelemetryWithSessionId;
+    flushTelemetry = nativeModule.flushTelemetry;
+    trackEventNative = nativeModule.trackEvent;
+    trackPageViewNative = nativeModule.trackPageView;
+    getEventDimensions = nativeModule.getEventDimensions;
+}
+exports.customDimensions = native_1.IS_WASM
+    ? null
+    : (getEventDimensions?.() ?? null);
+let _telemetryInitialized = false;
+/**
+ * Fraction of sessions that report perf spans. Stamping this rate on a
+ * measure's detail (as the sampleRate dimension) opts it into sampling; see
+ * is_sampled_in in native/telemetry/service.rs. Multiply GA counts by 1/rate.
+ */
+exports.PERF_SPAN_SAMPLE_RATE = 0.1;
+async function startAnalytics() {
+    // Analytics not supported on WASM
+    if (native_1.IS_WASM) {
+        return;
+    }
+    // Analytics must never break the command that triggered it; callers await
+    // this bare. Nothing below (nx.json read, package-manager version
+    // detection, machine id, telemetry init) may throw past this boundary -
+    // on any failure, continue without telemetry.
+    try {
+        const nxJson = (0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot);
+        if (!(0, analytics_enabled_1.isAnalyticsEnabled)(nxJson)) {
+            return;
+        }
+        const workspaceId = (0, workspace_id_1.generateWorkspaceId)(workspace_root_1.workspaceRoot, nxJson);
+        if (!workspaceId) {
+            // Not a git repo — no telemetry
+            return;
+        }
+        const isNxCloud = !!(nxJson?.nxCloudId ?? nxJson?.nxCloudAccessToken);
+        // A CI fleet is not a user: shared images bake in /etc/machine-id, so a
+        // uid would collapse whole fleets into one GA "user" (and trip per-user
+        // collection caps). GA falls back to cid = workspace for CI traffic.
+        const userId = (0, is_ci_1.isCI)() ? undefined : await getTelemetryUserId(workspaceId);
+        const packageManagerInfo = getPackageManagerInfo();
+        const nodeVersion = (0, semver_1.parse)(process.version);
+        const nodeVersionString = nodeVersion
+            ? `${nodeVersion.major}.${nodeVersion.minor}.${nodeVersion.patch}`
+            : 'unknown';
+        const commonArgs = [
+            workspaceId,
+            userId,
+            versions_1.nxVersion,
+            packageManagerInfo.name,
+            packageManagerInfo.version,
+            nodeVersionString,
+            os.arch(),
+            os.platform(),
+            os.release(),
+            !!(0, is_ci_1.isCI)(),
+            isNxCloud,
+        ];
+        const sessionId = process.env.NX_ANALYTICS_SESSION_ID;
+        if (sessionId) {
+            // Plugin worker path — reuse session ID from parent, no DB needed
+            initializeTelemetryWithSessionId(sessionId, ...commonArgs);
+        }
+        else {
+            // CLI/daemon path — get session from DB, set env var for children
+            const dbConnection = (0, db_connection_1.getDbConnection)();
+            const newSessionId = initializeTelemetry(dbConnection, ...commonArgs);
+            process.env.NX_ANALYTICS_SESSION_ID = newSessionId;
+        }
+        _telemetryInitialized = true;
+        // Flush analytics automatically on process exit so every code path
+        // is covered without needing explicit exitAndFlushAnalytics() calls.
+        process.on('exit', () => {
+            flushAnalytics();
+        });
+    }
+    catch (error) {
+        // If telemetry fails to initialize, continue without it
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            console.log(`Failed to initialize telemetry: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+}
+function reportNxAddCommand(packageName, version) {
+    reportCommandRunEvent('add', {
+        [exports.customDimensions.packageName]: packageName,
+        [exports.customDimensions.packageVersion]: version,
+    });
+}
+function reportNxGenerateCommand(generator) {
+    reportCommandRunEvent('generate', {
+        [exports.customDimensions.generatorName]: generator,
+    });
+}
+function reportCommandRunEvent(command, parameters, args) {
+    command = command === 'g' ? 'generate' : command;
+    let pageLocation = command;
+    if (args) {
+        const qs = argsToQueryString(args);
+        if (qs) {
+            pageLocation = `${command}?${qs}`;
+        }
+    }
+    trackPageView(command, pageLocation, parameters);
+}
+function reportEvent(name, eventParameters) {
+    trackEvent(name, eventParameters);
+}
+const SKIP_ARGS_KEYS = new Set([
+    '$0',
+    '_',
+    '__overrides_unparsed__',
+    '__overrides__',
+]);
+// String args with fixed enum values that are safe to include in analytics.
+// All boolean and number args are included automatically.
+const ALLOWED_STRING_ARGS = new Set([
+    'outputStyle',
+    'type',
+    'view',
+    'access',
+    'preset',
+    'interactive',
+    'printConfig',
+    'resolveVersionPlans',
+]);
+function argsToQueryString(args) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(args)) {
+        if (SKIP_ARGS_KEYS.has(key))
+            continue;
+        if (value === undefined || value === null)
+            continue;
+        if (typeof value === 'boolean' || typeof value === 'number') {
+            params.append(key, String(value));
+        }
+        else if (typeof value === 'string' && ALLOWED_STRING_ARGS.has(key)) {
+            params.append(key, value);
+        }
+        // All other types (strings, arrays, objects) are dropped
+    }
+    return params.toString();
+}
+function trackEvent(eventName, parameters) {
+    if (_telemetryInitialized) {
+        // Convert parameters to string map for Rust
+        const stringParams = {};
+        if (parameters) {
+            for (const [key, value] of Object.entries(parameters)) {
+                if (value !== undefined && value !== null) {
+                    stringParams[key] = String(value);
+                }
+            }
+        }
+        // Fire and forget - synchronous call
+        try {
+            trackEventNative(eventName, stringParams);
+        }
+        catch {
+            // Silently ignore errors
+        }
+    }
+}
+function trackPageView(pageTitle, pageLocation, parameters) {
+    if (_telemetryInitialized) {
+        // Convert parameters to string map for Rust
+        const stringParams = {};
+        if (parameters) {
+            for (const [key, value] of Object.entries(parameters)) {
+                if (value !== undefined && value !== null) {
+                    stringParams[key] = String(value);
+                }
+            }
+        }
+        // Fire and forget - synchronous call
+        try {
+            trackPageViewNative(pageTitle, pageLocation, stringParams);
+        }
+        catch {
+            // Silently ignore errors
+        }
+    }
+}
+function flushAnalytics() {
+    if (_telemetryInitialized) {
+        try {
+            flushTelemetry();
+        }
+        catch (error) {
+            // Failure to report analytics shouldn't crash the CLI
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                console.log(`Failed to flush telemetry: ${error.message}`);
+            }
+        }
+    }
+}
+function getPackageManagerInfo() {
+    const pm = (0, package_manager_1.detectPackageManager)();
+    return {
+        name: pm,
+        version: (0, package_manager_1.getPackageManagerVersion)(pm),
+    };
+}
+// Mix workspace id in: shared Docker images (Gitpod, Cypress, etc.) bake
+// in /etc/machine-id, so machine-id alone collapses many users into one.
+async function getTelemetryUserId(workspaceId) {
+    const machineId = await (0, machine_id_cache_1.getCurrentMachineId)();
+    return (0, crypto_1.createHash)('sha256')
+        .update(`${machineId}|${workspaceId}`)
+        .digest('hex');
+}

package/dist/src/analytics/index.d.ts

@@ -0,0 +1 @@
+export { customDimensions, EventParameters, PERF_SPAN_SAMPLE_RATE, startAnalytics, reportNxAddCommand, reportNxGenerateCommand, reportCommandRunEvent, reportEvent, flushAnalytics, } from './analytics';

package/dist/src/analytics/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flushAnalytics = exports.reportEvent = exports.reportCommandRunEvent = exports.reportNxGenerateCommand = exports.reportNxAddCommand = exports.startAnalytics = exports.PERF_SPAN_SAMPLE_RATE = exports.customDimensions = void 0;
+var analytics_1 = require("./analytics");
+Object.defineProperty(exports, "customDimensions", { enumerable: true, get: function () { return analytics_1.customDimensions; } });
+Object.defineProperty(exports, "PERF_SPAN_SAMPLE_RATE", { enumerable: true, get: function () { return analytics_1.PERF_SPAN_SAMPLE_RATE; } });
+Object.defineProperty(exports, "startAnalytics", { enumerable: true, get: function () { return analytics_1.startAnalytics; } });
+Object.defineProperty(exports, "reportNxAddCommand", { enumerable: true, get: function () { return analytics_1.reportNxAddCommand; } });
+Object.defineProperty(exports, "reportNxGenerateCommand", { enumerable: true, get: function () { return analytics_1.reportNxGenerateCommand; } });
+Object.defineProperty(exports, "reportCommandRunEvent", { enumerable: true, get: function () { return analytics_1.reportCommandRunEvent; } });
+Object.defineProperty(exports, "reportEvent", { enumerable: true, get: function () { return analytics_1.reportEvent; } });
+Object.defineProperty(exports, "flushAnalytics", { enumerable: true, get: function () { return analytics_1.flushAnalytics; } });

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

@@ -0,0 +1,3 @@
+import type { AddOptions } from './command-object';
+export declare function addHandler(options: AddOptions): Promise<number>;
+export declare const coreNxPluginVersions: Map<string, string>;

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

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coreNxPluginVersions = void 0;
+exports.addHandler = addHandler;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const nx_json_1 = require("../../config/nx-json");
+const child_process_2 = require("../../utils/child-process");
+const fileutils_1 = require("../../utils/fileutils");
+const logger_1 = require("../../utils/logger");
+const output_1 = require("../../utils/output");
+const package_manager_1 = require("../../utils/package-manager");
+const handle_errors_1 = require("../../utils/handle-errors");
+const versions_1 = require("../../utils/versions");
+const workspace_root_1 = require("../../utils/workspace-root");
+const add_nx_scripts_1 = require("../init/implementation/dot-nx/add-nx-scripts");
+const semver_1 = require("semver");
+const configure_plugins_1 = require("../init/configure-plugins");
+const spinner_1 = require("../../utils/spinner");
+const analytics_1 = require("../../analytics");
+const client_1 = require("../../daemon/client/client");
+function addHandler(options) {
+    return (0, handle_errors_1.handleErrors)(options.verbose, async () => {
+        output_1.output.addNewline();
+        // Package managers write the lock file before node_modules is fully linked,
+        // so a live daemon restarts mid-install and caches a graph whose plugins,
+        // still being relinked, no longer resolve.
+        await client_1.daemonClient.stop();
+        const [pkgName, version] = parsePackageSpecifier(options.packageSpecifier);
+        (0, analytics_1.reportNxAddCommand)(pkgName, version);
+        const nxJson = (0, nx_json_1.readNxJson)();
+        await installPackage(pkgName, version, nxJson);
+        await initializePlugin(pkgName, options, nxJson);
+        output_1.output.success({
+            title: `Package ${pkgName} added successfully.`,
+        });
+    });
+}
+async function installPackage(pkgName, version, nxJson) {
+    const spinner = spinner_1.globalSpinner.start(`Installing ${pkgName}@${version}...`);
+    if ((0, fs_1.existsSync)('package.json')) {
+        const pm = (0, package_manager_1.detectPackageManager)();
+        const pmv = (0, package_manager_1.getPackageManagerVersion)(pm);
+        const pmc = (0, package_manager_1.getPackageManagerCommand)(pm);
+        // if we explicitly specify latest in yarn berry, it won't resolve the version
+        let command = pm === 'yarn' && (0, semver_1.gte)(pmv, '2.0.0') && version === 'latest'
+            ? `${pmc.addDev} ${pkgName}`
+            : `${pmc.addDev} ${pkgName}@${version}`;
+        // pnpm 11+ fails the install when the plugin's own dependency tree
+        // carries unacknowledged build scripts, and the plugin's generators can
+        // only record allowBuilds decisions after this install. Warn and skip
+        // for this one install, like pnpm 10 did. pnpm 12 gave `--config` a
+        // meaning of its own and takes the setting from the environment instead.
+        const env = { ...process.env };
+        if (pm === 'pnpm' && (0, semver_1.gte)(pmv, '11.0.0')) {
+            command += ' --config.strictDepBuilds=false';
+            env.PNPM_CONFIG_STRICT_DEP_BUILDS = 'false';
+        }
+        await new Promise((resolve) => (0, child_process_1.exec)(command, {
+            windowsHide: true,
+            env,
+        }, (error, stdout, stderr) => {
+            if (error) {
+                spinner.fail();
+                output_1.output.addNewline();
+                const errorOutput = [stdout.trim(), stderr.trim()]
+                    .filter(Boolean)
+                    .join('\n');
+                logger_1.logger.error(errorOutput);
+                output_1.output.error({
+                    title: `Failed to install ${pkgName}. Please check the error above for more details.`,
+                });
+                process.exit(1);
+            }
+            return resolve();
+        }));
+    }
+    else {
+        nxJson.installation.plugins ??= {};
+        nxJson.installation.plugins[pkgName] = (0, add_nx_scripts_1.normalizeVersionForNxJson)(pkgName, version);
+        (0, fileutils_1.writeJsonFile)('nx.json', nxJson);
+        try {
+            await (0, child_process_2.runNxAsync)('--help', { silent: true });
+        }
+        catch (e) {
+            // revert adding the plugin to nx.json
+            nxJson.installation.plugins[pkgName] = undefined;
+            (0, fileutils_1.writeJsonFile)('nx.json', nxJson);
+            spinner.fail();
+            output_1.output.addNewline();
+            logger_1.logger.error(e.message);
+            output_1.output.error({
+                title: `Failed to install ${pkgName}. Please check the error above for more details.`,
+            });
+            process.exit(1);
+        }
+    }
+    spinner.succeed();
+}
+async function initializePlugin(pkgName, options, nxJson) {
+    let updatePackageScripts = false;
+    if (exports.coreNxPluginVersions.has(pkgName) &&
+        (options.updatePackageScripts ||
+            (options.updatePackageScripts === undefined &&
+                nxJson.useInferencePlugins !== false &&
+                process.env.NX_ADD_PLUGINS !== 'false'))) {
+        updatePackageScripts = true;
+    }
+    const spinner = spinner_1.globalSpinner.start(`Initializing ${pkgName}...`);
+    try {
+        await (0, configure_plugins_1.runPluginInitGenerator)(pkgName, workspace_root_1.workspaceRoot, updatePackageScripts, options.verbose);
+    }
+    catch (e) {
+        spinner.fail();
+        output_1.output.addNewline();
+        output_1.output.error({
+            title: `Failed to initialize ${pkgName}`,
+            bodyLines: (0, configure_plugins_1.getFailedToInstallPluginErrorMessages)(e),
+        });
+        process.exit(1);
+    }
+    spinner.succeed();
+}
+function parsePackageSpecifier(packageSpecifier) {
+    const i = packageSpecifier.lastIndexOf('@');
+    if (i <= 0) {
+        if (exports.coreNxPluginVersions.has(packageSpecifier)) {
+            return [packageSpecifier, exports.coreNxPluginVersions.get(packageSpecifier)];
+        }
+        return [packageSpecifier, 'latest'];
+    }
+    const pkgName = packageSpecifier.substring(0, i);
+    const version = packageSpecifier.substring(i + 1);
+    return [pkgName, version];
+}
+exports.coreNxPluginVersions = require(require.resolve('nx/package.json'))['nx-migrations'].packageGroup.reduce((map, entry) => {
+    const packageName = typeof entry === 'string' ? entry : entry.package;
+    const version = typeof entry === 'string' ? versions_1.nxVersion : entry.version;
+    return map.set(packageName, version);
+}, 
+// Package Name -> Desired Version
+new Map());

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

@@ -0,0 +1,8 @@
+import { CommandModule } from 'yargs';
+export interface AddOptions {
+    packageSpecifier: string;
+    updatePackageScripts?: boolean;
+    verbose?: boolean;
+    __overrides_unparsed__: string[];
+}
+export declare const yargsAddCommand: CommandModule<{}, AddOptions>;