chore(cli): don't double up on errors

mrgrain · mrgrain · commit bb556b22d011 · 2025-03-19T18:52:31.000Z
diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/src/api/toolkit-error.ts b/packages/@aws-cdk/tmp-toolkit-helpers/src/api/toolkit-error.ts
@@ -37,6 +37,13 @@ export class ToolkitError extends Error {
     return this.isToolkitError(x) && CONTEXT_PROVIDER_ERROR_SYMBOL in x;
   }
 
+  /**
+   * An AssemblyError with an original error as cause
+   */
+  public static withCause(message: string, error: unknown): ToolkitError {
+    return new ToolkitError(message, 'toolkit', error);
+  }
+
   /**
    * The type of the error, defaults to "toolkit".
    */
@@ -47,13 +54,19 @@ export class ToolkitError extends Error {
    */
   public readonly source: 'toolkit' | 'user';
 
-  constructor(message: string, type: string = 'toolkit') {
+  /**
+   * The specific original cause of the error, if available
+   */
+  public readonly cause?: unknown;
+
+  constructor(message: string, type: string = 'toolkit', cause?: unknown) {
     super(message);
     Object.setPrototypeOf(this, ToolkitError.prototype);
     Object.defineProperty(this, TOOLKIT_ERROR_SYMBOL, { value: true });
     this.name = new.target.name;
     this.type = type;
     this.source = 'toolkit';
+    this.cause = cause;
   }
 }
 
@@ -106,17 +119,11 @@ export class AssemblyError extends ToolkitError {
    */
   public readonly stacks?: cxapi.CloudFormationStackArtifact[];
 
-  /**
-   * The specific original cause of the error, if available
-   */
-  public readonly cause?: unknown;
-
   private constructor(message: string, stacks?: cxapi.CloudFormationStackArtifact[], cause?: unknown) {
-    super(message, 'assembly');
+    super(message, 'assembly', cause);
     Object.setPrototypeOf(this, AssemblyError.prototype);
     Object.defineProperty(this, ASSEMBLY_ERROR_SYMBOL, { value: true });
     this.stacks = stacks;
-    this.cause = cause;
   }
 }
 
diff --git a/packages/aws-cdk/lib/api/plugin/plugin.ts b/packages/aws-cdk/lib/api/plugin/plugin.ts
@@ -1,9 +1,6 @@
 import { inspect } from 'util';
 import type { CredentialProviderSource, IPluginHost, Plugin } from '@aws-cdk/cli-plugin-contract';
-
-import * as chalk from 'chalk';
 import { type ContextProviderPlugin, isContextProviderPlugin } from './context-provider-plugin';
-import { error } from '../../logging';
 import { ToolkitError } from '../../toolkit/error';
 
 export let TESTING = false;
@@ -44,15 +41,13 @@ export class PluginHost implements IPluginHost {
       const plugin = require(moduleSpec);
       /* eslint-enable */
       if (!isPlugin(plugin)) {
-        error(`Module ${chalk.green(moduleSpec)} is not a valid plug-in, or has an unsupported version.`);
-        throw new ToolkitError(`Module ${moduleSpec} does not define a valid plug-in.`);
+        throw new ToolkitError(`Module ${moduleSpec} is not a valid plug-in, or has an unsupported version.`);
       }
       if (plugin.init) {
         plugin.init(this);
       }
     } catch (e: any) {
-      error(`Unable to load ${chalk.green(moduleSpec)}: ${e.stack}`);
-      throw new ToolkitError(`Unable to load plug-in: ${moduleSpec}: ${e}`);
+      throw ToolkitError.withCause(`Unable to load plug-in '${moduleSpec}'`, e);
     }
 
     function isPlugin(x: any): x is Plugin {
diff --git a/packages/aws-cdk/lib/cli/cli.ts b/packages/aws-cdk/lib/cli/cli.ts
@@ -4,7 +4,7 @@ import { CdkToolkit, AssetBuildTime } from './cdk-toolkit';
 import { ciSystemIsStdErrSafe } from './ci-systems';
 import { parseCommandLineArguments } from './parse-command-line-arguments';
 import { checkForPlatformWarnings } from './platform-warnings';
-
+import { prettyPrintError } from './pretty-print-error';
 import * as version from './version';
 import { asIoHelper } from '../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { SdkProvider } from '../api/aws-auth';
@@ -28,7 +28,6 @@ import { docs } from '../commands/docs';
 import { doctor } from '../commands/doctor';
 import { getMigrateScanType } from '../commands/migrate';
 import { cliInit, printAvailableTemplates } from '../init';
-import { result, debug, error, info } from '../logging';
 import { Notices } from '../notices';
 import type { Command } from './user-configuration';
 import { Configuration } from './user-configuration';
@@ -82,11 +81,11 @@ export async function exec(args: string[], synthesizer?: Synthesizer): Promise<n
   try {
     await checkForPlatformWarnings();
   } catch (e) {
-    debug(`Error while checking for platform warnings: ${e}`);
+    ioHost.defaults.debug(`Error while checking for platform warnings: ${e}`);
   }
 
-  debug('CDK Toolkit CLI version:', version.displayVersion());
-  debug('Command line arguments:', argv);
+  ioHost.defaults.debug('CDK Toolkit CLI version:', version.displayVersion());
+  ioHost.defaults.debug('Command line arguments:', argv);
 
   const configuration = new Configuration({
     commandLineArguments: {
@@ -158,7 +157,7 @@ export async function exec(args: string[], synthesizer?: Synthesizer): Promise<n
         if (loaded.has(resolved)) {
           continue;
         }
-        debug(`Loading plug-in: ${chalk.green(plugin)} from ${chalk.blue(resolved)}`);
+        ioHost.defaults.debug(`Loading plug-in: ${chalk.green(plugin)} from ${chalk.blue(resolved)}`);
         PluginHost.instance.load(plugin);
         loaded.add(resolved);
       }
@@ -168,8 +167,7 @@ export async function exec(args: string[], synthesizer?: Synthesizer): Promise<n
       try {
         return require.resolve(plugin);
       } catch (e: any) {
-        error(`Unable to resolve plugin ${chalk.green(plugin)}: ${e.stack}`);
-        throw new ToolkitError(`Unable to resolve plug-in: ${plugin}`);
+        throw new ToolkitError(`Unable to resolve plug-in: Cannot find module '${plugin}'`);
       }
     }
   }
@@ -201,7 +199,7 @@ export async function exec(args: string[], synthesizer?: Synthesizer): Promise<n
   async function main(command: string, args: any): Promise<number | void> {
     ioHost.currentAction = command as any;
     const toolkitStackName: string = ToolkitInfo.determineName(configuration.settings.get(['toolkitStackName']));
-    debug(`Toolkit stack: ${chalk.bold(toolkitStackName)}`);
+    ioHost.defaults.debug(`Toolkit stack: ${chalk.bold(toolkitStackName)}`);
 
     const cloudFormation = new Deployments({
       sdkProvider,
@@ -282,7 +280,7 @@ export async function exec(args: string[], synthesizer?: Synthesizer): Promise<n
 
       case 'bootstrap':
         ioHost.currentAction = 'bootstrap';
-        const source: BootstrapSource = determineBootstrapVersion(args);
+        const source: BootstrapSource = determineBootstrapVersion(ioHost, args);
 
         if (args.showTemplate) {
           const bootstrapper = new Bootstrapper(source, asIoHelper(ioHost, ioHost.currentAction));
@@ -523,7 +521,7 @@ export async function exec(args: string[], synthesizer?: Synthesizer): Promise<n
         });
       case 'version':
         ioHost.currentAction = 'version';
-        return result(version.displayVersion());
+        return ioHost.defaults.result(version.displayVersion());
 
       default:
         throw new ToolkitError('Unknown command: ' + command);
@@ -534,13 +532,13 @@ export async function exec(args: string[], synthesizer?: Synthesizer): Promise<n
 /**
  * Determine which version of bootstrapping
  */
-function determineBootstrapVersion(args: { template?: string }): BootstrapSource {
+function determineBootstrapVersion(ioHost: CliIoHost, args: { template?: string }): BootstrapSource {
   let source: BootstrapSource;
   if (args.template) {
-    info(`Using bootstrapping template from ${args.template}`);
+    ioHost.defaults.info(`Using bootstrapping template from ${args.template}`);
     source = { source: 'custom', templateFile: args.template };
   } else if (process.env.CDK_LEGACY_BOOTSTRAP) {
-    info('CDK_LEGACY_BOOTSTRAP set, using legacy-style bootstrapping');
+    ioHost.defaults.info('CDK_LEGACY_BOOTSTRAP set, using legacy-style bootstrapping');
     source = { source: 'legacy' };
   } else {
     // in V2, the "new" bootstrapping is the default
@@ -600,13 +598,9 @@ export function cli(args: string[] = process.argv.slice(2)) {
       }
     })
     .catch((err) => {
-      error(err.message);
-
       // Log the stack trace if we're on a developer workstation. Otherwise this will be into a minified
       // file and the printed code line and stack trace are huge and useless.
-      if (err.stack && version.isDeveloperBuild()) {
-        debug(err.stack);
-      }
+      prettyPrintError(err, version.isDeveloperBuild());
       process.exitCode = 1;
     });
 }
diff --git a/packages/aws-cdk/lib/cli/pretty-print-error.ts b/packages/aws-cdk/lib/cli/pretty-print-error.ts
@@ -0,0 +1,36 @@
+/* eslint-disable no-console */
+import * as chalk from 'chalk';
+
+export function prettyPrintError(error: unknown, debug = false) {
+  const err = ensureError(error);
+  console.error(chalk.red(err.message));
+
+  if (err.cause) {
+    const cause = ensureError(err.cause);
+    console.error(chalk.yellow(cause.message));
+    printTrace(err, debug);
+  }
+
+  printTrace(err, debug);
+}
+
+function printTrace(err: Error, debug = false) {
+  // Log the stack trace if we're on a developer workstation. Otherwise this will be into a minified
+  // file and the printed code line and stack trace are huge and useless.
+  if (err.stack && debug) {
+    console.debug(chalk.gray(err.stack));
+  }
+}
+
+function ensureError(value: unknown): Error & { cause?: unknown } {
+  if (value instanceof Error) return value;
+
+  let stringified = '[Unable to stringify the thrown value]';
+  try {
+    stringified = JSON.stringify(value);
+  } catch {
+  }
+
+  const error = new Error(`An unexpected error was thrown: ${stringified}`);
+  return error;
+}
diff --git a/packages/aws-cdk/lib/toolkit/cli-io-host.ts b/packages/aws-cdk/lib/toolkit/cli-io-host.ts
@@ -4,7 +4,7 @@ import * as chalk from 'chalk';
 import * as promptly from 'promptly';
 import { ToolkitError } from './error';
 import { type IIoHost, type IoMessage, type IoMessageCode, type IoMessageLevel, type IoRequest, type ToolkitAction } from '../../../@aws-cdk/tmp-toolkit-helpers/src/api/io';
-import { IO, isMessageRelevantForLevel } from '../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
+import { asIoHelper, IO, IoDefaultMessages, isMessageRelevantForLevel } from '../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import type { ActivityPrinterProps, IActivityPrinter } from '../cli/activity-printer';
 import { CurrentActivityPrinter, HistoryActivityPrinter } from '../cli/activity-printer';
 import { StackActivityProgress } from '../commands/deploy';
@@ -204,6 +204,11 @@ export class CliIoHost implements IIoHost {
     return this._progress;
   }
 
+  public get defaults() {
+    const helper = asIoHelper(this, this.currentAction as any);
+    return new IoDefaultMessages(helper);
+  }
+
   /**
    * Executes a block of code with corked logging. All log messages during execution
    * are buffered and only written when all nested cork blocks complete (when CORK_COUNTER reaches 0).
