nx 19.7.2 → 19.7.4

package/src/tasks-runner/run-command.js

@@ -11,12 +11,13 @@ const nx_json_1 = require("../config/nx-json");
 const client_1 = require("../daemon/client/client");
 const create_task_hasher_1 = require("../hasher/create-task-hasher");
 const hash_task_1 = require("../hasher/hash-task");
+const native_1 = require("../native");
 const project_graph_1 = require("../project-graph/project-graph");
 const fileutils_1 = require("../utils/fileutils");
 const is_ci_1 = require("../utils/is-ci");
 const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
 const output_1 = require("../utils/output");
-const params_1 = require("../utils/params");
+const handle_errors_1 = require("../utils/handle-errors");
 const sync_generators_1 = require("../utils/sync-generators");
 const workspace_root_1 = require("../utils/workspace-root");
 const create_task_graph_1 = require("./create-task-graph");
@@ -33,7 +34,6 @@ const task_timings_life_cycle_1 = require("./life-cycles/task-timings-life-cycle
 const task_graph_utils_1 = require("./task-graph-utils");
 const utils_1 = require("./utils");
 const chalk = require("chalk");
-const native_1 = require("../native");
 async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides) {
     const { runnerOptions } = getRunner(nxArgs, nxJson);
     const isRunOne = initiatingProject != null;
@@ -98,7 +98,7 @@ function createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies,
     return taskGraph;
 }
 async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
-    const status = await (0, params_1.handleErrors)(process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+    const status = await (0, handle_errors_1.handleErrors)(process.env.NX_VERBOSE_LOGGING === 'true', async () => {
         const projectNames = projectsToRun.map((t) => t.name);
         const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
         const tasks = Object.values(taskGraph.tasks);
@@ -135,14 +135,49 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
         // There are no changes to sync, workspace is up to date
         return { projectGraph, taskGraph };
     }
+    const { failedGeneratorsCount, areAllResultsFailures, anySyncGeneratorsFailed, } = (0, sync_generators_1.processSyncGeneratorResultErrors)(results);
+    const failedSyncGeneratorsFixMessageLines = (0, sync_generators_1.getFailedSyncGeneratorsFixMessageLines)(results, nxArgs.verbose);
     const outOfSyncTitle = 'The workspace is out of sync';
-    const resultBodyLines = [...(0, sync_generators_1.syncGeneratorResultsToMessageLines)(results), ''];
-    const fixMessage = 'You can manually run `nx sync` to update your workspace or you can set `sync.applyChanges` to `true` in your `nx.json` to apply the changes automatically when running tasks in interactive environments.';
-    const willErrorOnCiMessage = 'Please note that this will be an error on CI.';
+    const resultBodyLines = (0, sync_generators_1.getSyncGeneratorSuccessResultsMessageLines)(results);
+    const fixMessage = 'You can manually run `nx sync` to update your workspace with the identified changes or you can set `sync.applyChanges` to `true` in your `nx.json` to apply the changes automatically when running tasks in interactive environments.';
+    const willErrorOnCiMessage = 'Please note that having the workspace out of sync will result in an error in CI.';
     if ((0, is_ci_1.isCI)() || !process.stdout.isTTY) {
         // If the user is running in CI or is running in a non-TTY environment we
         // throw an error to stop the execution of the tasks.
-        throw new Error(`${outOfSyncTitle}\n${resultBodyLines.join('\n')}\n${fixMessage}`);
+        if (areAllResultsFailures) {
+            output_1.output.error({
+                title: `The workspace is probably out of sync because ${failedGeneratorsCount === 1
+                    ? 'a sync generator'
+                    : 'some sync generators'} failed to run`,
+                bodyLines: failedSyncGeneratorsFixMessageLines,
+            });
+        }
+        else {
+            output_1.output.error({
+                title: outOfSyncTitle,
+                bodyLines: [...resultBodyLines, '', fixMessage],
+            });
+            if (anySyncGeneratorsFailed) {
+                output_1.output.error({
+                    title: failedGeneratorsCount === 1
+                        ? 'A sync generator failed to run'
+                        : 'Some sync generators failed to run',
+                    bodyLines: failedSyncGeneratorsFixMessageLines,
+                });
+            }
+        }
+        process.exit(1);
+    }
+    if (areAllResultsFailures) {
+        output_1.output.warn({
+            title: `The workspace is probably out of sync because ${failedGeneratorsCount === 1
+                ? 'a sync generator'
+                : 'some sync generators'} failed to run`,
+            bodyLines: failedSyncGeneratorsFixMessageLines,
+        });
+        await confirmRunningTasksWithSyncFailures();
+        // if all sync generators failed to run there's nothing to sync, we just let the tasks run
+        return { projectGraph, taskGraph };
     }
     if (nxJson.sync?.applyChanges === false) {
         // If the user has set `sync.applyChanges` to `false` in their `nx.json`
@@ -153,19 +188,30 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
             title: outOfSyncTitle,
             bodyLines: [
                 ...resultBodyLines,
-                'Your workspace is set to not apply changes automatically (`sync.applyChanges` is set to `false` in your `nx.json`).',
+                '',
+                'Your workspace is set to not apply the identified changes automatically (`sync.applyChanges` is set to `false` in your `nx.json`).',
                 willErrorOnCiMessage,
                 fixMessage,
             ],
         });
+        if (anySyncGeneratorsFailed) {
+            output_1.output.warn({
+                title: failedGeneratorsCount === 1
+                    ? 'A sync generator failed to run'
+                    : 'Some sync generators failed to run',
+                bodyLines: failedSyncGeneratorsFixMessageLines,
+            });
+            await confirmRunningTasksWithSyncFailures();
+        }
         return { projectGraph, taskGraph };
     }
     output_1.output.warn({
         title: outOfSyncTitle,
         bodyLines: [
             ...resultBodyLines,
+            '',
             nxJson.sync?.applyChanges === true
-                ? 'Proceeding to sync the changes automatically (`sync.applyChanges` is set to `true` in your `nx.json`).'
+                ? 'Proceeding to sync the identified changes automatically (`sync.applyChanges` is set to `true` in your `nx.json`).'
                 : willErrorOnCiMessage,
         ],
     });
@@ -175,31 +221,66 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
         const spinner = ora('Syncing the workspace...');
         spinner.start();
         // Flush sync generator changes to disk
-        await (0, sync_generators_1.flushSyncGeneratorChanges)(results);
+        const flushResult = await (0, sync_generators_1.flushSyncGeneratorChanges)(results);
+        if ('generatorFailures' in flushResult) {
+            spinner.fail();
+            output_1.output.error({
+                title: 'Failed to sync the workspace',
+                bodyLines: [
+                    ...(0, sync_generators_1.getFlushFailureMessageLines)(flushResult, nxArgs.verbose),
+                    ...(flushResult.generalFailure
+                        ? [
+                            'If needed, you can run the tasks with the `--skip-sync` flag to disable syncing.',
+                        ]
+                        : []),
+                ],
+            });
+            await confirmRunningTasksWithSyncFailures();
+        }
         // Re-create project graph and task graph
         projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
         taskGraph = createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies ?? {}, projectNames, nxArgs, overrides, extraOptions);
-        if (nxJson.sync?.applyChanges === true) {
-            spinner.succeed(`The workspace was synced successfully!
-
-Please make sure to commit the changes to your repository or this will error on CI.`);
-        }
-        else {
-            // The user was prompted and we already logged a message about erroring on CI
-            // so here we just tell them to commit the changes.
-            spinner.succeed(`The workspace was synced successfully!
-
-Please make sure to commit the changes to your repository.`);
+        const successTitle = anySyncGeneratorsFailed
+            ? // the identified changes were synced successfully, but the workspace
+                // is still not up to date, which we'll mention next
+                'The identified changes were synced successfully!'
+            : // the workspace is fully up to date
+                'The workspace was synced successfully!';
+        const successSubtitle = nxJson.sync?.applyChanges === true
+            ? 'Please make sure to commit the changes to your repository or this will error in CI.'
+            : // The user was prompted and we already logged a message about erroring in CI
+                // so here we just tell them to commit the changes.
+                'Please make sure to commit the changes to your repository.';
+        spinner.succeed(`${successTitle}\n\n${successSubtitle}`);
+        if (anySyncGeneratorsFailed) {
+            output_1.output.warn({
+                title: `The workspace is probably still out of sync because ${failedGeneratorsCount === 1
+                    ? 'a sync generator'
+                    : 'some sync generators'} failed to run`,
+                bodyLines: failedSyncGeneratorsFixMessageLines,
+            });
+            await confirmRunningTasksWithSyncFailures();
         }
     }
     else {
-        output_1.output.warn({
-            title: 'Syncing the workspace was skipped',
-            bodyLines: [
-                'This could lead to unexpected results or errors when running tasks.',
-                fixMessage,
-            ],
-        });
+        if (anySyncGeneratorsFailed) {
+            output_1.output.warn({
+                title: failedGeneratorsCount === 1
+                    ? 'A sync generator failed to report the sync status'
+                    : 'Some sync generators failed to report the sync status',
+                bodyLines: failedSyncGeneratorsFixMessageLines,
+            });
+            await confirmRunningTasksWithSyncFailures();
+        }
+        else {
+            output_1.output.warn({
+                title: 'Syncing the workspace was skipped',
+                bodyLines: [
+                    'This could lead to unexpected results or errors when running tasks.',
+                    fixMessage,
+                ],
+            });
+        }
     }
     return { projectGraph, taskGraph };
 }
@@ -208,7 +289,7 @@ async function promptForApplyingSyncGeneratorChanges() {
         const promptConfig = {
             name: 'applyChanges',
             type: 'select',
-            message: 'Would you like to sync the changes to get your worskpace up to date?',
+            message: 'Would you like to sync the identified changes to get your worskpace up to date?',
             choices: [
                 {
                     name: 'yes',
@@ -227,6 +308,35 @@ async function promptForApplyingSyncGeneratorChanges() {
         process.exit(1);
     }
 }
+async function confirmRunningTasksWithSyncFailures() {
+    try {
+        const promptConfig = {
+            name: 'runTasks',
+            type: 'select',
+            message: 'Would you like to ignore the sync failures and continue running the tasks?',
+            choices: [
+                {
+                    name: 'yes',
+                    message: 'Yes, ignore the failures and run the tasks',
+                },
+                {
+                    name: 'no',
+                    message: `No, don't run the tasks`,
+                },
+            ],
+            footer: () => chalk.dim(`\nWhen running in CI and there are sync failures, the tasks won't run. Addressing the errors above is highly recommended to prevent failures in CI.`),
+        };
+        const runTasks = await (0, enquirer_1.prompt)([
+            promptConfig,
+        ]).then(({ runTasks }) => runTasks === 'yes');
+        if (!runTasks) {
+            process.exit(1);
+        }
+    }
+    catch {
+        process.exit(1);
+    }
+}
 function setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles) {
     if (nxArgs.outputStyle == 'stream' ||
         process.env.NX_BATCH_MODE === 'true' ||
@@ -329,7 +439,9 @@ function constructLifeCycles(lifeCycle) {
         lifeCycles.push(new task_profiling_life_cycle_1.TaskProfilingLifeCycle(process.env.NX_PROFILE));
     }
     if (!(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
-        lifeCycles.push(!native_1.IS_WASM ? new task_history_life_cycle_1.TaskHistoryLifeCycle() : new task_history_life_cycle_old_1.LegacyTaskHistoryLifeCycle());
+        lifeCycles.push(process.env.NX_DISABLE_DB !== 'true' && !native_1.IS_WASM
+            ? new task_history_life_cycle_1.TaskHistoryLifeCycle()
+            : new task_history_life_cycle_old_1.LegacyTaskHistoryLifeCycle());
     }
     return lifeCycles;
 }

package/src/tasks-runner/task-orchestrator.d.ts

@@ -40,7 +40,6 @@ export declare class TaskOrchestrator {
     private runTaskInForkedProcess;
     private preRunSteps;
     private postRunSteps;
-    private scheduleNextTasks;
     private complete;
     private pipeOutputCapture;
     private shouldCacheTaskResult;

package/src/tasks-runner/task-orchestrator.js

@@ -43,7 +43,7 @@ class TaskOrchestrator {
         // Init the ForkedProcessTaskRunner
         await this.forkedProcessTaskRunner.init();
         // initial scheduling
-        await this.scheduleNextTasks();
+        await this.tasksSchedule.scheduleNextTasks();
         perf_hooks_1.performance.mark('task-execution:start');
         const threads = [];
         process.stdout.setMaxListeners(this.options.parallel + events_1.defaultMaxListeners);
@@ -65,6 +65,7 @@ class TaskOrchestrator {
         }
         const doNotSkipCache = this.options.skipNxCache === false ||
             this.options.skipNxCache === undefined;
+        this.processAllScheduledTasks();
         const batch = this.tasksSchedule.nextBatch();
         if (batch) {
             const groupId = this.closeGroup();
@@ -373,15 +374,11 @@ class TaskOrchestrator {
                 status,
             };
         }));
-        await this.scheduleNextTasks();
+        await this.tasksSchedule.scheduleNextTasks();
         // release blocked threads
         this.waitingForTasks.forEach((f) => f(null));
         this.waitingForTasks.length = 0;
     }
-    async scheduleNextTasks() {
-        await this.tasksSchedule.scheduleNextTasks();
-        this.processAllScheduledTasks();
-    }
     complete(taskResults) {
         this.tasksSchedule.complete(taskResults.map(({ taskId }) => taskId));
         for (const { taskId, status } of taskResults) {

package/src/utils/git-utils.d.ts

@@ -25,10 +25,11 @@ export declare class GitRepository {
     deleteGitRemote(name: string): Promise<string>;
     addGitRemote(name: string, url: string): Promise<string>;
     hasFilterRepoInstalled(): Promise<boolean>;
-    filterRepo(subdirectory: string): Promise<string>;
-    filterBranch(subdirectory: string, branchName: string): Promise<string>;
+    filterRepo(source: string, destination: string): Promise<void>;
+    filterBranch(source: string, destination: string, branchName: string): Promise<void>;
     private execAsync;
     private quotePath;
+    private quoteArg;
 }
 /**
  * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.

package/src/utils/git-utils.index-filter.js

@@ -0,0 +1,20 @@
+/**
+ * This is meant to be used with `git filter-branch --index-filter` to rewrite
+ * history such that only commits related to the subdirectory is kept.
+ *
+ * Example:
+ * NX_IMPORT_SOURCE=<source> git filter-branch --index-filter 'node git-utils.index-filter.js' --prune-empty -- --all
+ */
+try {
+    const { execSync } = require('child_process');
+    // NOTE: Using env vars because Windows PowerShell has its own handling of quotes (") messes up quotes in args, even if escaped.
+    const src = process.env.NX_IMPORT_SOURCE;
+    execSync('git read-tree --empty', { stdio: 'inherit' });
+    execSync(`git reset ${process.env.GIT_COMMIT} -- "${src}"`, {
+        stdio: 'inherit',
+    });
+}
+catch (error) {
+    console.error(`Error executing Git commands: ${error}`);
+    process.exit(1);
+}

package/src/utils/git-utils.js

@@ -105,32 +105,63 @@ class GitRepository {
     }
     // git-filter-repo is much faster than filter-branch, but needs to be installed by user
     // Use `hasFilterRepoInstalled` to check if it's installed
-    async filterRepo(subdirectory) {
-        // filter-repo requires POSIX path to work
-        const posixPath = subdirectory.split(path_1.sep).join(path_1.posix.sep);
-        return await this.execAsync(`git filter-repo -f --subdirectory-filter ${this.quotePath(posixPath)}`);
-    }
-    async filterBranch(subdirectory, branchName) {
-        // filter-repo requires POSIX path to work
-        const posixPath = subdirectory.split(path_1.sep).join(path_1.posix.sep);
+    async filterRepo(source, destination) {
+        // NOTE: filter-repo requires POSIX path to work
+        const sourcePosixPath = source.split(path_1.sep).join(path_1.posix.sep);
+        const destinationPosixPath = destination.split(path_1.sep).join(path_1.posix.sep);
+        await this.execAsync(`git filter-repo -f ${source !== '' ? `--path ${this.quotePath(sourcePosixPath)}` : ''} ${source !== destination
+            ? `--path-rename ${this.quotePath(sourcePosixPath, true)}:${this.quotePath(destinationPosixPath, true)}`
+            : ''}`);
+    }
+    async filterBranch(source, destination, branchName) {
         // We need non-ASCII file names to not be quoted, or else filter-branch will exclude them.
         await this.execAsync(`git config core.quotepath false`);
-        return await this.execAsync(`git filter-branch --subdirectory-filter ${this.quotePath(posixPath)} -- ${branchName}`);
+        // NOTE: filter-repo requires POSIX path to work
+        const sourcePosixPath = source.split(path_1.sep).join(path_1.posix.sep);
+        const destinationPosixPath = destination.split(path_1.sep).join(path_1.posix.sep);
+        // First, if the source is not a root project, then only include commits relevant to the subdirectory.
+        if (source !== '') {
+            const indexFilterCommand = this.quoteArg(`node ${(0, path_1.join)(__dirname, 'git-utils.index-filter.js')}`);
+            await this.execAsync(`git filter-branch -f --index-filter ${indexFilterCommand} --prune-empty -- ${branchName}`, {
+                NX_IMPORT_SOURCE: sourcePosixPath,
+                NX_IMPORT_DESTINATION: destinationPosixPath,
+            });
+        }
+        // Then, move files to their new location if necessary.
+        if (source === '' || source !== destination) {
+            const treeFilterCommand = this.quoteArg(`node ${(0, path_1.join)(__dirname, 'git-utils.tree-filter.js')}`);
+            await this.execAsync(`git filter-branch -f --tree-filter ${treeFilterCommand} -- ${branchName}`, {
+                NX_IMPORT_SOURCE: sourcePosixPath,
+                NX_IMPORT_DESTINATION: destinationPosixPath,
+            });
+        }
     }
-    execAsync(command) {
+    execAsync(command, env) {
         return execAsync(command, {
             cwd: this.root,
             maxBuffer: 10 * 1024 * 1024,
+            env: {
+                ...process.env,
+                ...env,
+            },
         });
     }
-    quotePath(path) {
+    quotePath(path, ensureTrailingSlash) {
+        return this.quoteArg(ensureTrailingSlash && path !== '' && !path.endsWith('/')
+            ? `${path}/`
+            : path);
+    }
+    quoteArg(arg) {
         return process.platform === 'win32'
             ? // Windows/CMD only understands double-quotes, single-quotes are treated as part of the file name
                 // Bash and other shells will substitute `$` in file names with a variable value.
-                `"${path}"`
+                `"${arg
+                    // Need to keep two slashes for Windows or else the path will be invalid.
+                    // e.g. 'C:\Users\bob\projects\repo' is invalid, but 'C:\\Users\\bob\\projects\\repo' is valid
+                    .replaceAll('\\', '\\\\')}"`
             : // e.g. `git mv "$$file.txt" "libs/a/$$file.txt"` will not work since `$$` is swapped with the PID of the last process.
                 // Using single-quotes prevents this substitution.
-                `'${path}'`;
+                `'${arg}'`;
     }
 }
 exports.GitRepository = GitRepository;

package/src/utils/git-utils.tree-filter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This is meant to be used with `git filter-branch --tree-filter` to rewrite
+ * history to only include commits related to the source project folder. If the
+ * destination folder is different, this script also moves the files over.
+ *
+ * Example:
+ * NX_IMPORT_SOURCE=<source> NX_IMPORT_DESTINATION=<destination> git filter-branch --tree-filter 'node git-utils.tree-filter.js' --prune-empty -- --all
+ */
+declare const execSync: any;
+declare const existsSync: any, mkdirSync: any, renameSync: any, rmSync: any;
+declare const posix: any;

package/src/utils/git-utils.tree-filter.js

@@ -0,0 +1,43 @@
+/**
+ * This is meant to be used with `git filter-branch --tree-filter` to rewrite
+ * history to only include commits related to the source project folder. If the
+ * destination folder is different, this script also moves the files over.
+ *
+ * Example:
+ * NX_IMPORT_SOURCE=<source> NX_IMPORT_DESTINATION=<destination> git filter-branch --tree-filter 'node git-utils.tree-filter.js' --prune-empty -- --all
+ */
+const { execSync } = require('child_process');
+const { existsSync, mkdirSync, renameSync, rmSync } = require('fs');
+// NOTE: The path passed to `git filter-branch` is POSIX, so we need to use the `posix` module.
+const { posix } = require('path');
+try {
+    // NOTE: Using env vars because Windows PowerShell has its own handling of quotes (") messes up quotes in args, even if escaped.
+    const src = process.env.NX_IMPORT_SOURCE;
+    const dest = process.env.NX_IMPORT_DESTINATION;
+    const files = execSync(`git ls-files -z ${src}`)
+        .toString()
+        .trim()
+        .split('\x00')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    for (const file of files) {
+        if (src === '' || file.startsWith(src)) {
+            // If source and destination are the same, then keep the file as is.
+            if (src === dest)
+                continue;
+            const destFile = posix.join(dest, file.replace(src, ''));
+            const dir = posix.dirname(destFile);
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            renameSync(file, destFile);
+        }
+        else {
+            // If not matching the source we are filtering, remove it.
+            rmSync(file);
+        }
+    }
+}
+catch (error) {
+    console.error(`Error executing Git commands: ${error}`);
+    process.exit(1);
+}

package/src/utils/handle-errors.d.ts

@@ -0,0 +1 @@
+export declare function handleErrors(isVerbose: boolean, fn: Function): Promise<number>;

package/src/utils/handle-errors.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleErrors = handleErrors;
+const client_1 = require("../daemon/client/client");
+const logger_1 = require("./logger");
+const output_1 = require("./output");
+async function handleErrors(isVerbose, fn) {
+    try {
+        const result = await fn();
+        if (typeof result === 'number') {
+            return result;
+        }
+        return 0;
+    }
+    catch (err) {
+        err ||= new Error('Unknown error caught');
+        if (err.constructor.name === 'UnsuccessfulWorkflowExecution') {
+            logger_1.logger.error('The generator workflow failed. See above.');
+        }
+        else if (err.name === 'ProjectGraphError') {
+            const projectGraphError = err;
+            let title = projectGraphError.message;
+            if (projectGraphError.cause &&
+                typeof projectGraphError.cause === 'object' &&
+                'message' in projectGraphError.cause) {
+                title += ' ' + projectGraphError.cause.message + '.';
+            }
+            if (isVerbose) {
+                title += ' See errors below.';
+            }
+            const bodyLines = isVerbose
+                ? formatErrorStackAndCause(projectGraphError)
+                : ['Pass --verbose to see the stacktraces.'];
+            output_1.output.error({
+                title,
+                bodyLines: bodyLines,
+            });
+        }
+        else {
+            const lines = (err.message ? err.message : err.toString()).split('\n');
+            const bodyLines = lines.slice(1);
+            if (isVerbose) {
+                bodyLines.push(...formatErrorStackAndCause(err));
+            }
+            else if (err.stack) {
+                bodyLines.push('Pass --verbose to see the stacktrace.');
+            }
+            output_1.output.error({
+                title: lines[0],
+                bodyLines,
+            });
+        }
+        if (client_1.daemonClient.enabled()) {
+            client_1.daemonClient.reset();
+        }
+        return 1;
+    }
+}
+function formatErrorStackAndCause(error) {
+    return [
+        error.stack || error.message,
+        ...(error.cause && typeof error.cause === 'object'
+            ? [
+                'Caused by:',
+                'stack' in error.cause
+                    ? error.cause.stack.toString()
+                    : error.cause.toString(),
+            ]
+            : []),
+    ];
+}

package/src/utils/nx-cloud-utils.d.ts

@@ -1,4 +1,3 @@
 import { NxJsonConfiguration } from '../config/nx-json';
 export declare function isNxCloudUsed(nxJson: NxJsonConfiguration): boolean;
 export declare function getNxCloudUrl(nxJson: NxJsonConfiguration): string;
-export declare function getNxCloudToken(nxJson: NxJsonConfiguration): string;

package/src/utils/nx-cloud-utils.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNxCloudUsed = isNxCloudUsed;
 exports.getNxCloudUrl = getNxCloudUrl;
-exports.getNxCloudToken = getNxCloudToken;
 function isNxCloudUsed(nxJson) {
     return (!!process.env.NX_CLOUD_ACCESS_TOKEN ||
         !!nxJson.nxCloudAccessToken ||
@@ -17,12 +16,3 @@ function getNxCloudUrl(nxJson) {
         throw new Error('nx-cloud runner not found in nx.json');
     return cloudRunner?.options?.url ?? nxJson.nxCloudUrl ?? 'https://nx.app';
 }
-function getNxCloudToken(nxJson) {
-    const cloudRunner = Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud');
-    if (!cloudRunner &&
-        !(nxJson.nxCloudAccessToken || process.env.NX_CLOUD_ACCESS_TOKEN))
-        throw new Error('nx-cloud runner not found in nx.json');
-    return (process.env.NX_CLOUD_ACCESS_TOKEN ??
-        cloudRunner?.options.accessToken ??
-        nxJson.nxCloudAccessToken);
-}

package/src/utils/params.d.ts

@@ -79,7 +79,6 @@ export type Options = {
     '--'?: Unmatched[];
     [k: string]: string | number | boolean | string[] | Unmatched[] | undefined;
 };
-export declare function handleErrors(isVerbose: boolean, fn: Function): Promise<number>;
 export declare function convertToCamelCase(parsed: {
     [k: string]: any;
 }, schema: Schema): Options;

package/src/utils/params.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaError = void 0;
-exports.handleErrors = handleErrors;
 exports.convertToCamelCase = convertToCamelCase;
 exports.coerceTypesInOptions = coerceTypesInOptions;
 exports.convertAliases = convertAliases;
@@ -15,55 +14,6 @@ exports.warnDeprecations = warnDeprecations;
 exports.convertSmartDefaultsIntoNamedParams = convertSmartDefaultsIntoNamedParams;
 exports.getPromptsForSchema = getPromptsForSchema;
 const logger_1 = require("./logger");
-const output_1 = require("./output");
-const client_1 = require("../daemon/client/client");
-async function handleErrors(isVerbose, fn) {
-    try {
-        const result = await fn();
-        if (typeof result === 'number') {
-            return result;
-        }
-        return 0;
-    }
-    catch (err) {
-        err ||= new Error('Unknown error caught');
-        if (err.constructor.name === 'UnsuccessfulWorkflowExecution') {
-            logger_1.logger.error('The generator workflow failed. See above.');
-        }
-        else if (err.name === 'ProjectGraphError') {
-            const projectGraphError = err;
-            let title = projectGraphError.message;
-            if (isVerbose) {
-                title += ' See errors below.';
-            }
-            const bodyLines = isVerbose
-                ? [projectGraphError.stack]
-                : ['Pass --verbose to see the stacktraces.'];
-            output_1.output.error({
-                title,
-                bodyLines: bodyLines,
-            });
-        }
-        else {
-            const lines = (err.message ? err.message : err.toString()).split('\n');
-            const bodyLines = lines.slice(1);
-            if (err.stack && !isVerbose) {
-                bodyLines.push('Pass --verbose to see the stacktrace.');
-            }
-            output_1.output.error({
-                title: lines[0],
-                bodyLines,
-            });
-            if (err.stack && isVerbose) {
-                logger_1.logger.info(err.stack);
-            }
-        }
-        if (client_1.daemonClient.enabled()) {
-            client_1.daemonClient.reset();
-        }
-        return 1;
-    }
-}
 function camelCase(input) {
     if (input.indexOf('-') > 1) {
         return input