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

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/new/new.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newWorkspace = newWorkspace;
+const tree_1 = require("../../generators/tree");
+const params_1 = require("../../utils/params");
+const handle_errors_1 = require("../../utils/handle-errors");
+const generator_utils_1 = require("../generate/generator-utils");
+function removeSpecialFlags(generatorOptions) {
+    delete generatorOptions.interactive;
+    delete generatorOptions.help;
+    delete generatorOptions.verbose;
+    delete generatorOptions['--'];
+    delete generatorOptions['$0'];
+}
+async function newWorkspace(cwd, args) {
+    return (0, handle_errors_1.handleErrors)(process.env.NX_VERBOSE_LOGGING === 'true' || args.verbose, async () => {
+        const isInteractive = args.interactive;
+        const { normalizedGeneratorName, schema, implementationFactory } = (0, generator_utils_1.getGeneratorInformation)('@nx/workspace/generators.json', 'new', null, {});
+        removeSpecialFlags(args);
+        const combinedOpts = await (0, params_1.combineOptionsForGenerator)(args, '@nx/workspace/generators.json', normalizedGeneratorName, null, null, schema, isInteractive, null, null, false);
+        const host = new tree_1.FsTree(cwd, false, 'nx new');
+        const implementation = implementationFactory();
+        const task = await implementation(host, combinedOpts);
+        (0, tree_1.flushChanges)(cwd, host.listChanges());
+        host.lock();
+        if (task) {
+            await task();
+        }
+    });
+}

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/apply-locally.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyLocallyHandler = applyLocallyHandler;
+const nx_json_1 = require("../../../config/nx-json");
+const nx_cloud_utils_1 = require("../../../utils/nx-cloud-utils");
+const utils_1 = require("../utils");
+function applyLocallyHandler(args) {
+    if (!(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
+        (0, utils_1.warnNotConnectedToCloud)();
+        return Promise.resolve(0);
+    }
+    return (0, utils_1.executeNxCloudCommand)('apply-locally', args.verbose);
+}

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/complete-run/stop-all-agents.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopAllAgentsHandler = stopAllAgentsHandler;
+const nx_json_1 = require("../../../config/nx-json");
+const nx_cloud_utils_1 = require("../../../utils/nx-cloud-utils");
+const utils_1 = require("../utils");
+function stopAllAgentsHandler(args) {
+    if (!(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
+        (0, utils_1.warnNotConnectedToCloud)();
+        return Promise.resolve(0);
+    }
+    return (0, utils_1.executeNxCloudCommand)('stop-all-agents', args.verbose);
+}

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;

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

@@ -0,0 +1,28 @@
+"use strict";
+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 shared_options_1 = require("../../yargs-utils/shared-options");
+exports.yargsConnectCommand = {
+    command: 'connect',
+    aliases: ['connect-to-nx-cloud'],
+    describe: `Connect workspace to Nx Cloud.`,
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)(withConnectOptions(yargs), 'connect-to-nx-cloud'),
+    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 });
+        process.exit(0);
+    },
+};
+function withConnectOptions(yargs) {
+    return (0, shared_options_1.withVerbose)(yargs).option('generateToken', {
+        type: 'boolean',
+        description: 'Explicitly asks for a token to be created, do not override existing tokens from Nx Cloud.',
+    });
+}
+exports.yargsViewLogsCommand = {
+    command: 'view-logs',
+    describe: 'Enables you to view and interact with the logs via the advanced analytic UI from Nx Cloud to help you debug your issue. To do this, Nx needs to connect your workspace to Nx Cloud and upload the most recent run details. Only the metrics are uploaded, not the artefacts.',
+    handler: async () => process.exit(await (await (0, handle_import_1.handleImport)('./view-logs.js', __dirname)).viewLogs()),
+};

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

@@ -0,0 +1,13 @@
+import { ConnectToNxCloudOptions } from '../../../nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud';
+import { NxJsonConfiguration } from '../../../config/nx-json';
+import { NxArgs } from '../../../utils/command-line-utils';
+import { MessageKey, MessageOptionKey } from '../../../utils/ab-testing';
+export declare function onlyDefaultRunnerIsUsed(nxJson: NxJsonConfiguration): boolean;
+export declare function connectToNxCloudIfExplicitlyAsked(opts: NxArgs): Promise<void>;
+export declare function connectWorkspaceToCloud(options: ConnectToNxCloudOptions, directory?: string): Promise<string>;
+export declare function connectToNxCloudCommand(options: {
+    generateToken?: boolean;
+    checkRemote?: boolean;
+}, command?: string): Promise<boolean>;
+export declare function connectExistingRepoToNxCloudPrompt(command?: string, key?: MessageKey, recordCompletion?: boolean): Promise<MessageOptionKey>;
+export declare function connectToNxCloudWithPrompt(command: string): Promise<void>;

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

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onlyDefaultRunnerIsUsed = onlyDefaultRunnerIsUsed;
+exports.connectToNxCloudIfExplicitlyAsked = connectToNxCloudIfExplicitlyAsked;
+exports.connectWorkspaceToCloud = connectWorkspaceToCloud;
+exports.connectToNxCloudCommand = connectToNxCloudCommand;
+exports.connectExistingRepoToNxCloudPrompt = connectExistingRepoToNxCloudPrompt;
+exports.connectToNxCloudWithPrompt = connectToNxCloudWithPrompt;
+const tslib_1 = require("tslib");
+const prompt_helpers_1 = require("../../../utils/prompt-helpers");
+const output_1 = require("../../../utils/output");
+const configuration_1 = require("../../../config/configuration");
+const tree_1 = require("../../../generators/tree");
+const connect_to_nx_cloud_1 = require("../../../nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud");
+const url_shorten_1 = require("../../../nx-cloud/utilities/url-shorten");
+const nx_cloud_utils_1 = require("../../../utils/nx-cloud-utils");
+const child_process_1 = require("../../../utils/child-process");
+const ab_testing_1 = require("../../../utils/ab-testing");
+const versions_1 = require("../../../utils/versions");
+const is_ci_1 = require("../../../utils/is-ci");
+const native_1 = require("../../../native");
+const package_manager_1 = require("../../../utils/package-manager");
+const workspace_root_1 = require("../../../utils/workspace-root");
+const git_utils_1 = require("../../../utils/git-utils");
+const pc = tslib_1.__importStar(require("picocolors"));
+const ora = require('ora');
+function onlyDefaultRunnerIsUsed(nxJson) {
+    const defaultRunner = nxJson.tasksRunnerOptions?.default?.runner;
+    if (!defaultRunner) {
+        // No tasks runner options OR no default runner defined:
+        // - If access token defined, uses cloud runner
+        // - If no access token defined, uses default
+        return (!(nxJson.nxCloudAccessToken ??
+            process.env.NX_CLOUD_AUTH_TOKEN ??
+            process.env.NX_CLOUD_ACCESS_TOKEN) && !nxJson.nxCloudId);
+    }
+    return defaultRunner === 'nx/tasks-runners/default';
+}
+async function connectToNxCloudIfExplicitlyAsked(opts) {
+    if (opts['cloud'] === true) {
+        const nxJson = (0, configuration_1.readNxJson)();
+        if (!onlyDefaultRunnerIsUsed(nxJson))
+            return;
+        output_1.output.log({
+            title: '--cloud requires the workspace to be connected to Nx Cloud.',
+        });
+        (0, child_process_1.runNxSync)(`connect-to-nx-cloud`, {
+            stdio: [0, 1, 2],
+        });
+        output_1.output.success({
+            title: 'Your workspace has been successfully connected to Nx Cloud.',
+        });
+        process.exit(0);
+    }
+}
+async function connectWorkspaceToCloud(options, directory = workspace_root_1.workspaceRoot) {
+    const tree = new tree_1.FsTree(directory, false, 'connect-to-nx-cloud');
+    const accessToken = await (0, connect_to_nx_cloud_1.connectToNxCloud)(tree, options);
+    tree.lock();
+    (0, tree_1.flushChanges)(directory, tree.listChanges());
+    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'
+        : 'nx-connect';
+    const hasRemote = !!(0, git_utils_1.getVcsRemoteInfo)();
+    if (!hasRemote && options.checkRemote) {
+        output_1.output.error({
+            title: 'Missing VCS provider',
+            bodyLines: [
+                'Push this repository to a VCS provider (e.g., GitHub) and try again.',
+                'Go to https://github.com/new to create a repository on GitHub.',
+            ],
+        });
+        return false;
+    }
+    if ((0, nx_cloud_utils_1.isNxCloudUsed)(nxJson)) {
+        const token = process.env.NX_CLOUD_AUTH_TOKEN ||
+            process.env.NX_CLOUD_ACCESS_TOKEN ||
+            nxJson.nxCloudAccessToken ||
+            nxJson.nxCloudId;
+        if (!token) {
+            throw new Error(`Unable to authenticate. If you are connecting to Nx Cloud locally, set Nx Cloud ID in nx.json. If you are connecting in a CI context, either define accessToken in nx.json or set the NX_CLOUD_ACCESS_TOKEN env variable.`);
+        }
+        const connectCloudUrl = await (0, url_shorten_1.createNxCloudOnboardingURL)(installationSource, token, undefined, options?.generateToken === true);
+        output_1.output.log({
+            title: '✔ This workspace already has Nx Cloud set up',
+            bodyLines: [
+                'If you have not done so already, connect your workspace to your Nx Cloud account with the following URL:',
+                '',
+                `${connectCloudUrl}`,
+            ],
+        });
+        return false;
+    }
+    const token = await connectWorkspaceToCloud({
+        generateToken: options?.generateToken,
+        installationSource: command ?? installationSource,
+    });
+    const connectCloudUrl = await (0, url_shorten_1.createNxCloudOnboardingURL)('nx-connect', token, undefined, options?.generateToken === true);
+    try {
+        const cloudConnectSpinner = ora(`Opening Nx Cloud ${connectCloudUrl} in your browser to connect your workspace.`).start();
+        await sleep(2000);
+        const { default: open } = await new Function('return import("open")')();
+        await open(connectCloudUrl);
+        cloudConnectSpinner.succeed();
+    }
+    catch (e) {
+        output_1.output.note({
+            title: `Your Nx Cloud workspace is ready.`,
+            bodyLines: [
+                `To claim it, connect it to your Nx Cloud account:`,
+                `- Go to the following URL to connect your workspace to Nx Cloud:`,
+                '',
+                `${connectCloudUrl}`,
+            ],
+        });
+    }
+    return true;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function connectExistingRepoToNxCloudPrompt(command = 'init', key = 'setupNxCloud', recordCompletion = true) {
+    const res = await nxCloudPrompt(key, utmContentForCommand(command));
+    // TODO: once legacy init-v1 (the NX_ADD_PLUGINS=false / useInferencePlugins:false path) is
+    // removed, drop this recordStat and the recordCompletion flag entirely - init-v2 records its
+    // own complete, and view-logs should record its own stat, so this shared helper won't record.
+    // init-v2 records its own init "complete" stat, so it opts out here to avoid double-counting.
+    // Other callers (e.g. view-logs, legacy init-v1) rely on this as their only completion event.
+    if (recordCompletion) {
+        await (0, ab_testing_1.recordStat)({
+            command,
+            nxVersion: versions_1.nxVersion,
+            useCloud: res === 'yes',
+            meta: {
+                type: 'complete',
+                setupCloudPrompt: ab_testing_1.messages.codeOfSelectedPromptMessage(key) || '',
+                nxCloudArg: res,
+                nodeVersion: process.versions.node,
+                os: process.platform,
+                packageManager: (0, package_manager_1.detectPackageManager)(),
+                aiAgent: (0, native_1.isAiAgent)(),
+                isCI: (0, is_ci_1.isCI)(),
+            },
+        });
+    }
+    return res;
+}
+async function connectToNxCloudWithPrompt(command) {
+    const setNxCloud = await nxCloudPrompt('setupNxCloud', utmContentForCommand(command));
+    let useCloud = false;
+    if (setNxCloud === 'yes') {
+        useCloud = await connectToNxCloudCommand({ generateToken: false }, command);
+    }
+    await (0, ab_testing_1.recordStat)({
+        command,
+        nxVersion: versions_1.nxVersion,
+        useCloud,
+        meta: {
+            type: 'complete',
+            setupCloudPrompt: ab_testing_1.messages.codeOfSelectedPromptMessage('setupNxCloud') || '',
+            nxCloudArg: setNxCloud,
+            nodeVersion: process.versions.node,
+            os: process.platform,
+            packageManager: (0, package_manager_1.detectPackageManager)(),
+            aiAgent: (0, native_1.isAiAgent)(),
+            isCI: (0, is_ci_1.isCI)(),
+        },
+    });
+}
+function utmContentForCommand(command) {
+    switch (command) {
+        case 'migrate':
+            return 'nx-migrate';
+        case 'view-logs':
+            return 'nx-connect';
+        default:
+            return 'nx-init';
+    }
+}
+async function nxCloudPrompt(key, utmContent) {
+    const { message, choices, initial, footer, hint } = ab_testing_1.messages.getPrompt(key);
+    // No separate footer/hint slot, so both are folded into the message.
+    const suffix = [
+        hint,
+        footer && `${footer} ${(0, ab_testing_1.nxCloudHyperlink)(utmContent)}`,
+        `See it in action: ${(0, ab_testing_1.nxCloudDemoHyperlink)(utmContent)}`,
+    ]
+        .filter(Boolean)
+        .map((t) => pc.dim(t));
+    return (await (0, prompt_helpers_1.selectPrompt)({
+        message: [message, ...suffix].join('\n'),
+        // These choices are `{ value, name }` where `name` is the display text,
+        // the inverse of enquirer's usual `{ name, message }`. Prefer `value` so
+        // the answer is the key the caller compares against, not the label.
+        choices: choices.map((c) => typeof c === 'string'
+            ? { value: c, label: c }
+            : { value: c.value ?? c.name, label: c.message ?? c.name ?? c.value }),
+        initial: choices[initial ?? 0]?.value ??
+            choices[initial ?? 0]?.name,
+    }));
+}

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

@@ -0,0 +1 @@
+export declare function viewLogs(): Promise<number>;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.viewLogs = viewLogs;
+const package_manager_1 = require("../../../utils/package-manager");
+const child_process_1 = require("child_process");
+const nx_cloud_utils_1 = require("../../../utils/nx-cloud-utils");
+const output_1 = require("../../../utils/output");
+const nx_json_1 = require("../../../config/nx-json");
+const connect_to_nx_cloud_1 = require("./connect-to-nx-cloud");
+async function viewLogs() {
+    const cloudUsed = (0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)());
+    if (cloudUsed) {
+        output_1.output.error({
+            title: 'Your workspace is already connected to Nx Cloud',
+            bodyLines: [
+                `Refer to the output of the last command to find the Nx Cloud link to view the run details.`,
+            ],
+        });
+        return 1;
+    }
+    const setupNxCloud = await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)('view-logs', 'setupViewLogs');
+    if (setupNxCloud !== 'yes') {
+        return;
+    }
+    try {
+        output_1.output.log({
+            title: 'Connecting to Nx Cloud',
+        });
+        await (0, connect_to_nx_cloud_1.connectWorkspaceToCloud)({
+            installationSource: 'view-logs',
+            generateToken: true,
+        });
+    }
+    catch (e) {
+        output_1.output.log({
+            title: 'Failed to connect to Nx Cloud',
+        });
+        console.log(e);
+        return 1;
+    }
+    const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    // Intentionally not runNxSync: this invokes the separate `nx-cloud` binary,
+    // not the nx CLI that runNxSync resolves.
+    (0, child_process_1.execSync)(`${pmc.exec} nx-cloud upload-and-show-run-details`, {
+        stdio: [0, 1, 2],
+        windowsHide: true,
+    });
+    if (!cloudUsed) {
+        output_1.output.note({
+            title: 'Your workspace is now connected to Nx Cloud',
+            bodyLines: [`Learn more about Nx Cloud at https://nx.dev/nx-cloud`],
+        });
+    }
+    return 0;
+}

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

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

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsDownloadCloudClientCommand = void 0;
+const handle_import_1 = require("../../../utils/handle-import");
+const shared_options_1 = require("../../yargs-utils/shared-options");
+exports.yargsDownloadCloudClientCommand = {
+    command: 'download-cloud-client',
+    describe: 'Download the Nx Cloud client.',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs),
+    handler: async (args) => {
+        process.exit(await (await (0, handle_import_1.handleImport)('./download-cloud-client.js', __dirname)).downloadCloudClientHandler(args));
+    },
+};

package/dist/src/command-line/nx-cloud/download-cloud-client/download-cloud-client.d.ts

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

package/dist/src/command-line/nx-cloud/download-cloud-client/download-cloud-client.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadCloudClientHandler = downloadCloudClientHandler;
+const nx_json_1 = require("../../../config/nx-json");
+const update_manager_1 = require("../../../nx-cloud/update-manager");
+const get_cloud_options_1 = require("../../../nx-cloud/utilities/get-cloud-options");
+const nx_cloud_utils_1 = require("../../../utils/nx-cloud-utils");
+const handle_errors_1 = require("../../../utils/handle-errors");
+const output_1 = require("../../../utils/output");
+function downloadCloudClientHandler(args) {
+    return (0, handle_errors_1.handleErrors)(args.verbose, async () => {
+        // Try to get cloud options from nx.json if available, otherwise
+        // fall back to defaults (env vars / https://cloud.nx.app).
+        let options = {};
+        try {
+            const nxJson = (0, nx_json_1.readNxJson)();
+            if ((0, nx_cloud_utils_1.isNxCloudUsed)(nxJson)) {
+                options = (0, get_cloud_options_1.getCloudOptions)();
+            }
+        }
+        catch {
+            // Not in an Nx workspace — use defaults
+        }
+        const result = await (0, update_manager_1.verifyOrUpdateNxCloudClient)(options);
+        if (result) {
+            output_1.output.success({
+                title: 'Nx Cloud client downloaded successfully',
+                bodyLines: [`Version: ${result.version}`],
+            });
+        }
+    });
+}

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsFixCiCommand = void 0;
+const shared_options_1 = require("../../yargs-utils/shared-options");
+const handle_import_1 = require("../../../utils/handle-import");
+exports.yargsFixCiCommand = {
+    command: 'fix-ci [options]',
+    describe: 'Fixes CI failures. This command is an alias for [`nx-cloud fix-ci`](/ci/reference/nx-cloud-cli#npx-nxcloud-fix-ci).',
+    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)('./fix-ci.js', __dirname)).fixCiHandler(args));
+    },
+};