@ohos-ports/nx 17.3.2-beta.0

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAffectedGraphNodes = exports.affected = void 0;
+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 print_affected_1 = require("./print-affected");
+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");
+const logger_1 = require("../../utils/logger");
+const command_object_1 = require("./command-object");
+async function affected(command, args, extraTargetDependencies = {}) {
+    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);
+    if (nxArgs.verbose) {
+        process.env.NX_VERBOSE_LOGGING = 'true';
+    }
+    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 'graph':
+                logger_1.logger.warn([logger_1.NX_PREFIX, command_object_1.affectedGraphDeprecationMessage].join(' '));
+                const projectNames = projects.map((p) => p.name);
+                await (0, graph_1.generateGraph)(args, projectNames);
+                break;
+            case 'print-affected':
+                if (nxArgs.targets && nxArgs.targets.length > 0) {
+                    await (0, print_affected_1.printAffected)(allProjectsWithTarget(projects, nxArgs), projectGraph, { nxJson }, nxArgs, overrides);
+                }
+                else {
+                    await (0, print_affected_1.printAffected)(projects, projectGraph, { nxJson }, nxArgs, overrides);
+                }
+                break;
+            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: false,
+                        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, { excludeTaskDependencies: false, loadDotEnvFiles: true });
+                    process.exit(status);
+                }
+                break;
+            }
+        }
+        await output_1.output.drain();
+    }
+    catch (e) {
+        printError(e, args.verbose);
+        process.exit(1);
+    }
+}
+exports.affected = affected;
+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);
+}
+exports.getAffectedGraphNodes = getAffectedGraphNodes;
+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,16 @@
+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;
+export declare const affectedGraphDeprecationMessage = "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.";
+/**
+ * @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;
+export declare 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 will be removed in Nx 19.";
+/**
+ * @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/affected/command-object.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsPrintAffectedCommand = exports.printAffectedDeprecationMessage = exports.yargsAffectedGraphCommand = exports.affectedGraphDeprecationMessage = 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");
+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) => (await Promise.resolve().then(() => require('./affected'))).affected('affected', (0, shared_options_1.withOverrides)(args)),
+};
+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) => (await Promise.resolve().then(() => require('./affected'))).affected('affected', {
+        ...(0, shared_options_1.withOverrides)(args),
+        target: 'test',
+    }),
+};
+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) => (await Promise.resolve().then(() => require('./affected'))).affected('affected', {
+        ...(0, shared_options_1.withOverrides)(args),
+        target: 'build',
+    }),
+};
+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) => (await Promise.resolve().then(() => require('./affected'))).affected('affected', {
+        ...(0, shared_options_1.withOverrides)(args),
+        target: 'lint',
+    }),
+};
+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) => (await Promise.resolve().then(() => require('./affected'))).affected('affected', {
+        ...(0, shared_options_1.withOverrides)(args),
+        target: 'e2e',
+    }),
+};
+exports.affectedGraphDeprecationMessage = '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.';
+/**
+ * @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: 'Graph dependencies affected by changes',
+    aliases: ['affected:dep-graph'],
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withAffectedOptions)((0, shared_options_1.withDepGraphOptions)(yargs)), 'affected:graph'),
+    handler: async (args) => await (await Promise.resolve().then(() => require('./affected'))).affected('graph', {
+        ...args,
+    }),
+    deprecated: exports.affectedGraphDeprecationMessage,
+};
+exports.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 will be removed in Nx 19.';
+/**
+ * @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: 'Prints information about the projects and targets affected by changes',
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withAffectedOptions)((0, shared_options_1.withTargetAndConfigurationOption)(yargs, false)), 'print-affected')
+        .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) => {
+        await (await Promise.resolve().then(() => require('./affected'))).affected('print-affected', (0, shared_options_1.withOverrides)(args));
+        process.exit(0);
+    },
+    deprecated: exports.printAffectedDeprecationMessage,
+};

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

@@ -0,0 +1,11 @@
+import * as yargs from 'yargs';
+import type { NxArgs } from '../../utils/command-line-utils';
+import { ProjectGraph, ProjectGraphProjectNode } from '../../config/project-graph';
+import { NxJsonConfiguration } from '../../config/nx-json';
+/**
+ * @deprecated Use showProjectsHandler, generateGraph, or affected (without the print-affected mode) instead.
+ */
+export declare function printAffected(affectedProjects: ProjectGraphProjectNode[], projectGraph: ProjectGraph, { nxJson }: {
+    nxJson: NxJsonConfiguration;
+}, nxArgs: NxArgs, overrides: yargs.Arguments): Promise<void>;
+export declare function selectPrintAffected(wholeJson: any, wholeSelect: string): any;

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectPrintAffected = exports.printAffected = void 0;
+const utils_1 = require("../../tasks-runner/utils");
+const create_task_graph_1 = require("../../tasks-runner/create-task-graph");
+const task_hasher_1 = require("../../hasher/task-hasher");
+const hash_task_1 = require("../../hasher/hash-task");
+const package_manager_1 = require("../../utils/package-manager");
+const command_object_1 = require("./command-object");
+const logger_1 = require("../../utils/logger");
+const task_env_1 = require("../../tasks-runner/task-env");
+const build_project_graph_1 = require("../../project-graph/build-project-graph");
+const client_1 = require("../../daemon/client/client");
+/**
+ * @deprecated Use showProjectsHandler, generateGraph, or affected (without the print-affected mode) instead.
+ */
+async function printAffected(affectedProjects, projectGraph, { nxJson }, nxArgs, overrides) {
+    logger_1.logger.warn([logger_1.NX_PREFIX, command_object_1.printAffectedDeprecationMessage].join(' '));
+    const projectsForType = affectedProjects.filter((p) => nxArgs.type ? p.type === nxArgs.type : true);
+    const projectNames = projectsForType.map((p) => p.name);
+    const tasksJson = nxArgs.targets && nxArgs.targets.length > 0
+        ? await createTasks(projectsForType, projectGraph, nxArgs, nxJson, overrides)
+        : [];
+    const result = {
+        tasks: tasksJson,
+        projects: projectNames,
+        projectGraph: serializeProjectGraph(projectGraph),
+    };
+    if (nxArgs.select) {
+        console.log(selectPrintAffected(result, nxArgs.select));
+    }
+    else {
+        console.log(JSON.stringify(selectPrintAffected(result, null), null, 2));
+    }
+}
+exports.printAffected = printAffected;
+async function createTasks(affectedProjectsWithTargetAndConfig, projectGraph, nxArgs, nxJson, overrides) {
+    const defaultDependencyConfigs = (0, create_task_graph_1.mapTargetDefaultsToDependencies)(nxJson.targetDefaults);
+    const taskGraph = (0, create_task_graph_1.createTaskGraph)(projectGraph, defaultDependencyConfigs, affectedProjectsWithTargetAndConfig.map((p) => p.name), nxArgs.targets, nxArgs.configuration, overrides);
+    let hasher;
+    if (client_1.daemonClient.enabled()) {
+        hasher = new task_hasher_1.DaemonBasedTaskHasher(client_1.daemonClient, {});
+    }
+    else {
+        const { fileMap, allWorkspaceFiles, rustReferences } = (0, build_project_graph_1.getFileMap)();
+        hasher = new task_hasher_1.InProcessTaskHasher(fileMap?.projectFileMap, allWorkspaceFiles, projectGraph, nxJson, rustReferences, {});
+    }
+    const execCommand = (0, package_manager_1.getPackageManagerCommand)().exec;
+    const tasks = Object.values(taskGraph.tasks);
+    await Promise.all(tasks.map((t) => (0, hash_task_1.hashTask)(hasher, projectGraph, taskGraph, t, 
+    // This loads dotenv files for the task
+    (0, task_env_1.getTaskSpecificEnv)(t))));
+    return tasks.map((task) => ({
+        id: task.id,
+        overrides,
+        target: task.target,
+        hash: task.hash,
+        command: (0, utils_1.getCommandAsString)(execCommand, task),
+        outputs: task.outputs,
+    }));
+}
+function serializeProjectGraph(projectGraph) {
+    const nodes = Object.values(projectGraph.nodes).map((n) => n.name);
+    const dependencies = {};
+    // we don't need external dependencies' dependencies for print-affected
+    // having them included makes the output unreadable
+    Object.keys(projectGraph.dependencies).forEach((key) => {
+        if (!key.startsWith('npm:')) {
+            dependencies[key] = projectGraph.dependencies[key];
+        }
+    });
+    return { nodes, dependencies };
+}
+function selectPrintAffected(wholeJson, wholeSelect) {
+    if (!wholeSelect)
+        return wholeJson;
+    return _select(wholeJson, wholeSelect);
+    function _select(json, select) {
+        if (select.indexOf('.') > -1) {
+            const [firstKey, ...restKeys] = select.split('.');
+            const first = json[firstKey];
+            throwIfEmpty(wholeSelect, first);
+            const rest = restKeys.join('.');
+            if (Array.isArray(first)) {
+                return first.map((q) => _select(q, rest)).join(', ');
+            }
+            else {
+                return _select(first, rest);
+            }
+        }
+        else {
+            const res = json[select];
+            throwIfEmpty(wholeSelect, res);
+            if (Array.isArray(res)) {
+                return res.join(', ');
+            }
+            else {
+                return res;
+            }
+        }
+    }
+}
+exports.selectPrintAffected = selectPrintAffected;
+function throwIfEmpty(select, value) {
+    if (value === undefined) {
+        throw new Error(`Cannot select '${select}' in the results of print-affected.`);
+    }
+}

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,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsViewLogsCommand = exports.yargsConnectCommand = void 0;
+const documentation_1 = require("../yargs-utils/documentation");
+exports.yargsConnectCommand = {
+    command: 'connect',
+    aliases: ['connect-to-nx-cloud'],
+    describe: `Connect workspace to Nx Cloud`,
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)(yargs, 'connect-to-nx-cloud'),
+    handler: async () => {
+        await (await Promise.resolve().then(() => require('./connect-to-nx-cloud'))).connectToNxCloudCommand();
+        process.exit(0);
+    },
+};
+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,8 @@
+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 connectToNxCloudCommand(): Promise<boolean>;
+export declare function connectToNxCloudWithPrompt(command: string): Promise<void>;
+export declare function connectExistingRepoToNxCloudPrompt(key?: MessageKey): Promise<boolean>;

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectExistingRepoToNxCloudPrompt = exports.connectToNxCloudWithPrompt = exports.connectToNxCloudCommand = exports.connectToNxCloudIfExplicitlyAsked = exports.onlyDefaultRunnerIsUsed = void 0;
+const output_1 = require("../../utils/output");
+const configuration_1 = require("../../config/configuration");
+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 chalk = require("chalk");
+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);
+    }
+    return defaultRunner === 'nx/tasks-runners/default';
+}
+exports.onlyDefaultRunnerIsUsed = onlyDefaultRunnerIsUsed;
+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);
+    }
+}
+exports.connectToNxCloudIfExplicitlyAsked = connectToNxCloudIfExplicitlyAsked;
+async function connectToNxCloudCommand() {
+    const nxJson = (0, configuration_1.readNxJson)();
+    if ((0, nx_cloud_utils_1.isNxCloudUsed)(nxJson)) {
+        output_1.output.log({
+            title: '✅ This workspace is already connected to Nx Cloud.',
+            bodyLines: [
+                'This means your workspace can use computation caching, distributed task execution, and show you run analytics.',
+                'Go to https://nx.app to learn more.',
+                ' ',
+                'If you have not done so already, please claim this workspace:',
+                `${(0, nx_cloud_utils_1.getNxCloudUrl)(nxJson)}/orgs/workspace-setup?accessToken=${(0, nx_cloud_utils_1.getNxCloudToken)(nxJson)}`,
+            ],
+        });
+        return false;
+    }
+    (0, child_process_1.runNxSync)(`g nx:connect-to-nx-cloud --quiet --no-interactive`, {
+        stdio: [0, 1, 2],
+    });
+    return true;
+}
+exports.connectToNxCloudCommand = connectToNxCloudCommand;
+async function connectToNxCloudWithPrompt(command) {
+    const setNxCloud = await nxCloudPrompt('setupNxCloud');
+    const useCloud = setNxCloud ? await connectToNxCloudCommand() : false;
+    await (0, ab_testing_1.recordStat)({
+        command,
+        nxVersion: versions_1.nxVersion,
+        useCloud,
+        meta: ab_testing_1.messages.codeOfSelectedPromptMessage('setupNxCloud'),
+    });
+}
+exports.connectToNxCloudWithPrompt = connectToNxCloudWithPrompt;
+async function connectExistingRepoToNxCloudPrompt(key = 'setupNxCloud') {
+    return nxCloudPrompt(key).then((value) => value === 'yes');
+}
+exports.connectExistingRepoToNxCloudPrompt = connectExistingRepoToNxCloudPrompt;
+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,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.viewLogs = void 0;
+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 child_process_2 = require("../../utils/child-process");
+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)('setupViewLogs');
+    if (!setupNxCloud) {
+        return;
+    }
+    try {
+        output_1.output.log({
+            title: 'Connecting to Nx Cloud',
+        });
+        (0, child_process_2.runNxSync)(`g nx:connect-to-nx-cloud --installation-source=view-logs --quiet --no-interactive`, {
+            stdio: 'ignore',
+        });
+    }
+    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],
+    });
+    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;
+}
+exports.viewLogs = viewLogs;

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,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.daemonHandler = void 0;
+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)());
+    }
+}
+exports.daemonHandler = daemonHandler;

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[]>;