@ohos-ports/nx 19.8.4-beta.0

package/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>;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsAddCommand = void 0;
+const shared_options_1 = require("../yargs-utils/shared-options");
+exports.yargsAddCommand = {
+    command: 'add <packageSpecifier>',
+    describe: 'Install a plugin and initialize it.',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs)
+        .parserConfiguration({
+        'strip-dashed': true,
+        'unknown-options-as-args': true,
+    })
+        .positional('packageSpecifier', {
+        type: 'string',
+        description: 'The package name and optional version (e.g. `@nx/react` or `@nx/react@latest`) to install and initialize. If the version is not specified it will install the same version as the `nx` package for Nx core plugins or the latest version for other packages.',
+    })
+        .option('updatePackageScripts', {
+        type: 'boolean',
+        description: 'Update `package.json` scripts with inferred targets. Defaults to `true` when the package is a core Nx plugin.',
+    })
+        .example('$0 add @nx/react', 'Install the latest version of the `@nx/react` package and run its `@nx/react:init` generator')
+        .example('$0 add non-core-nx-plugin', 'Install the latest version of the `non-core-nx-plugin` package and run its `non-core-nx-plugin:init` generator if available')
+        .example('$0 add @nx/react@17.0.0', 'Install version `17.0.0` of the `@nx/react` package and run its `@nx/react:init` generator'),
+    handler: async (args) => {
+        process.exit(await Promise.resolve().then(() => require('./add')).then((m) => m.addHandler((0, shared_options_1.withOverrides)(args))));
+    },
+};

package/src/command-line/affected/affected.d.ts

@@ -0,0 +1,10 @@
+import type { NxArgs } from '../../utils/command-line-utils';
+import { ProjectGraph, ProjectGraphProjectNode } from '../../config/project-graph';
+import { TargetDependencyConfig } from '../../config/workspace-json-project-json';
+export declare function affected(command: 'graph' | 'print-affected' | 'affected', args: {
+    [k: string]: any;
+}, extraTargetDependencies?: Record<string, (TargetDependencyConfig | string)[]>, extraOptions?: {
+    excludeTaskDependencies: boolean;
+    loadDotEnvFiles: boolean;
+}): Promise<void>;
+export declare function getAffectedGraphNodes(nxArgs: NxArgs, projectGraph: ProjectGraph): Promise<ProjectGraphProjectNode[]>;

package/src/command-line/affected/affected.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.affected = affected;
+exports.getAffectedGraphNodes = getAffectedGraphNodes;
+const file_utils_1 = require("../../project-graph/file-utils");
+const run_command_1 = require("../../tasks-runner/run-command");
+const output_1 = require("../../utils/output");
+const connect_to_nx_cloud_1 = require("../connect/connect-to-nx-cloud");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const perf_hooks_1 = require("perf_hooks");
+const project_graph_1 = require("../../project-graph/project-graph");
+const project_graph_utils_1 = require("../../utils/project-graph-utils");
+const affected_project_graph_1 = require("../../project-graph/affected/affected-project-graph");
+const configuration_1 = require("../../config/configuration");
+const workspace_configuration_check_1 = require("../../utils/workspace-configuration-check");
+const find_matching_projects_1 = require("../../utils/find-matching-projects");
+const graph_1 = require("../graph/graph");
+const all_file_data_1 = require("../../utils/all-file-data");
+async function affected(command, args, extraTargetDependencies = {}, extraOptions = {
+    excludeTaskDependencies: args.excludeTaskDependencies,
+    loadDotEnvFiles: process.env.NX_LOAD_DOT_ENV_FILES !== 'false',
+}) {
+    perf_hooks_1.performance.mark('code-loading:end');
+    perf_hooks_1.performance.measure('code-loading', 'init-local', 'code-loading:end');
+    (0, workspace_configuration_check_1.workspaceConfigurationCheck)();
+    const nxJson = (0, configuration_1.readNxJson)();
+    const { nxArgs, overrides } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)(args, 'affected', {
+        printWarnings: command !== 'print-affected' && !args.plain && args.graph !== 'stdout',
+    }, nxJson);
+    await (0, connect_to_nx_cloud_1.connectToNxCloudIfExplicitlyAsked)(nxArgs);
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+    const projects = await getAffectedGraphNodes(nxArgs, projectGraph);
+    try {
+        switch (command) {
+            case 'affected': {
+                const projectsWithTarget = allProjectsWithTarget(projects, nxArgs);
+                if (nxArgs.graph) {
+                    const projectNames = projectsWithTarget.map((t) => t.name);
+                    const file = (0, command_line_utils_1.readGraphFileFromGraphArg)(nxArgs);
+                    return await (0, graph_1.generateGraph)({
+                        watch: true,
+                        open: true,
+                        view: 'tasks',
+                        targets: nxArgs.targets,
+                        projects: projectNames,
+                        file,
+                    }, projectNames);
+                }
+                else {
+                    const status = await (0, run_command_1.runCommand)(projectsWithTarget, projectGraph, { nxJson }, nxArgs, overrides, null, extraTargetDependencies, extraOptions);
+                    process.exit(status);
+                }
+                break;
+            }
+        }
+        await output_1.output.drain();
+    }
+    catch (e) {
+        printError(e, args.verbose);
+        process.exit(1);
+    }
+}
+async function getAffectedGraphNodes(nxArgs, projectGraph) {
+    let affectedGraph = nxArgs.all
+        ? projectGraph
+        : await (0, affected_project_graph_1.filterAffected)(projectGraph, (0, file_utils_1.calculateFileChanges)((0, command_line_utils_1.parseFiles)(nxArgs).files, await (0, all_file_data_1.allFileData)(), nxArgs));
+    if (nxArgs.exclude) {
+        const excludedProjects = new Set((0, find_matching_projects_1.findMatchingProjects)(nxArgs.exclude, affectedGraph.nodes));
+        return Object.entries(affectedGraph.nodes)
+            .filter(([projectName]) => !excludedProjects.has(projectName))
+            .map(([, project]) => project);
+    }
+    return Object.values(affectedGraph.nodes);
+}
+function allProjectsWithTarget(projects, nxArgs) {
+    return projects.filter((p) => nxArgs.targets.find((target) => (0, project_graph_utils_1.projectHasTarget)(p, target)));
+}
+function printError(e, verbose) {
+    const bodyLines = [e.message];
+    if (verbose && e.stack) {
+        bodyLines.push('');
+        bodyLines.push(e.stack);
+    }
+    output_1.output.error({
+        title: 'There was a critical error when running your command',
+        bodyLines,
+    });
+}

package/src/command-line/affected/command-object.d.ts

@@ -0,0 +1,6 @@
+import { CommandModule } from 'yargs';
+export declare const yargsAffectedCommand: CommandModule;
+export declare const yargsAffectedTestCommand: CommandModule;
+export declare const yargsAffectedBuildCommand: CommandModule;
+export declare const yargsAffectedLintCommand: CommandModule;
+export declare const yargsAffectedE2ECommand: CommandModule;

package/src/command-line/affected/command-object.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsAffectedE2ECommand = exports.yargsAffectedLintCommand = exports.yargsAffectedBuildCommand = exports.yargsAffectedTestCommand = exports.yargsAffectedCommand = void 0;
+const documentation_1 = require("../yargs-utils/documentation");
+const shared_options_1 = require("../yargs-utils/shared-options");
+const handle_errors_1 = require("../../utils/handle-errors");
+exports.yargsAffectedCommand = {
+    command: 'affected',
+    describe: 'Run target for affected projects.',
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withAffectedOptions)((0, shared_options_1.withRunOptions)((0, shared_options_1.withOutputStyleOption)((0, shared_options_1.withTargetAndConfigurationOption)((0, shared_options_1.withBatch)(yargs)))))
+        .option('all', {
+        type: 'boolean',
+        deprecated: 'Use `nx run-many` instead',
+    })
+        .middleware((args) => {
+        if (args.all !== undefined) {
+            throw new Error("The '--all' option has been removed for `nx affected`. Use 'nx run-many' instead.");
+        }
+    }), 'affected'),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            return (await Promise.resolve().then(() => require('./affected'))).affected('affected', (0, shared_options_1.withOverrides)(args));
+        });
+        process.exit(exitCode);
+    },
+};
+exports.yargsAffectedTestCommand = {
+    command: 'affected:test',
+    describe: false,
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withAffectedOptions)((0, shared_options_1.withRunOptions)((0, shared_options_1.withOutputStyleOption)((0, shared_options_1.withConfiguration)(yargs)))), 'affected'),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            return (await Promise.resolve().then(() => require('./affected'))).affected('affected', {
+                ...(0, shared_options_1.withOverrides)(args),
+                target: 'test',
+            });
+        });
+        process.exit(exitCode);
+    },
+};
+exports.yargsAffectedBuildCommand = {
+    command: 'affected:build',
+    describe: false,
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withAffectedOptions)((0, shared_options_1.withRunOptions)((0, shared_options_1.withOutputStyleOption)((0, shared_options_1.withConfiguration)(yargs)))), 'affected'),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            return (await Promise.resolve().then(() => require('./affected'))).affected('affected', {
+                ...(0, shared_options_1.withOverrides)(args),
+                target: 'build',
+            });
+        });
+        process.exit(exitCode);
+    },
+};
+exports.yargsAffectedLintCommand = {
+    command: 'affected:lint',
+    describe: false,
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withAffectedOptions)((0, shared_options_1.withRunOptions)((0, shared_options_1.withOutputStyleOption)((0, shared_options_1.withConfiguration)(yargs)))), 'affected'),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            return (await Promise.resolve().then(() => require('./affected'))).affected('affected', {
+                ...(0, shared_options_1.withOverrides)(args),
+                target: 'lint',
+            });
+        });
+        process.exit(exitCode);
+    },
+};
+exports.yargsAffectedE2ECommand = {
+    command: 'affected:e2e',
+    describe: false,
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withAffectedOptions)((0, shared_options_1.withRunOptions)((0, shared_options_1.withOutputStyleOption)((0, shared_options_1.withConfiguration)(yargs)))), 'affected'),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            return (await Promise.resolve().then(() => require('./affected'))).affected('affected', {
+                ...(0, shared_options_1.withOverrides)(args),
+                target: 'e2e',
+            });
+        });
+        process.exit(exitCode);
+    },
+};

package/src/command-line/connect/command-object.d.ts

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

package/src/command-line/connect/command-object.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsViewLogsCommand = exports.yargsConnectCommand = void 0;
+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',
+    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) => {
+        await (await Promise.resolve().then(() => require('./connect-to-nx-cloud'))).connectToNxCloudCommand(args);
+        await (await Promise.resolve().then(() => require('../../utils/ab-testing'))).recordStat({
+            command: 'connect',
+            nxVersion: versions_1.nxVersion,
+            useCloud: true,
+        });
+        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 Promise.resolve().then(() => require('./view-logs'))).viewLogs()),
+};

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

@@ -0,0 +1,12 @@
+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 } 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;
+}, command?: string): Promise<boolean>;
+export declare function connectExistingRepoToNxCloudPrompt(command?: string, key?: MessageKey): Promise<boolean>;
+export declare function connectToNxCloudWithPrompt(command: string): Promise<void>;

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

@@ -0,0 +1,149 @@
+"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 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 workspace_root_1 = require("../../utils/workspace-root");
+const chalk = require("chalk");
+const ora = require("ora");
+const open = require("open");
+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_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) {
+    const nxJson = (0, configuration_1.readNxJson)();
+    const installationSource = process.env.NX_CONSOLE
+        ? 'nx-console'
+        : 'nx-connect';
+    if ((0, nx_cloud_utils_1.isNxCloudUsed)(nxJson)) {
+        const 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, 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, options?.generateToken !== true);
+    try {
+        const cloudConnectSpinner = ora(`Opening Nx Cloud ${connectCloudUrl} in your browser to connect your workspace.`).start();
+        await sleep(2000);
+        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') {
+    const res = await nxCloudPrompt(key).then((value) => value === 'yes');
+    await (0, ab_testing_1.recordStat)({
+        command,
+        nxVersion: versions_1.nxVersion,
+        useCloud: res,
+        meta: ab_testing_1.messages.codeOfSelectedPromptMessage(key),
+    });
+    return res;
+}
+async function connectToNxCloudWithPrompt(command) {
+    const setNxCloud = await nxCloudPrompt('setupNxCloud');
+    const useCloud = setNxCloud === 'yes'
+        ? await connectToNxCloudCommand({ generateToken: false }, command)
+        : false;
+    await (0, ab_testing_1.recordStat)({
+        command,
+        nxVersion: versions_1.nxVersion,
+        useCloud,
+        meta: ab_testing_1.messages.codeOfSelectedPromptMessage('setupNxCloud'),
+    });
+}
+async function nxCloudPrompt(key) {
+    const { message, choices, initial, footer, hint } = ab_testing_1.messages.getPrompt(key);
+    const promptConfig = {
+        name: 'NxCloud',
+        message,
+        type: 'autocomplete',
+        choices,
+        initial,
+    }; // meeroslav: types in enquirer are not up to date
+    if (footer) {
+        promptConfig.footer = () => chalk.dim(footer);
+    }
+    if (hint) {
+        promptConfig.hint = () => chalk.dim(hint);
+    }
+    return await (await Promise.resolve().then(() => require('enquirer')))
+        .prompt([promptConfig])
+        .then((a) => {
+        return a.NxCloud;
+    });
+}

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

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

package/src/command-line/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");
+const connect_to_nx_cloud_2 = require("../../nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud");
+const url_shorten_1 = require("../../nx-cloud/utilities/url-shorten");
+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) {
+        return;
+    }
+    try {
+        output_1.output.log({
+            title: 'Connecting to Nx Cloud',
+        });
+        const token = await (0, connect_to_nx_cloud_1.connectWorkspaceToCloud)({
+            installationSource: 'view-logs',
+        });
+        await (0, connect_to_nx_cloud_2.printSuccessMessage)(token, 'view-logs', await (0, url_shorten_1.repoUsesGithub)());
+    }
+    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)();
+    (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.app`],
+        });
+    }
+    return 0;
+}

package/src/command-line/daemon/command-object.d.ts

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

package/src/command-line/daemon/command-object.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsDaemonCommand = void 0;
+const documentation_1 = require("../yargs-utils/documentation");
+exports.yargsDaemonCommand = {
+    command: 'daemon',
+    describe: 'Prints information about the Nx Daemon process or starts a daemon process.',
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)(withDaemonOptions(yargs), 'daemon'),
+    handler: async (args) => (await Promise.resolve().then(() => require('./daemon'))).daemonHandler(args),
+};
+function withDaemonOptions(yargs) {
+    return yargs
+        .option('start', {
+        type: 'boolean',
+        default: false,
+    })
+        .option('stop', {
+        type: 'boolean',
+        default: false,
+    });
+}

package/src/command-line/daemon/daemon.d.ts

@@ -0,0 +1,2 @@
+import type { Arguments } from 'yargs';
+export declare function daemonHandler(args: Arguments): Promise<void>;

package/src/command-line/daemon/daemon.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.daemonHandler = daemonHandler;
+const tmp_dir_1 = require("../../daemon/tmp-dir");
+const output_1 = require("../../utils/output");
+const generate_help_output_1 = require("../../daemon/client/generate-help-output");
+async function daemonHandler(args) {
+    if (args.start) {
+        const { daemonClient } = await Promise.resolve().then(() => require('../../daemon/client/client'));
+        const pid = await daemonClient.startInBackground();
+        output_1.output.log({
+            title: `Daemon Server - Started in a background process...`,
+            bodyLines: [
+                `${output_1.output.dim('Logs from the Daemon process (')}ID: ${pid}${output_1.output.dim(') can be found here:')} ${tmp_dir_1.DAEMON_OUTPUT_LOG_FILE}\n`,
+            ],
+        });
+    }
+    else if (args.stop) {
+        const { daemonClient } = await Promise.resolve().then(() => require('../../daemon/client/client'));
+        await daemonClient.stop();
+        output_1.output.log({ title: 'Daemon Server - Stopped' });
+    }
+    else {
+        console.log((0, generate_help_output_1.generateDaemonHelpOutput)());
+    }
+}

package/src/command-line/deprecated/command-objects.d.ts

@@ -0,0 +1,9 @@
+import { CommandModule } from 'yargs';
+/**
+ * @deprecated 'Use `nx graph --affected`, or` nx affected --graph` instead depending on which best suits your use case. The `affected:graph` command will be removed in Nx 19.'
+ */
+export declare const yargsAffectedGraphCommand: CommandModule;
+/**
+ * @deprecated 'Use `nx show --affected`, `nx affected --graph` or `nx graph --affected` depending on which best suits your use case. The `print-affected` command will be removed in Nx 19.'
+ */
+export declare const yargsPrintAffectedCommand: CommandModule;

package/src/command-line/deprecated/command-objects.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsPrintAffectedCommand = exports.yargsAffectedGraphCommand = void 0;
+const handle_errors_1 = require("../../utils/handle-errors");
+const shared_options_1 = require("../yargs-utils/shared-options");
+const command_object_1 = require("../graph/command-object");
+const affectedGraphDeprecationMessage = 'Use `nx graph --affected`, or `nx affected --graph` instead depending on which best suits your use case. The `affected:graph` command has been removed in Nx 19.';
+const printAffectedDeprecationMessage = 'Use `nx show projects --affected`, `nx affected --graph -t build` or `nx graph --affected` depending on which best suits your use case. The `print-affected` command has been removed in Nx 19.';
+/**
+ * @deprecated 'Use `nx graph --affected`, or` nx affected --graph` instead depending on which best suits your use case. The `affected:graph` command will be removed in Nx 19.'
+ */
+exports.yargsAffectedGraphCommand = {
+    command: 'affected:graph',
+    describe: false,
+    aliases: ['affected:dep-graph'],
+    builder: (yargs) => (0, shared_options_1.withAffectedOptions)((0, command_object_1.withGraphOptions)(yargs)),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(false, () => {
+            throw new Error(affectedGraphDeprecationMessage);
+        });
+        process.exit(exitCode);
+    },
+    deprecated: affectedGraphDeprecationMessage,
+};
+/**
+ * @deprecated 'Use `nx show --affected`, `nx affected --graph` or `nx graph --affected` depending on which best suits your use case. The `print-affected` command will be removed in Nx 19.'
+ */
+exports.yargsPrintAffectedCommand = {
+    command: 'print-affected',
+    describe: false,
+    builder: (yargs) => (0, shared_options_1.withAffectedOptions)((0, shared_options_1.withTargetAndConfigurationOption)(yargs, false))
+        .option('select', {
+        type: 'string',
+        describe: 'Select the subset of the returned json document (e.g., --select=projects).',
+    })
+        .option('type', {
+        type: 'string',
+        choices: ['app', 'lib'],
+        describe: 'Select the type of projects to be returned (e.g., --type=app).',
+    }),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(false, () => {
+            throw new Error(printAffectedDeprecationMessage);
+        });
+        process.exit(exitCode);
+    },
+    deprecated: printAffectedDeprecationMessage,
+};

package/src/command-line/examples.d.ts

@@ -0,0 +1,5 @@
+export interface Example {
+    command: string;
+    description: string;
+}
+export declare const examples: Record<string, Example[]>;