aws-cdk 2.1005.0 → 2.1007.0

package/lib/cli/io-host/cli-io-host.js

@@ -0,0 +1,356 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliIoHost = void 0;
+exports.isCI = isCI;
+const util = require("node:util");
+const cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema");
+const chalk = require("chalk");
+const promptly = require("promptly");
+const api_1 = require("../../../../@aws-cdk/tmp-toolkit-helpers/src/api");
+const private_1 = require("../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private");
+const deploy_1 = require("../../commands/deploy");
+const activity_printer_1 = require("../activity-printer");
+/**
+ * A simple IO host for the CLI that writes messages to the console.
+ */
+class CliIoHost {
+    /**
+     * Returns the singleton instance
+     */
+    static instance(props = {}, forceNew = false) {
+        if (forceNew || !CliIoHost._instance) {
+            CliIoHost._instance = new CliIoHost(props);
+        }
+        return CliIoHost._instance;
+    }
+    constructor(props = {}) {
+        /**
+         * Configure the target stream for notices
+         *
+         * (Not a setter because there's no need for additional logic when this value
+         * is changed yet)
+         */
+        this.noticesDestination = 'stderr';
+        this._progress = deploy_1.StackActivityProgress.BAR;
+        // Corked Logging
+        this.corkedCounter = 0;
+        this.corkedLoggingBuffer = [];
+        this.currentAction = props.currentAction ?? 'none';
+        this.isTTY = props.isTTY ?? process.stdout.isTTY ?? false;
+        this.logLevel = props.logLevel ?? 'info';
+        this.isCI = props.isCI ?? isCI();
+        this.requireDeployApproval = props.requireDeployApproval ?? cloud_assembly_schema_1.RequireApproval.BROADENING;
+        this.stackProgress = props.stackProgress ?? deploy_1.StackActivityProgress.BAR;
+    }
+    /**
+     * Returns the singleton instance
+     */
+    registerIoHost(ioHost) {
+        if (ioHost !== this) {
+            this._internalIoHost = ioHost;
+        }
+    }
+    /**
+     * Update the stackProgress preference.
+     */
+    set stackProgress(type) {
+        this._progress = type;
+    }
+    /**
+     * Gets the stackProgress value.
+     *
+     * This takes into account other state of the ioHost,
+     * like if isTTY and isCI.
+     */
+    get stackProgress() {
+        // We can always use EVENTS
+        if (this._progress === deploy_1.StackActivityProgress.EVENTS) {
+            return this._progress;
+        }
+        // if a debug message (and thus any more verbose messages) are relevant to the current log level, we have verbose logging
+        const verboseLogging = (0, private_1.isMessageRelevantForLevel)({ level: 'debug' }, this.logLevel);
+        if (verboseLogging) {
+            return deploy_1.StackActivityProgress.EVENTS;
+        }
+        // On Windows we cannot use fancy output
+        const isWindows = process.platform === 'win32';
+        if (isWindows) {
+            return deploy_1.StackActivityProgress.EVENTS;
+        }
+        // On some CI systems (such as CircleCI) output still reports as a TTY so we also
+        // need an individual check for whether we're running on CI.
+        // see: https://discuss.circleci.com/t/circleci-terminal-is-a-tty-but-term-is-not-set/9965
+        const fancyOutputAvailable = this.isTTY && !this.isCI;
+        if (!fancyOutputAvailable) {
+            return deploy_1.StackActivityProgress.EVENTS;
+        }
+        // Use the user preference
+        return this._progress;
+    }
+    get defaults() {
+        return new private_1.IoDefaultMessages(this.asIoHelper());
+    }
+    asIoHelper() {
+        return (0, private_1.asIoHelper)(this, this.currentAction);
+    }
+    /**
+     * 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).
+     * The corking is bound to the specific instance of the CliIoHost.
+     *
+     * @param block - Async function to execute with corked logging
+     * @returns Promise that resolves with the block's return value
+     */
+    async withCorkedLogging(block) {
+        this.corkedCounter++;
+        try {
+            return await block();
+        }
+        finally {
+            this.corkedCounter--;
+            if (this.corkedCounter === 0) {
+                // Process each buffered message through notify
+                for (const ioMessage of this.corkedLoggingBuffer) {
+                    await this.notify(ioMessage);
+                }
+                // remove all buffered messages in-place
+                this.corkedLoggingBuffer.splice(0);
+            }
+        }
+    }
+    /**
+     * Notifies the host of a message.
+     * The caller waits until the notification completes.
+     */
+    async notify(msg) {
+        if (this._internalIoHost) {
+            return this._internalIoHost.notify(msg);
+        }
+        if (this.isStackActivity(msg)) {
+            if (!this.activityPrinter) {
+                this.activityPrinter = this.makeActivityPrinter();
+            }
+            await this.activityPrinter.notify(msg);
+            return;
+        }
+        if (!(0, private_1.isMessageRelevantForLevel)(msg, this.logLevel)) {
+            return;
+        }
+        if (this.corkedCounter > 0) {
+            this.corkedLoggingBuffer.push(msg);
+            return;
+        }
+        const output = this.formatMessage(msg);
+        const stream = this.selectStream(msg);
+        stream?.write(output);
+    }
+    /**
+     * Detect stack activity messages so they can be send to the printer.
+     */
+    isStackActivity(msg) {
+        return [
+            'CDK_TOOLKIT_I5501',
+            'CDK_TOOLKIT_I5502',
+            'CDK_TOOLKIT_I5503',
+        ].includes(msg.code);
+    }
+    /**
+     * Detect special messages encode information about whether or not
+     * they require approval
+     */
+    skipApprovalStep(msg) {
+        const approvalToolkitCodes = ['CDK_TOOLKIT_I5060'];
+        if (!approvalToolkitCodes.includes(msg.code)) {
+            false;
+        }
+        switch (this.requireDeployApproval) {
+            // Never require approval
+            case cloud_assembly_schema_1.RequireApproval.NEVER:
+                return true;
+            // Always require approval
+            case cloud_assembly_schema_1.RequireApproval.ANYCHANGE:
+                return false;
+            // Require approval if changes include broadening permissions
+            case cloud_assembly_schema_1.RequireApproval.BROADENING:
+                return ['none', 'non-broadening'].includes(msg.data?.permissionChangeType);
+        }
+    }
+    /**
+     * Determines the output stream, based on message and configuration.
+     */
+    selectStream(msg) {
+        if (isNoticesMessage(msg)) {
+            return targetStreamObject(this.noticesDestination);
+        }
+        return this.selectStreamFromLevel(msg.level);
+    }
+    /**
+     * Determines the output stream, based on message level and configuration.
+     */
+    selectStreamFromLevel(level) {
+        // The stream selection policy for the CLI is the following:
+        //
+        //   (1) Messages of level `result` always go to `stdout`
+        //   (2) Messages of level `error` always go to `stderr`.
+        //   (3a) All remaining messages go to `stderr`.
+        //   (3b) If we are in CI mode, all remaining messages go to `stdout`.
+        //
+        switch (level) {
+            case 'error':
+                return process.stderr;
+            case 'result':
+                return process.stdout;
+            default:
+                return this.isCI ? process.stdout : process.stderr;
+        }
+    }
+    /**
+     * Notifies the host of a message that requires a response.
+     *
+     * If the host does not return a response the suggested
+     * default response from the input message will be used.
+     */
+    async requestResponse(msg) {
+        // First call out to a registered instance if we have one
+        if (this._internalIoHost) {
+            return this._internalIoHost.requestResponse(msg);
+        }
+        // If the request cannot be prompted for by the CliIoHost, we just accept the default
+        if (!isPromptableRequest(msg)) {
+            await this.notify(msg);
+            return msg.defaultResponse;
+        }
+        const response = await this.withCorkedLogging(async () => {
+            // prepare prompt data
+            // @todo this format is not defined anywhere, probably should be
+            const data = msg.data ?? {};
+            const motivation = data.motivation ?? 'User input is needed';
+            const concurrency = data.concurrency ?? 0;
+            // only talk to user if STDIN is a terminal (otherwise, fail)
+            if (!this.isTTY) {
+                throw new api_1.ToolkitError(`${motivation}, but terminal (TTY) is not attached so we are unable to get a confirmation from the user`);
+            }
+            // only talk to user if concurrency is 1 (otherwise, fail)
+            if (concurrency > 1) {
+                throw new api_1.ToolkitError(`${motivation}, but concurrency is greater than 1 so we are unable to get a confirmation from the user`);
+            }
+            // Special approval prompt
+            // Determine if the message needs approval. If it does, continue (it is a basic confirmation prompt)
+            // If it does not, return success (true). We only check messages with codes that we are aware
+            // are requires approval codes.
+            if (this.skipApprovalStep(msg)) {
+                return true;
+            }
+            // Basic confirmation prompt
+            // We treat all requests with a boolean response as confirmation prompts
+            if (isConfirmationPrompt(msg)) {
+                const confirmed = await promptly.confirm(`${chalk.cyan(msg.message)} (y/n)`);
+                if (!confirmed) {
+                    throw new api_1.ToolkitError('Aborted by user');
+                }
+                return confirmed;
+            }
+            // Asking for a specific value
+            const prompt = extractPromptInfo(msg);
+            const answer = await promptly.prompt(`${chalk.cyan(msg.message)} (${prompt.default})`, {
+                default: prompt.default,
+            });
+            return prompt.convertAnswer(answer);
+        });
+        // We need to cast this because it is impossible to narrow the generic type
+        // isPromptableRequest ensures that the response type is one we can prompt for
+        // the remaining code ensure we are indeed returning the correct type
+        return response;
+    }
+    /**
+     * Formats a message for console output with optional color support
+     */
+    formatMessage(msg) {
+        // apply provided style or a default style if we're in TTY mode
+        let message_text = this.isTTY
+            ? styleMap[msg.level](msg.message)
+            : msg.message;
+        // prepend timestamp if IoMessageLevel is DEBUG or TRACE. Postpend a newline.
+        return ((msg.level === 'debug' || msg.level === 'trace')
+            ? `[${this.formatTime(msg.time)}] ${message_text}`
+            : message_text) + '\n';
+    }
+    /**
+     * Formats date to HH:MM:SS
+     */
+    formatTime(d) {
+        const pad = (n) => n.toString().padStart(2, '0');
+        return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+    }
+    /**
+     * Get an instance of the ActivityPrinter
+     */
+    makeActivityPrinter() {
+        const props = {
+            stream: this.selectStreamFromLevel('info'),
+        };
+        switch (this.stackProgress) {
+            case deploy_1.StackActivityProgress.EVENTS:
+                return new activity_printer_1.HistoryActivityPrinter(props);
+            case deploy_1.StackActivityProgress.BAR:
+                return new activity_printer_1.CurrentActivityPrinter(props);
+        }
+    }
+}
+exports.CliIoHost = CliIoHost;
+/**
+ * This IoHost implementation considers a request promptable, if:
+ * - it's a yes/no confirmation
+ * - asking for a string or number value
+ */
+function isPromptableRequest(msg) {
+    return isConfirmationPrompt(msg)
+        || typeof msg.defaultResponse === 'string'
+        || typeof msg.defaultResponse === 'number';
+}
+/**
+ * Check if the request is a confirmation prompt
+ * We treat all requests with a boolean response as confirmation prompts
+ */
+function isConfirmationPrompt(msg) {
+    return typeof msg.defaultResponse === 'boolean';
+}
+/**
+ * Helper to extract information for promptly from the request
+ */
+function extractPromptInfo(msg) {
+    const isNumber = (typeof msg.defaultResponse === 'number');
+    return {
+        default: util.format(msg.defaultResponse),
+        convertAnswer: isNumber ? (v) => Number(v) : (v) => String(v),
+    };
+}
+const styleMap = {
+    error: chalk.red,
+    warn: chalk.yellow,
+    result: chalk.white,
+    info: chalk.white,
+    debug: chalk.gray,
+    trace: chalk.gray,
+};
+/**
+ * Returns true if the current process is running in a CI environment
+ * @returns true if the current process is running in a CI environment
+ */
+function isCI() {
+    return process.env.CI !== undefined && process.env.CI !== 'false' && process.env.CI !== '0';
+}
+function targetStreamObject(x) {
+    switch (x) {
+        case 'stderr':
+            return process.stderr;
+        case 'stdout':
+            return process.stdout;
+        case 'drop':
+            return undefined;
+    }
+}
+function isNoticesMessage(msg) {
+    return private_1.IO.CDK_TOOLKIT_I0100.is(msg) || private_1.IO.CDK_TOOLKIT_W0101.is(msg) || private_1.IO.CDK_TOOLKIT_E0101.is(msg) || private_1.IO.CDK_TOOLKIT_I0101.is(msg);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli-io-host.js","sourceRoot":"","sources":["cli-io-host.ts"],"names":[],"mappings":"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","sourcesContent":["import * as util from 'node:util';\nimport { RequireApproval } from '@aws-cdk/cloud-assembly-schema';\nimport * as chalk from 'chalk';\nimport * as promptly from 'promptly';\nimport { ToolkitError } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api';\nimport type { IIoHost, IoMessage, IoMessageCode, IoMessageLevel, IoRequest, ToolkitAction } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api';\nimport type { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';\nimport { asIoHelper, IO, IoDefaultMessages, isMessageRelevantForLevel } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';\nimport { StackActivityProgress } from '../../commands/deploy';\nimport { CurrentActivityPrinter, HistoryActivityPrinter } from '../activity-printer';\nimport type { ActivityPrinterProps, IActivityPrinter } from '../activity-printer';\n\nexport type { IIoHost, IoMessage, IoMessageCode, IoMessageLevel, IoRequest };\n\ntype CliAction =\n| ToolkitAction\n| 'context'\n| 'docs'\n| 'notices'\n| 'version'\n| 'none';\n\nexport interface CliIoHostProps {\n  /**\n   * The initial Toolkit action the hosts starts with.\n   *\n   * @default 'none'\n   */\n  readonly currentAction?: ToolkitAction;\n\n  /**\n   * Determines the verbosity of the output.\n   *\n   * The CliIoHost will still receive all messages and requests,\n   * but only the messages included in this level will be printed.\n   *\n   * @default 'info'\n   */\n  readonly logLevel?: IoMessageLevel;\n\n  /**\n   * Overrides the automatic TTY detection.\n   *\n   * When TTY is disabled, the CLI will have no interactions or color.\n   *\n   * @default - determined from the current process\n   */\n  readonly isTTY?: boolean;\n\n  /**\n   * Whether the CliIoHost is running in CI mode.\n   *\n   * In CI mode, all non-error output goes to stdout instead of stderr.\n   * Set to false in the CliIoHost constructor it will be overwritten if the CLI CI argument is passed\n   *\n   * @default - determined from the environment, specifically based on `process.env.CI`\n   */\n  readonly isCI?: boolean;\n\n  /**\n   * In what scenarios should the CliIoHost ask for approval\n   *\n   * @default RequireApproval.BROADENING\n   */\n  readonly requireDeployApproval?: RequireApproval;\n\n  /*\n   * The initial Toolkit action the hosts starts with.\n   *\n   * @default StackActivityProgress.BAR\n   */\n  readonly stackProgress?: StackActivityProgress;\n}\n\n/**\n * A type for configuring a target stream\n */\nexport type TargetStream = 'stdout' | 'stderr' | 'drop';\n\n/**\n * A simple IO host for the CLI that writes messages to the console.\n */\nexport class CliIoHost implements IIoHost {\n  /**\n   * Returns the singleton instance\n   */\n  static instance(props: CliIoHostProps = {}, forceNew = false): CliIoHost {\n    if (forceNew || !CliIoHost._instance) {\n      CliIoHost._instance = new CliIoHost(props);\n    }\n    return CliIoHost._instance;\n  }\n\n  /**\n   * Singleton instance of the CliIoHost\n   */\n  private static _instance: CliIoHost | undefined;\n\n  /**\n   * The current action being performed by the CLI.\n   */\n  public currentAction: CliAction;\n\n  /**\n   * Whether the CliIoHost is running in CI mode.\n   *\n   * In CI mode, all non-error output goes to stdout instead of stderr.\n   */\n  public isCI: boolean;\n\n  /**\n   * Whether the host can use interactions and message styling.\n   */\n  public isTTY: boolean;\n\n  /**\n   * The current threshold.\n   *\n   * Messages with a lower priority level will be ignored.\n   */\n  public logLevel: IoMessageLevel;\n\n  /**\n   * The conditions for requiring approval in this CliIoHost.\n   */\n  public requireDeployApproval: RequireApproval;\n\n  /**\n   * Configure the target stream for notices\n   *\n   * (Not a setter because there's no need for additional logic when this value\n   * is changed yet)\n   */\n  public noticesDestination: TargetStream = 'stderr';\n\n  private _internalIoHost?: IIoHost;\n  private _progress: StackActivityProgress = StackActivityProgress.BAR;\n\n  // Stack Activity Printer\n  private activityPrinter?: IActivityPrinter;\n\n  // Corked Logging\n  private corkedCounter = 0;\n  private readonly corkedLoggingBuffer: IoMessage<unknown>[] = [];\n\n  private constructor(props: CliIoHostProps = {}) {\n    this.currentAction = props.currentAction ?? 'none';\n    this.isTTY = props.isTTY ?? process.stdout.isTTY ?? false;\n    this.logLevel = props.logLevel ?? 'info';\n    this.isCI = props.isCI ?? isCI();\n    this.requireDeployApproval = props.requireDeployApproval ?? RequireApproval.BROADENING;\n\n    this.stackProgress = props.stackProgress ?? StackActivityProgress.BAR;\n  }\n\n  /**\n   * Returns the singleton instance\n   */\n  public registerIoHost(ioHost: IIoHost) {\n    if (ioHost !== this) {\n      this._internalIoHost = ioHost;\n    }\n  }\n\n  /**\n   * Update the stackProgress preference.\n   */\n  public set stackProgress(type: StackActivityProgress) {\n    this._progress = type;\n  }\n\n  /**\n   * Gets the stackProgress value.\n   *\n   * This takes into account other state of the ioHost,\n   * like if isTTY and isCI.\n   */\n  public get stackProgress(): StackActivityProgress {\n    // We can always use EVENTS\n    if (this._progress === StackActivityProgress.EVENTS) {\n      return this._progress;\n    }\n\n    // if a debug message (and thus any more verbose messages) are relevant to the current log level, we have verbose logging\n    const verboseLogging = isMessageRelevantForLevel({ level: 'debug' }, this.logLevel);\n    if (verboseLogging) {\n      return StackActivityProgress.EVENTS;\n    }\n\n    // On Windows we cannot use fancy output\n    const isWindows = process.platform === 'win32';\n    if (isWindows) {\n      return StackActivityProgress.EVENTS;\n    }\n\n    // On some CI systems (such as CircleCI) output still reports as a TTY so we also\n    // need an individual check for whether we're running on CI.\n    // see: https://discuss.circleci.com/t/circleci-terminal-is-a-tty-but-term-is-not-set/9965\n    const fancyOutputAvailable = this.isTTY && !this.isCI;\n    if (!fancyOutputAvailable) {\n      return StackActivityProgress.EVENTS;\n    }\n\n    // Use the user preference\n    return this._progress;\n  }\n\n  public get defaults() {\n    return new IoDefaultMessages(this.asIoHelper());\n  }\n\n  public asIoHelper(): IoHelper {\n    return asIoHelper(this, this.currentAction as any);\n  }\n\n  /**\n   * Executes a block of code with corked logging. All log messages during execution\n   * are buffered and only written when all nested cork blocks complete (when CORK_COUNTER reaches 0).\n   * The corking is bound to the specific instance of the CliIoHost.\n   *\n   * @param block - Async function to execute with corked logging\n   * @returns Promise that resolves with the block's return value\n   */\n  public async withCorkedLogging<T>(block: () => Promise<T>): Promise<T> {\n    this.corkedCounter++;\n    try {\n      return await block();\n    } finally {\n      this.corkedCounter--;\n      if (this.corkedCounter === 0) {\n        // Process each buffered message through notify\n        for (const ioMessage of this.corkedLoggingBuffer) {\n          await this.notify(ioMessage);\n        }\n        // remove all buffered messages in-place\n        this.corkedLoggingBuffer.splice(0);\n      }\n    }\n  }\n\n  /**\n   * Notifies the host of a message.\n   * The caller waits until the notification completes.\n   */\n  public async notify(msg: IoMessage<unknown>): Promise<void> {\n    if (this._internalIoHost) {\n      return this._internalIoHost.notify(msg);\n    }\n\n    if (this.isStackActivity(msg)) {\n      if (!this.activityPrinter) {\n        this.activityPrinter = this.makeActivityPrinter();\n      }\n      await this.activityPrinter.notify(msg);\n      return;\n    }\n\n    if (!isMessageRelevantForLevel(msg, this.logLevel)) {\n      return;\n    }\n\n    if (this.corkedCounter > 0) {\n      this.corkedLoggingBuffer.push(msg);\n      return;\n    }\n\n    const output = this.formatMessage(msg);\n    const stream = this.selectStream(msg);\n    stream?.write(output);\n  }\n\n  /**\n   * Detect stack activity messages so they can be send to the printer.\n   */\n  private isStackActivity(msg: IoMessage<unknown>) {\n    return [\n      'CDK_TOOLKIT_I5501',\n      'CDK_TOOLKIT_I5502',\n      'CDK_TOOLKIT_I5503',\n    ].includes(msg.code);\n  }\n\n  /**\n   * Detect special messages encode information about whether or not\n   * they require approval\n   */\n  private skipApprovalStep(msg: IoRequest<any, any>): boolean {\n    const approvalToolkitCodes = ['CDK_TOOLKIT_I5060'];\n    if (!approvalToolkitCodes.includes(msg.code)) {\n      false;\n    }\n\n    switch (this.requireDeployApproval) {\n      // Never require approval\n      case RequireApproval.NEVER:\n        return true;\n      // Always require approval\n      case RequireApproval.ANYCHANGE:\n        return false;\n      // Require approval if changes include broadening permissions\n      case RequireApproval.BROADENING:\n        return ['none', 'non-broadening'].includes(msg.data?.permissionChangeType);\n    }\n  }\n\n  /**\n   * Determines the output stream, based on message and configuration.\n   */\n  private selectStream(msg: IoMessage<any>): NodeJS.WriteStream | undefined {\n    if (isNoticesMessage(msg)) {\n      return targetStreamObject(this.noticesDestination);\n    }\n\n    return this.selectStreamFromLevel(msg.level);\n  }\n\n  /**\n   * Determines the output stream, based on message level and configuration.\n   */\n  private selectStreamFromLevel(level: IoMessageLevel): NodeJS.WriteStream {\n    // The stream selection policy for the CLI is the following:\n    //\n    //   (1) Messages of level `result` always go to `stdout`\n    //   (2) Messages of level `error` always go to `stderr`.\n    //   (3a) All remaining messages go to `stderr`.\n    //   (3b) If we are in CI mode, all remaining messages go to `stdout`.\n    //\n    switch (level) {\n      case 'error':\n        return process.stderr;\n      case 'result':\n        return process.stdout;\n      default:\n        return this.isCI ? process.stdout : process.stderr;\n    }\n  }\n\n  /**\n   * Notifies the host of a message that requires a response.\n   *\n   * If the host does not return a response the suggested\n   * default response from the input message will be used.\n   */\n  public async requestResponse<DataType, ResponseType>(msg: IoRequest<DataType, ResponseType>): Promise<ResponseType> {\n    // First call out to a registered instance if we have one\n    if (this._internalIoHost) {\n      return this._internalIoHost.requestResponse(msg);\n    }\n\n    // If the request cannot be prompted for by the CliIoHost, we just accept the default\n    if (!isPromptableRequest(msg)) {\n      await this.notify(msg);\n      return msg.defaultResponse;\n    }\n\n    const response = await this.withCorkedLogging(async (): Promise<string | number | true> => {\n      // prepare prompt data\n      // @todo this format is not defined anywhere, probably should be\n      const data: {\n        motivation?: string;\n        concurrency?: number;\n      } = msg.data ?? {};\n\n      const motivation = data.motivation ?? 'User input is needed';\n      const concurrency = data.concurrency ?? 0;\n\n      // only talk to user if STDIN is a terminal (otherwise, fail)\n      if (!this.isTTY) {\n        throw new ToolkitError(`${motivation}, but terminal (TTY) is not attached so we are unable to get a confirmation from the user`);\n      }\n\n      // only talk to user if concurrency is 1 (otherwise, fail)\n      if (concurrency > 1) {\n        throw new ToolkitError(`${motivation}, but concurrency is greater than 1 so we are unable to get a confirmation from the user`);\n      }\n\n      // Special approval prompt\n      // Determine if the message needs approval. If it does, continue (it is a basic confirmation prompt)\n      // If it does not, return success (true). We only check messages with codes that we are aware\n      // are requires approval codes.\n      if (this.skipApprovalStep(msg)) {\n        return true;\n      }\n\n      // Basic confirmation prompt\n      // We treat all requests with a boolean response as confirmation prompts\n      if (isConfirmationPrompt(msg)) {\n        const confirmed = await promptly.confirm(`${chalk.cyan(msg.message)} (y/n)`);\n        if (!confirmed) {\n          throw new ToolkitError('Aborted by user');\n        }\n        return confirmed;\n      }\n\n      // Asking for a specific value\n      const prompt = extractPromptInfo(msg);\n      const answer = await promptly.prompt(`${chalk.cyan(msg.message)} (${prompt.default})`, {\n        default: prompt.default,\n      });\n      return prompt.convertAnswer(answer);\n    });\n\n    // We need to cast this because it is impossible to narrow the generic type\n    // isPromptableRequest ensures that the response type is one we can prompt for\n    // the remaining code ensure we are indeed returning the correct type\n    return response as ResponseType;\n  }\n\n  /**\n   * Formats a message for console output with optional color support\n   */\n  private formatMessage(msg: IoMessage<unknown>): string {\n    // apply provided style or a default style if we're in TTY mode\n    let message_text = this.isTTY\n      ? styleMap[msg.level](msg.message)\n      : msg.message;\n\n    // prepend timestamp if IoMessageLevel is DEBUG or TRACE. Postpend a newline.\n    return ((msg.level === 'debug' || msg.level === 'trace')\n      ? `[${this.formatTime(msg.time)}] ${message_text}`\n      : message_text) + '\\n';\n  }\n\n  /**\n   * Formats date to HH:MM:SS\n   */\n  private formatTime(d: Date): string {\n    const pad = (n: number): string => n.toString().padStart(2, '0');\n    return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;\n  }\n\n  /**\n   * Get an instance of the ActivityPrinter\n   */\n  private makeActivityPrinter() {\n    const props: ActivityPrinterProps = {\n      stream: this.selectStreamFromLevel('info'),\n    };\n\n    switch (this.stackProgress) {\n      case StackActivityProgress.EVENTS:\n        return new HistoryActivityPrinter(props);\n      case StackActivityProgress.BAR:\n        return new CurrentActivityPrinter(props);\n    }\n  }\n}\n\n/**\n * This IoHost implementation considers a request promptable, if:\n * - it's a yes/no confirmation\n * - asking for a string or number value\n */\nfunction isPromptableRequest(msg: IoRequest<any, any>): msg is IoRequest<any, string | number | boolean> {\n  return isConfirmationPrompt(msg)\n    || typeof msg.defaultResponse === 'string'\n    || typeof msg.defaultResponse === 'number';\n}\n\n/**\n * Check if the request is a confirmation prompt\n * We treat all requests with a boolean response as confirmation prompts\n */\nfunction isConfirmationPrompt(msg: IoRequest<any, any>): msg is IoRequest<any, boolean> {\n  return typeof msg.defaultResponse === 'boolean';\n}\n\n/**\n * Helper to extract information for promptly from the request\n */\nfunction extractPromptInfo(msg: IoRequest<any, any>): {\n  default: string;\n  convertAnswer: (input: string) => string | number;\n} {\n  const isNumber = (typeof msg.defaultResponse === 'number');\n  return {\n    default: util.format(msg.defaultResponse),\n    convertAnswer: isNumber ? (v) => Number(v) : (v) => String(v),\n  };\n}\n\nconst styleMap: Record<IoMessageLevel, (str: string) => string> = {\n  error: chalk.red,\n  warn: chalk.yellow,\n  result: chalk.white,\n  info: chalk.white,\n  debug: chalk.gray,\n  trace: chalk.gray,\n};\n\n/**\n * Returns true if the current process is running in a CI environment\n * @returns true if the current process is running in a CI environment\n */\nexport function isCI(): boolean {\n  return process.env.CI !== undefined && process.env.CI !== 'false' && process.env.CI !== '0';\n}\n\nfunction targetStreamObject(x: TargetStream): NodeJS.WriteStream | undefined {\n  switch (x) {\n    case 'stderr':\n      return process.stderr;\n    case 'stdout':\n      return process.stdout;\n    case 'drop':\n      return undefined;\n  }\n}\n\nfunction isNoticesMessage(msg: IoMessage<unknown>) {\n  return IO.CDK_TOOLKIT_I0100.is(msg) || IO.CDK_TOOLKIT_W0101.is(msg) || IO.CDK_TOOLKIT_E0101.is(msg) || IO.CDK_TOOLKIT_I0101.is(msg);\n}\n"]}

package/lib/cli/io-host/index.d.ts

@@ -0,0 +1 @@
+export * from './cli-io-host';

package/lib/{toolkit/error.js → cli/io-host/index.js}

@@ -14,5 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("../../../@aws-cdk/tmp-toolkit-helpers/src/api/toolkit-error"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJlcnJvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsOEZBQTRFIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi4vLi4vLi4vQGF3cy1jZGsvdG1wLXRvb2xraXQtaGVscGVycy9zcmMvYXBpL3Rvb2xraXQtZXJyb3InO1xuIl19
+__exportStar(require("./cli-io-host"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsZ0RBQThCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jbGktaW8taG9zdCc7XG4iXX0=

package/lib/cli/messages.d.ts

@@ -1,6 +1,6 @@
+import type { IoMessageCode } from './io-host';
 import type { ActionLessMessage } from '../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import type { IoMessageCodeCategory } from '../logging';
-import type { IoMessageCode } from '../toolkit/cli-io-host';
 type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
 type SimplifiedMessage<T> = Omit<ActionLessMessage<T>, 'time'>;
 /**

package/lib/cli/messages.js

@@ -8,11 +8,10 @@ exports.formatMessage = formatMessage;
  * Applies optional styling and prepares the final message for logging.
  */
 function formatMessage(msg, category = 'TOOLKIT') {
-    var _a;
     return {
         time: new Date(),
         level: msg.level,
-        code: (_a = msg.code) !== null && _a !== void 0 ? _a : defaultMessageCode(msg.level, category),
+        code: msg.code ?? defaultMessageCode(msg.level, category),
         message: msg.message,
         data: msg.data,
     };
@@ -104,4 +103,4 @@ const trace = (message, code, payload) => {
     });
 };
 exports.trace = trace;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cli/pretty-print-error.d.ts

@@ -0,0 +1 @@
+export declare function prettyPrintError(error: unknown, debug?: boolean): void;

package/lib/cli/pretty-print-error.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyPrintError = prettyPrintError;
+/* eslint-disable no-console */
+const chalk = require("chalk");
+function prettyPrintError(error, 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, 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) {
+    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;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cli/root-dir.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cliRootDir = cliRootDir;
 const fs = require("fs");
 const path = require("path");
-const error_1 = require("../toolkit/error");
+const api_1 = require("../../../@aws-cdk/tmp-toolkit-helpers/src/api");
 function cliRootDir(fail) {
     function _rootDir(dirname) {
         const manifestPath = path.join(dirname, 'package.json');
@@ -11,8 +11,8 @@ function cliRootDir(fail) {
             return dirname;
         }
         if (path.dirname(dirname) === dirname) {
-            if (fail !== null && fail !== void 0 ? fail : true) {
-                throw new error_1.ToolkitError('Unable to find package manifest');
+            if (fail ?? true) {
+                throw new api_1.ToolkitError('Unable to find package manifest');
             }
             return undefined;
         }
@@ -20,4 +20,4 @@ function cliRootDir(fail) {
     }
     return _rootDir(__dirname);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm9vdC1kaXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJyb290LWRpci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQWNBLGdDQWdCQztBQTlCRCx5QkFBeUI7QUFDekIsNkJBQTZCO0FBQzdCLDRDQUFnRDtBQVloRCxTQUFnQixVQUFVLENBQUMsSUFBYztJQUN2QyxTQUFTLFFBQVEsQ0FBQyxPQUFlO1FBQy9CLE1BQU0sWUFBWSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLGNBQWMsQ0FBQyxDQUFDO1FBQ3hELElBQUksRUFBRSxDQUFDLFVBQVUsQ0FBQyxZQUFZLENBQUMsRUFBRSxDQUFDO1lBQ2hDLE9BQU8sT0FBTyxDQUFDO1FBQ2pCLENBQUM7UUFDRCxJQUFJLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEtBQUssT0FBTyxFQUFFLENBQUM7WUFDdEMsSUFBSSxJQUFJLGFBQUosSUFBSSxjQUFKLElBQUksR0FBSSxJQUFJLEVBQUUsQ0FBQztnQkFDakIsTUFBTSxJQUFJLG9CQUFZLENBQUMsaUNBQWlDLENBQUMsQ0FBQztZQUM1RCxDQUFDO1lBQ0QsT0FBTyxTQUFTLENBQUM7UUFDbkIsQ0FBQztRQUNELE9BQU8sUUFBUSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztJQUN6QyxDQUFDO0lBRUQsT0FBTyxRQUFRLENBQUMsU0FBUyxDQUFDLENBQUM7QUFDN0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIGZzIGZyb20gJ2ZzJztcbmltcG9ydCAqIGFzIHBhdGggZnJvbSAncGF0aCc7XG5pbXBvcnQgeyBUb29sa2l0RXJyb3IgfSBmcm9tICcuLi90b29sa2l0L2Vycm9yJztcblxuLyoqXG4gKiBGcm9tIHRoZSBjdXJyZW50IGZpbGUsIGZpbmQgdGhlIGRpcmVjdG9yeSB0aGF0IGNvbnRhaW5zIHRoZSBDTEkncyBwYWNrYWdlLmpzb25cbiAqXG4gKiBDYW4ndCB1c2UgYF9fZGlybmFtZWAgaW4gcHJvZHVjdGlvbiBjb2RlLCBhcyB0aGUgQ0xJIHdpbGwgZ2V0IGJ1bmRsZWQgYXMgaXQnc1xuICogcmVsZWFzZWQgYW5kIGBfX2Rpcm5hbWVgIHdpbGwgcmVmZXIgdG8gYSBkaWZmZXJlbnQgbG9jYXRpb24gaW4gdGhlIGAudHNgIGZvcm1cbiAqIGFzIGl0IHdpbGwgaW4gdGhlIGZpbmFsIGV4ZWN1dGluZyBmb3JtLlxuICovXG5leHBvcnQgZnVuY3Rpb24gY2xpUm9vdERpcigpOiBzdHJpbmc7XG5leHBvcnQgZnVuY3Rpb24gY2xpUm9vdERpcihmYWlsOiB0cnVlKTogc3RyaW5nO1xuZXhwb3J0IGZ1bmN0aW9uIGNsaVJvb3REaXIoZmFpbDogZmFsc2UpOiBzdHJpbmcgfCB1bmRlZmluZWQ7XG5leHBvcnQgZnVuY3Rpb24gY2xpUm9vdERpcihmYWlsPzogYm9vbGVhbikge1xuICBmdW5jdGlvbiBfcm9vdERpcihkaXJuYW1lOiBzdHJpbmcpOiBzdHJpbmcgfCB1bmRlZmluZWQge1xuICAgIGNvbnN0IG1hbmlmZXN0UGF0aCA9IHBhdGguam9pbihkaXJuYW1lLCAncGFja2FnZS5qc29uJyk7XG4gICAgaWYgKGZzLmV4aXN0c1N5bmMobWFuaWZlc3RQYXRoKSkge1xuICAgICAgcmV0dXJuIGRpcm5hbWU7XG4gICAgfVxuICAgIGlmIChwYXRoLmRpcm5hbWUoZGlybmFtZSkgPT09IGRpcm5hbWUpIHtcbiAgICAgIGlmIChmYWlsID8/IHRydWUpIHtcbiAgICAgICAgdGhyb3cgbmV3IFRvb2xraXRFcnJvcignVW5hYmxlIHRvIGZpbmQgcGFja2FnZSBtYW5pZmVzdCcpO1xuICAgICAgfVxuICAgICAgcmV0dXJuIHVuZGVmaW5lZDtcbiAgICB9XG4gICAgcmV0dXJuIF9yb290RGlyKHBhdGguZGlybmFtZShkaXJuYW1lKSk7XG4gIH1cblxuICByZXR1cm4gX3Jvb3REaXIoX19kaXJuYW1lKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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