nx 22.7.0-rc.1 → 22.7.0

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

@@ -3,12 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.yargsInitCommand = void 0;
 const handle_import_1 = require("../../utils/handle-import");
 const shared_options_1 = require("../yargs-utils/shared-options");
-const native_1 = require("../../native");
-const ai_output_1 = require("./utils/ai-output");
-const ab_testing_1 = require("../../utils/ab-testing");
-const versions_1 = require("../../utils/versions");
-const is_ci_1 = require("../../utils/is-ci");
-const package_manager_1 = require("../../utils/package-manager");
 exports.yargsInitCommand = {
     command: 'init',
     describe: 'Adds Nx to any type of workspace. It installs nx, creates an nx.json configuration file and optionally sets up remote caching. For more info, check https://nx.dev/recipes/adopting-nx.',
@@ -33,70 +27,15 @@ exports.yargsInitCommand = {
                 return;
             throw error;
         });
-        const aiAgent = (0, native_1.isAiAgent)();
-        (0, ab_testing_1.recordStat)({
-            command: 'init',
-            nxVersion: versions_1.nxVersion,
-            useCloud: false,
-            meta: {
-                type: 'start',
-                nodeVersion: process.versions.node,
-                os: process.platform,
-                packageManager: (0, package_manager_1.detectPackageManager)(),
-                aiAgent,
-                isCI: (0, is_ci_1.isCI)(),
-            },
-        });
-        try {
-            const useV2 = await isInitV2();
-            if (useV2) {
-                // v2 records its own complete event with richer context
-                await require('./init-v2').initHandler(args);
-            }
-            else {
-                await require('./init-v1').initHandler(args);
-                await (0, ab_testing_1.recordStat)({
-                    command: 'init',
-                    nxVersion: versions_1.nxVersion,
-                    useCloud: false,
-                    meta: {
-                        type: 'complete',
-                        nodeVersion: process.versions.node,
-                        os: process.platform,
-                        packageManager: (0, package_manager_1.detectPackageManager)(),
-                        aiAgent,
-                        isCI: (0, is_ci_1.isCI)(),
-                    },
-                });
-            }
-            process.exit(0);
+        const useV2 = await isInitV2();
+        if (useV2) {
+            await require('./init-v2').initHandler(args);
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const errorCode = (0, ai_output_1.determineErrorCode)(error);
-            await (0, ab_testing_1.recordStat)({
-                command: 'init',
-                nxVersion: versions_1.nxVersion,
-                useCloud: false,
-                meta: {
-                    type: 'error',
-                    errorCode,
-                    errorMessage: errorMessage.substring(0, 250),
-                    aiAgent,
-                },
-            });
-            // Output structured error for AI agents
-            if (aiAgent) {
-                const errorLogPath = (0, ai_output_1.writeErrorLog)(error);
-                (0, ai_output_1.writeAiOutput)((0, ai_output_1.buildErrorResult)(errorMessage, errorCode, errorLogPath));
-            }
-            else {
-                // Ensure the cursor is always restored just in case the user has bailed during interactive prompts
-                // Skip for AI agents to avoid corrupting NDJSON output
-                process.stdout.write('\x1b[?25h');
-            }
-            process.exit(1);
+        else {
+            // v1 path retained for `NX_ADD_PLUGINS=false`; slated for removal.
+            await require('./init-v1').initHandler(args);
         }
+        process.exit(0);
     },
 };
 async function isInitV2() {

package/dist/src/command-line/init/configure-plugins.js

@@ -35,8 +35,14 @@ function installPluginPackages(repoRoot, pmc = (0, package_manager_1.getPackageM
             nxJson.installation.plugins[plugin] = versions_1.nxVersion;
         }
         (0, fileutils_1.writeJsonFile)((0, path_1.join)(repoRoot, 'nx.json'), nxJson);
-        // Invoking nx wrapper to install plugins.
-        (0, child_process_1.runNxSync)('--version', { stdio: 'ignore' });
+        try {
+            (0, child_process_1.runNxSync)('--version', { stdio: 'pipe' });
+        }
+        catch (e) {
+            if (e?.stderr)
+                process.stderr.write(e.stderr);
+            throw e;
+        }
     }
 }
 /**

package/dist/src/command-line/init/implementation/utils.d.ts

@@ -8,6 +8,13 @@ export declare function createNxJsonFromTurboJson(turboJson: Record<string, any>
 export declare function addDepsToPackageJson(repoRoot: string, additionalPackages?: string[]): void;
 export declare function updateGitIgnore(root: string): void;
 export declare function runInstall(repoRoot: string, pmc?: PackageManagerCommands): void;
+/**
+ * Coerce any thrown value into a non-empty telemetry string. The naive
+ * `error.message || String(error)` yields "" for bare `new Error()`.
+ */
+export declare function toErrorString(error: unknown): string;
+export declare function readErrorStderr(error: unknown): string;
+export declare function extractErrorName(error: unknown, stderr: string): string;
 export declare function initCloud(installationSource: 'nx-init' | 'nx-init-angular' | 'nx-init-monorepo' | 'nx-init-nest' | 'nx-init-npm-repo' | 'nx-init-turborepo'): Promise<void>;
 export declare function setNeverConnectToCloud(repoRoot: string): void;
 export declare function addVsCodeRecommendedExtensions(repoRoot: string, extensions: string[]): void;

package/dist/src/command-line/init/implementation/utils.js

@@ -5,6 +5,9 @@ exports.createNxJsonFromTurboJson = createNxJsonFromTurboJson;
 exports.addDepsToPackageJson = addDepsToPackageJson;
 exports.updateGitIgnore = updateGitIgnore;
 exports.runInstall = runInstall;
+exports.toErrorString = toErrorString;
+exports.readErrorStderr = readErrorStderr;
+exports.extractErrorName = extractErrorName;
 exports.initCloud = initCloud;
 exports.setNeverConnectToCloud = setNeverConnectToCloud;
 exports.addVsCodeRecommendedExtensions = addVsCodeRecommendedExtensions;
@@ -189,11 +192,74 @@ function updateGitIgnore(root) {
     catch { }
 }
 function runInstall(repoRoot, pmc = (0, package_manager_1.getPackageManagerCommand)()) {
-    (0, child_process_1.execSync)(pmc.install, {
-        stdio: ['ignore', 'ignore', 'inherit'],
-        cwd: repoRoot,
-        windowsHide: true,
-    });
+    try {
+        (0, child_process_1.execSync)(pmc.install, {
+            stdio: ['ignore', 'ignore', 'pipe'],
+            encoding: 'utf8',
+            cwd: repoRoot,
+            windowsHide: true,
+        });
+    }
+    catch (e) {
+        if (e?.stderr)
+            process.stderr.write(e.stderr);
+        throw e;
+    }
+}
+/**
+ * Coerce any thrown value into a non-empty telemetry string. The naive
+ * `error.message || String(error)` yields "" for bare `new Error()`.
+ */
+function toErrorString(error) {
+    if (error == null)
+        return 'Unknown error';
+    if (error instanceof Error) {
+        if (error.message)
+            return error.message;
+        if (error.name && error.name !== 'Error')
+            return error.name;
+        // Drop `stack` — large and contains absolute paths (PII).
+        const keys = Object.getOwnPropertyNames(error).filter((k) => k !== 'stack');
+        const serialized = safeJsonStringify(error, keys);
+        if (serialized && serialized !== '{}')
+            return serialized;
+        return error.name || 'Error';
+    }
+    if (typeof error === 'object') {
+        const serialized = safeJsonStringify(error);
+        if (serialized && serialized !== '{}')
+            return serialized;
+        return Object.prototype.toString.call(error);
+    }
+    return String(error);
+}
+function readErrorStderr(error) {
+    const raw = error?.stderr;
+    if (typeof raw === 'string')
+        return raw;
+    if (raw && typeof raw.toString === 'function') {
+        return raw.toString('utf8');
+    }
+    return '';
+}
+function extractErrorName(error, stderr) {
+    const nodeCode = error?.code;
+    if (typeof nodeCode === 'string')
+        return nodeCode;
+    const m = stderr.match(/\b(E[A-Z0-9_]{2,}|ERR_[A-Z0-9_]+)\b/);
+    if (m)
+        return m[1];
+    if (error instanceof Error)
+        return error.name;
+    return typeof error;
+}
+function safeJsonStringify(value, replacer) {
+    try {
+        return JSON.stringify(value, replacer);
+    }
+    catch {
+        return '';
+    }
 }
 async function initCloud(installationSource) {
     const token = await (0, connect_to_nx_cloud_2.connectWorkspaceToCloud)({

package/dist/src/command-line/init/init-v2.js

@@ -60,8 +60,58 @@ async function initHandler(options, inner = false) {
         return initHandlerImpl(options);
     }
 }
+async function recordInitError(error, baseMeta) {
+    const errorMessage = (0, utils_1.toErrorString)(error);
+    const errorCode = (0, ai_output_1.determineErrorCode)(error);
+    const stderr = (0, utils_1.readErrorStderr)(error).trim();
+    const telemetryMessage = (stderr ? `${errorMessage} | stderr: ${stderr.slice(-250)}` : errorMessage).slice(0, 500);
+    const errorName = (0, utils_1.extractErrorName)(error, stderr);
+    await (0, ab_testing_1.recordStat)({
+        command: 'init',
+        nxVersion: versions_1.nxVersion,
+        useCloud: false,
+        meta: {
+            type: 'error',
+            errorCode,
+            errorName,
+            errorMessage: telemetryMessage,
+            ...baseMeta,
+        },
+    });
+    if (baseMeta.aiAgent) {
+        const errorLogPath = (0, ai_output_1.writeErrorLog)(error);
+        (0, ai_output_1.writeAiOutput)((0, ai_output_1.buildErrorResult)(errorMessage, errorCode, errorLogPath));
+    }
+    else {
+        // Restore the cursor in case the user bailed during an interactive
+        // prompt. Skip for AI agents — it would corrupt NDJSON output.
+        process.stdout.write('\x1b[?25h');
+    }
+    process.exit(1);
+}
 async function initHandlerImpl(options) {
     process.env.NX_RUNNING_NX_INIT = 'true';
+    const baseMeta = {
+        nodeVersion: process.versions.node,
+        os: process.platform,
+        packageManager: (0, package_manager_2.detectPackageManager)(),
+        aiAgent: (0, native_1.isAiAgent)(),
+        isCI: (0, is_ci_1.isCI)(),
+    };
+    (0, ab_testing_1.recordStat)({
+        command: 'init',
+        nxVersion: versions_1.nxVersion,
+        useCloud: false,
+        meta: { type: 'start', ...baseMeta },
+    });
+    try {
+        return await runInit(options, baseMeta);
+    }
+    catch (error) {
+        await recordInitError(error, baseMeta);
+    }
+}
+async function runInit(options, baseMeta) {
     const version = process.env.NX_VERSION ?? ((0, semver_1.prerelease)(versions_1.nxVersion) ? versions_1.nxVersion : 'latest');
     if (process.env.NX_VERSION) {
         output_1.output.log({ title: `Using version ${process.env.NX_VERSION}` });

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.yargsViewLogsCommand = exports.yargsConnectCommand = void 0;
 const handle_import_1 = require("../../../utils/handle-import");
 const documentation_1 = require("../../yargs-utils/documentation");
-const versions_1 = require("../../../utils/versions");
 const shared_options_1 = require("../../yargs-utils/shared-options");
 exports.yargsConnectCommand = {
     command: 'connect',
@@ -13,11 +12,6 @@ exports.yargsConnectCommand = {
     handler: async (args) => {
         const checkRemote = process.env.NX_SKIP_CHECK_REMOTE !== 'true';
         await (await (0, handle_import_1.handleImport)('./connect-to-nx-cloud.js', __dirname)).connectToNxCloudCommand({ ...args, checkRemote });
-        await (await (0, handle_import_1.handleImport)('../../../utils/ab-testing.js', __dirname)).recordStat({
-            command: 'connect',
-            nxVersion: versions_1.nxVersion,
-            useCloud: true,
-        });
         process.exit(0);
     },
 };

package/dist/src/command-line/nx-cloud/connect/connect-to-nx-cloud.js

@@ -64,6 +64,61 @@ async function connectWorkspaceToCloud(options, directory = workspace_root_1.wor
     return accessToken;
 }
 async function connectToNxCloudCommand(options, command) {
+    // `connectToNxCloudWithPrompt` (called from `migrate`) records its own stat; skip here to avoid double-counting.
+    const selfRecord = !command;
+    const baseMeta = {
+        nodeVersion: process.versions.node,
+        os: process.platform,
+        packageManager: (0, package_manager_1.detectPackageManager)(),
+        aiAgent: (0, native_1.isAiAgent)(),
+        isCI: (0, is_ci_1.isCI)(),
+    };
+    if (selfRecord) {
+        await (0, ab_testing_1.recordStat)({
+            command: 'connect',
+            nxVersion: versions_1.nxVersion,
+            useCloud: true,
+            meta: { type: 'start', ...baseMeta },
+        });
+    }
+    try {
+        const result = await runConnectToNxCloud(options, command);
+        if (selfRecord) {
+            await (0, ab_testing_1.recordStat)({
+                command: 'connect',
+                nxVersion: versions_1.nxVersion,
+                useCloud: result,
+                meta: { type: 'complete', ...baseMeta },
+            });
+        }
+        return result;
+    }
+    catch (error) {
+        if (selfRecord) {
+            const message = (error instanceof Error && error.message) ||
+                String(error ?? 'Unknown error');
+            const errorName = typeof error?.code === 'string'
+                ? error.code
+                : error instanceof Error
+                    ? error.name
+                    : typeof error;
+            await (0, ab_testing_1.recordStat)({
+                command: 'connect',
+                nxVersion: versions_1.nxVersion,
+                useCloud: false,
+                meta: {
+                    type: 'error',
+                    errorCode: 'UNKNOWN',
+                    errorName,
+                    errorMessage: message.slice(0, 500),
+                    ...baseMeta,
+                },
+            });
+        }
+        throw error;
+    }
+}
+async function runConnectToNxCloud(options, command) {
     const nxJson = (0, configuration_1.readNxJson)();
     const installationSource = process.env.NX_CONSOLE
         ? 'nx-console'

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

@@ -103,7 +103,8 @@ function parseRunOneOptions(cwd, parsedArgs, projectGraph, nxJson) {
     let project;
     let target;
     let configuration;
-    if (parsedArgs[PROJECT_TARGET_CONFIG]?.lastIndexOf(':') > 0) {
+    if (typeof parsedArgs[PROJECT_TARGET_CONFIG] === 'string' &&
+        parsedArgs[PROJECT_TARGET_CONFIG].lastIndexOf(':') > 0) {
         // run case
         [project, target, configuration] = (0, split_target_1.splitTarget)(parsedArgs[PROJECT_TARGET_CONFIG], projectGraph, { currentProject: defaultProjectName });
         // this is to account for "nx npmscript:dev"
@@ -115,7 +116,7 @@ function parseRunOneOptions(cwd, parsedArgs, projectGraph, nxJson) {
     else if (parsedArgs.target) {
         target = parsedArgs.target;
     }
-    else if (parsedArgs[PROJECT_TARGET_CONFIG]) {
+    else if (typeof parsedArgs[PROJECT_TARGET_CONFIG] === 'string') {
         // If project:target:configuration exists but has no colon, check if it's a project with run target
         if (projectGraph.nodes[parsedArgs[PROJECT_TARGET_CONFIG]]?.data?.targets?.run) {
             target = 'run';

package/dist/src/command-line/yargs-utils/shared-options.d.ts

@@ -78,6 +78,8 @@ export declare function withRunOneOptions(yargs: Argv): Argv<{
     outputStyle: OutputStyle;
 } & RunOptions & {
     project: string;
+} & {
+    target: string;
 } & {
     help: boolean;
 }>;

package/dist/src/command-line/yargs-utils/shared-options.js

@@ -316,6 +316,13 @@ function withRunOneOptions(yargs) {
         .option('project', {
         describe: 'Target project.',
         type: 'string',
+        alias: 'p',
+    })
+        .option('target', {
+        describe: 'Target to run. Useful when the target name contains a colon, which conflicts with the positional `project:target:configuration` form.',
+        type: 'string',
+        alias: 't',
+        requiresArg: true,
     })
         .option('help', {
         describe: 'Show Help.',