aws-cdk 2.1128.0 → 2.1129.0

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

@@ -1,11 +1,48 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CliIoHost = void 0;
-const util = require("node:util");
+exports.matchAny = matchAny;
+const util = __importStar(require("node:util"));
 const cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema");
 const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
-const chalk = require("chalk");
-const promptly = require("promptly");
+const chalk_1 = __importDefault(require("chalk"));
+const promptly = __importStar(require("promptly"));
 const api_private_1 = require("../../../lib/api-private");
 const deploy_1 = require("../../commands/deploy");
 const collect_telemetry_1 = require("../telemetry/collect-telemetry");
@@ -35,20 +72,62 @@ class CliIoHost {
     static get() {
         return CliIoHost._instance;
     }
+    /**
+     * Singleton instance of the CliIoHost
+     */
+    static _instance;
+    /**
+     * The current action being performed by the CLI.
+     */
+    currentAction;
+    /**
+     * Whether the CliIoHost is running in CI mode.
+     *
+     * In CI mode, all non-error output goes to stdout instead of stderr.
+     */
+    isCI;
+    /**
+     * Whether the host can use interactions and message styling.
+     */
+    isTTY;
+    /**
+     * The current threshold.
+     *
+     * Messages with a lower priority level will be ignored.
+     */
+    logLevel;
+    /**
+     * The conditions for requiring approval in this CliIoHost.
+     */
+    requireDeployApproval;
+    /**
+     * Configure the target stream for notices
+     *
+     * (Not a setter because there's no need for additional logic when this value
+     * is changed yet)
+     */
+    noticesDestination = 'stderr';
+    _progress = deploy_1.StackActivityProgress.BAR;
+    // Stack Activity Printer
+    activityPrinter;
+    // Corked Logging
+    corkedCounter = 0;
+    corkedLoggingBuffer = [];
+    // Message listeners in registration order. Each carries a matcher (by code,
+    // or a custom predicate). See `on`/`once`/`rewrite`/`respond`.
+    messageListeners = [];
+    // Observers of how messages are handled (see ObservableIoHost / observeMessages).
+    messageObservers = new Set();
+    // True while replaying corked messages, so observers aren't notified twice.
+    corkReplaying = false;
+    autoRespond;
+    /**
+     * The telemetry session object
+     *
+     * Will remain `undefined` if the user has disabled telemetry.
+     */
+    telemetry;
     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 = [];
-        // Message listeners, keyed by message code. See `on`/`once`/`rewrite`/`rewriteOnce`.
-        this.messageListeners = new Map();
         this.currentAction = props.currentAction ?? 'none';
         this.isTTY = props.isTTY ?? process.stdout.isTTY ?? false;
         this.logLevel = props.logLevel ?? 'info';
@@ -172,108 +251,175 @@ class CliIoHost {
             this.corkedCounter--;
             if (this.corkedCounter === 0) {
                 // Process each buffered message through notify
-                for (const ioMessage of this.corkedLoggingBuffer) {
-                    await this.notify(ioMessage);
+                this.corkReplaying = true;
+                try {
+                    for (const ioMessage of this.corkedLoggingBuffer) {
+                        await this.notify(ioMessage);
+                    }
+                }
+                finally {
+                    this.corkReplaying = false;
                 }
                 // remove all buffered messages in-place
                 this.corkedLoggingBuffer.splice(0);
             }
         }
     }
+    on(selector, listener) {
+        return this.addMessageListener({ once: false, fn: listener, matches: messageMatcher(selector) });
+    }
+    /**
+     * Register an observer that is invoked for every message the host handles —
+     * both notifications and requests — with the disposition the host computed
+     * for it (its effective form after listeners and whether it was dropped). For
+     * a request, the resolved answer is the effective message's `defaultResponse`.
+     * Returns a function that removes the observer.
+     *
+     * @see ObservableIoHost
+     */
+    observeMessages(observer) {
+        this.messageObservers.add(observer);
+        return () => {
+            this.messageObservers.delete(observer);
+        };
+    }
+    once(selector, listener) {
+        return this.addMessageListener({ once: true, fn: listener, matches: messageMatcher(selector) });
+    }
+    /**
+     * Remove every message listener registered via `on`/`once`/`rewrite`/`respond`.
+     *
+     * The host's own internal listeners (such as stack-activity routing) are kept,
+     * so the host keeps working afterwards. Message observers registered via
+     * `observeMessages` are a separate mechanism and are not affected.
+     *
+     * This is mainly useful for tests that share the singleton host and need to
+     * reset listener state between cases (a leftover listener would otherwise
+     * leak into the next test).
+     */
+    removeAllListeners() {
+        // Drop user listeners in place (preserving array identity for any
+        // outstanding dispose closures); keep the host's internal listeners.
+        for (let i = this.messageListeners.length - 1; i >= 0; i--) {
+            if (!this.messageListeners[i].internal) {
+                this.messageListeners.splice(i, 1);
+            }
+        }
+    }
     /**
-     * Register a listener that is invoked for every message with the given code.
+     * Answer a request (by its code) on the user's behalf with a fixed value, so
+     * the host does not prompt. Syntactic sugar for an `on` listener returning
+     * `{ respond: value, preventDefault: suppressQuestion }`; for conditional
+     * answers or to also reword the question, use `on`/`once` directly. Returns a
+     * function that removes the responder again.
      *
-     * The listener may return a `MessageListenerResult` to update the message
-     * text and/or prevent the default processing (writing it to a stream);
-     * returning nothing leaves the message untouched. Returns a function that
-     * removes the listener again.
+     * @param suppressQuestion - whether to also suppress writing the question text.
+     *   Defaults to `true` (answer silently). Pass `false` to still surface the
+     *   question while answering it.
      *
      * @example
-     * const dispose = ioHost.on(IO.CDK_TOOLKIT_I2901, (msg) => {
-     *   myCount += msg.data.stacks.length;
-     * });
+     * // Under --force, auto-confirm the destroy prompt without prompting.
+     * const dispose = ioHost.respond(IO.CDK_TOOLKIT_I7010, true);
      */
-    on(code, listener) {
-        return this.addMessageListener(code.code, { once: false, fn: listener });
+    respond(code, value, suppressQuestion = true) {
+        return this.addMessageListener({ once: false, fn: () => ({ respond: value, preventDefault: suppressQuestion }), matches: messageMatcher(code) });
     }
     /**
-     * Like `on`, but the listener is automatically removed after it has been
-     * invoked once.
+     * Like `respond`, but the answer is given only once and then removed.
      */
-    once(code, listener) {
-        return this.addMessageListener(code.code, { once: true, fn: listener });
+    respondOnce(code, value, suppressQuestion = true) {
+        return this.addMessageListener({ once: true, fn: () => ({ respond: value, preventDefault: suppressQuestion }), matches: messageMatcher(code) });
     }
     /**
      * Register a formatter that replaces the printed text of messages with the
      * given code. This lets a caller define _how_ a toolkit message is presented
      * without the IoHost needing to know about it.
      *
-     * Syntactic sugar for an `on` listener that returns `{ message }`. Returns a
-     * function that removes the formatter again.
+     * Optionally pass a `level` to also override the message's level (which moves
+     * it between stdout/stderr and changes verbosity filtering). For the rarer
+     * case of overriding only the level, use `on`/`once` returning `{ level }`.
+     *
+     * Syntactic sugar for an `on` listener that returns `{ message, level? }`.
+     * Returns a function that removes the formatter again.
      *
      * @example
      * const dispose = ioHost.rewrite(IO.CDK_TOOLKIT_I2901, (msg) =>
      *   serializeStructure(msg.data.stacks, true));
      */
-    rewrite(code, formatter) {
-        return this.on(code, (msg) => ({ message: formatter(msg) }));
+    rewrite(code, formatter, level) {
+        return this.on(code, (msg) => ({ message: formatter(msg), ...(level !== undefined ? { level } : {}) }));
     }
     /**
      * Like `rewrite`, but the formatter is automatically removed after it has
      * been applied once.
      */
-    rewriteOnce(code, formatter) {
-        return this.once(code, (msg) => ({ message: formatter(msg) }));
+    rewriteOnce(code, formatter, level) {
+        return this.once(code, (msg) => ({ message: formatter(msg), ...(level !== undefined ? { level } : {}) }));
     }
     /**
      * Add a listener to the registry and return a function that removes it.
      */
-    addMessageListener(code, listener) {
-        const listeners = this.messageListeners.get(code) ?? [];
-        listeners.push(listener);
-        this.messageListeners.set(code, listeners);
+    addMessageListener(listener) {
+        this.messageListeners.push(listener);
         return () => {
-            const index = listeners.indexOf(listener);
+            const index = this.messageListeners.indexOf(listener);
             if (index >= 0) {
-                listeners.splice(index, 1);
+                this.messageListeners.splice(index, 1);
             }
         };
     }
     /**
-     * Run all registered listeners for a message's code, in registration order.
+     * Run every registered listener that matches the message, in registration
+     * order. A listener matches by its code (maker) or its custom predicate.
      *
-     * A listener may update the message text (which is passed on to subsequent
-     * listeners and the rest of the pipeline) and/or request that the default
-     * processing be skipped. `once` listeners are removed after they have run.
+     * A listener may update the message text/level (passed on to subsequent
+     * listeners and the rest of the pipeline), prevent the default processing, or
+     * (for requests) answer it. `once` listeners are removed after they have run.
+     * Matching is decided against the message as emitted, so a rewrite by an
+     * earlier listener does not change which later listeners apply.
      *
-     * Returns the (possibly text-updated) message and whether any listener
-     * prevented the default processing.
+     * Returns the (possibly updated) message, whether the default processing was
+     * prevented, and whether a listener answered the request (and with what).
      */
-    applyMessageListeners(msg) {
+    async applyMessageListeners(msg) {
         let current = msg;
         let preventDefault = false;
-        const listeners = msg.code ? this.messageListeners.get(msg.code) : undefined;
-        if (listeners && listeners.length > 0) {
-            // Iterate over a copy so that `once` listeners can remove themselves safely.
-            for (const listener of [...listeners]) {
-                const result = listener.fn(current);
-                if (listener.once) {
-                    const index = listeners.indexOf(listener);
-                    if (index >= 0) {
-                        listeners.splice(index, 1);
-                    }
+        let responded = false;
+        // Iterate over a copy so that `once` listeners can remove themselves safely.
+        for (const listener of [...this.messageListeners]) {
+            // Match against the emitted message; a listener receives the cumulatively
+            // transformed `current` message.
+            if (!listener.matches(msg)) {
+                continue;
+            }
+            // Listeners may be async; await each one before running the next so the
+            // cumulative effect on the message stays order-deterministic.
+            const result = await listener.fn(current);
+            if (listener.once) {
+                const index = this.messageListeners.indexOf(listener);
+                if (index >= 0) {
+                    this.messageListeners.splice(index, 1);
                 }
-                if (result) {
-                    if (result.message !== undefined) {
-                        current = { ...current, message: result.message };
-                    }
-                    if (result.preventDefault) {
-                        preventDefault = true;
-                    }
+            }
+            if (result) {
+                if (result.message !== undefined) {
+                    current = { ...current, message: result.message };
+                }
+                if (result.level !== undefined) {
+                    current = { ...current, level: result.level };
+                }
+                if (result.preventDefault) {
+                    preventDefault = true;
+                }
+                if ('respond' in result && 'defaultResponse' in msg) {
+                    // Fold the answer into the request's default response and mark it
+                    // answered, so we skip prompting and resolve with this value.
+                    current = { ...current, defaultResponse: result.respond };
+                    responded = true;
                 }
             }
         }
-        return { message: current, preventDefault };
+        return { message: current, preventDefault, responded };
     }
     /**
      * Notifies the host of a message.
@@ -284,10 +430,37 @@ class CliIoHost {
         // Run any registered listeners. A listener may update the message text
         // and/or prevent the default processing (e.g. stack-activity messages are
         // routed to the activity printer and not written to a stream).
-        const { message, preventDefault } = this.applyMessageListeners(msg);
+        const { message, preventDefault } = await this.applyMessageListeners(msg);
+        // Tell observers how this message was handled (its effective form and
+        // whether it was dropped). Skipped while replaying corked messages so each
+        // message is observed exactly once.
+        if (!this.corkReplaying) {
+            this.notifyObservers({ type: 'notify', emitted: msg, effective: message, dropped: preventDefault });
+        }
         if (preventDefault) {
             return;
         }
+        this.writeMessage(message);
+    }
+    /**
+     * Notify every registered message observer of how a message or request was
+     * handled. A no-op when nothing is observing (i.e. outside of tests), so the
+     * surrounding hot paths pay nothing in production.
+     */
+    notifyObservers(observation) {
+        if (this.messageObservers.size === 0) {
+            return;
+        }
+        for (const observer of this.messageObservers) {
+            observer(observation);
+        }
+    }
+    /**
+     * Write a (already listener-processed) message to its target stream, honoring
+     * the log level and corked-logging buffer. Shared by `notify` and the
+     * non-prompting `requestResponse` path.
+     */
+    writeMessage(message) {
         if (!(0, api_private_1.isMessageRelevantForLevel)(message, this.logLevel)) {
             return;
         }
@@ -326,9 +499,14 @@ class CliIoHost {
             this.activityPrinter.notify(msg);
             return { preventDefault: true }; // handled by the printer; don't also write to a stream
         };
-        this.on(api_private_1.IO.CDK_TOOLKIT_I5501, route);
-        this.on(api_private_1.IO.CDK_TOOLKIT_I5502, route);
-        this.on(api_private_1.IO.CDK_TOOLKIT_I5503, route);
+        // A single internal listener (so it survives `removeAllListeners()` and the
+        // host keeps routing stack activity) matching any of the activity codes.
+        this.addMessageListener({
+            once: false,
+            internal: true,
+            fn: route,
+            matches: matchAny(api_private_1.IO.CDK_TOOLKIT_I5501, api_private_1.IO.CDK_TOOLKIT_I5502, api_private_1.IO.CDK_TOOLKIT_I5503),
+        });
     }
     /**
      * Detect special messages encode information about whether or not
@@ -383,13 +561,38 @@ class CliIoHost {
     /**
      * 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.
+     * Registered listeners run first: a listener may reword the question (its text
+     * or level) or answer it outright via `respond` (e.g. `--force` auto-confirms
+     * a destroy). If no listener answers and the host cannot prompt, the suggested
+     * default response is used.
      */
     async requestResponse(msg) {
-        // If the request cannot be prompted for by the CliIoHost, we just accept the default
-        if (!isPromptableRequest(msg)) {
-            await this.notify(msg);
+        // Listeners run exactly once here (so we don't go back through `notify`):
+        // they may answer the request, or reword/relevel the question shown below.
+        const { message, ...listenerResult } = await this.applyMessageListeners(msg);
+        const response = await this.resolveRequest(message, listenerResult);
+        // Tell observers how this request was handled: the effective (possibly reworded) question
+        // and the resolved response. When a listener answered the request with the question suppressed
+        // (`preventDefault`, e.g. `--force` auto-confirm), it is reported as `dropped` since the user never saw it.
+        this.notifyObservers({ type: 'request', emitted: msg, effective: message, dropped: listenerResult.preventDefault });
+        return response;
+    }
+    /**
+     * Resolve a request to its response: a listener's answer if one was given,
+     * otherwise the answer prompted from the user, otherwise the suggested
+     * default when the host cannot prompt.
+     *
+     * Kept separate from `requestResponse` so the response can be observed in a
+     * single place regardless of which of these paths produced it.
+     */
+    async resolveRequest(msg, listenerResult) {
+        // stop processing, a listener has taken care of it
+        if (listenerResult.preventDefault) {
+            return msg.defaultResponse;
+        }
+        // if a listener provided a response, we skip interaction
+        if (!isPromptableRequest(msg) || listenerResult.responded) {
+            this.writeMessage(msg);
             return msg.defaultResponse;
         }
         const response = await this.withCorkedLogging(async () => {
@@ -410,17 +613,17 @@ class CliIoHost {
             if (this.autoRespond) {
                 // respond with yes to all confirmations
                 if (isConfirmationPrompt(msg)) {
-                    await this.notify({
+                    await this.writeMessage({
                         ...msg,
-                        message: `${chalk.cyan(msg.message)} (auto-confirmed)`,
+                        message: `${chalk_1.default.cyan(msg.message)} (auto-confirmed)`,
                     });
                     return true;
                 }
                 // respond with the default for all other messages
                 if (msg.defaultResponse) {
-                    await this.notify({
+                    await this.writeMessage({
                         ...msg,
-                        message: `${chalk.cyan(msg.message)} (auto-responded with default: ${util.format(msg.defaultResponse)})`,
+                        message: `${chalk_1.default.cyan(msg.message)} (auto-responded with default: ${util.format(msg.defaultResponse)})`,
                     });
                     return msg.defaultResponse;
                 }
@@ -435,17 +638,16 @@ class CliIoHost {
             }
             // Basic confirmation prompt
             // We treat all requests with a boolean response as confirmation prompts
+            // The IoHost never aborts on a "no": it returns the answer and lets the
+            // calling action decide what to do (so abort handling is consistent
+            // across actions).
             if (isConfirmationPrompt(msg)) {
-                const confirmed = await promptly.confirm(`${chalk.cyan(msg.message)} (y/n)`);
-                if (!confirmed) {
-                    throw new toolkit_lib_1.ToolkitError('AbortedByUser', 'Aborted by user');
-                }
-                return confirmed;
+                return promptly.confirm(`${chalk_1.default.cyan(msg.message)} (y/n)`);
             }
             // Asking for a specific value
             const prompt = extractPromptInfo(msg);
             const desc = responseDescription ?? prompt.default;
-            const answer = await promptly.prompt(`${chalk.cyan(msg.message)}${desc ? ` (${desc})` : ''}`, {
+            const answer = await promptly.prompt(`${chalk_1.default.cyan(msg.message)}${desc ? ` (${desc})` : ''}`, {
                 default: prompt.default,
                 trim: true,
             });
@@ -492,6 +694,30 @@ class CliIoHost {
     }
 }
 exports.CliIoHost = CliIoHost;
+/**
+ * Convert a `MessageSelector` into a predicate that decides whether a listener
+ * applies to a message. A maker matches messages carrying its `code`; a
+ * predicate (e.g. a maker's `.is`, or any `(msg) => boolean`) is used as-is.
+ */
+function messageMatcher(selector) {
+    if (typeof selector === 'function') {
+        return selector;
+    }
+    const { code } = selector;
+    return (msg) => msg.code === code;
+}
+/**
+ * Combine several selectors into a single predicate that matches a message when
+ * *any* of them matches. Each selector may be a maker (matched by its `code`)
+ * or a predicate.
+ *
+ * Useful for one listener that spans multiple codes, e.g.
+ * `ioHost.on(matchAny(IO.CDK_TOOLKIT_I5501, IO.CDK_TOOLKIT_I5502), listener)`.
+ */
+function matchAny(...selectors) {
+    const matchers = selectors.map(messageMatcher);
+    return (msg) => matchers.some((matches) => matches(msg));
+}
 /**
  * This IoHost implementation considers a request promptable, if:
  * - it's a yes/no confirmation
@@ -522,12 +748,12 @@ function extractPromptInfo(msg) {
     };
 }
 const styleMap = {
-    error: chalk.red,
-    warn: chalk.yellow,
-    result: chalk.reset,
-    info: chalk.reset,
-    debug: chalk.gray,
-    trace: chalk.gray,
+    error: chalk_1.default.red,
+    warn: chalk_1.default.yellow,
+    result: chalk_1.default.reset,
+    info: chalk_1.default.reset,
+    debug: chalk_1.default.gray,
+    trace: chalk_1.default.gray,
 };
 function targetStreamObject(x) {
     switch (x) {
@@ -600,4 +826,4 @@ function hotswapToEventResult(result) {
         },
     };
 }
-//# 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 type { Agent } from 'node:https';\nimport * as util from 'node:util';\nimport { RequireApproval } from '@aws-cdk/cloud-assembly-schema';\nimport { ToolkitError } from '@aws-cdk/toolkit-lib';\nimport type { HotswapResult, IIoHost, IoMessage, IoMessageCode, IoMessageLevel, IoRequest, ToolkitAction } from '@aws-cdk/toolkit-lib';\nimport * as chalk from 'chalk';\nimport * as promptly from 'promptly';\nimport type { IoHelper, ActivityPrinterProps, IActivityPrinter, IoMessageMaker, IoDefaultMessages } from '../../../lib/api-private';\nimport { asIoHelper, IO, isMessageRelevantForLevel, CurrentActivityPrinter, HistoryActivityPrinter } from '../../../lib/api-private';\nimport type { Context } from '../../api/context';\nimport { StackActivityProgress } from '../../commands/deploy';\nimport { canCollectTelemetry } from '../telemetry/collect-telemetry';\nimport { cdkCliErrorName } from '../telemetry/error';\nimport type { EventResult } from '../telemetry/messages';\nimport { CLI_PRIVATE_IO } from '../telemetry/messages';\nimport type { TelemetryEvent } from '../telemetry/session';\nimport { TelemetrySession } from '../telemetry/session';\nimport { EndpointTelemetrySink } from '../telemetry/sink/endpoint-sink';\nimport { FileTelemetrySink } from '../telemetry/sink/file-sink';\nimport { Funnel } from '../telemetry/sink/funnel';\nimport type { ITelemetrySink } from '../telemetry/sink/sink-interface';\nimport { isCI } from '../util/ci';\n\nexport type { IIoHost, IoMessage, IoMessageCode, IoMessageLevel, IoRequest };\n\n/**\n * The current action being performed by the CLI. 'none' represents the absence of an action.\n */\ntype CliAction =\n  | ToolkitAction\n  | 'context'\n  | 'docs'\n  | 'flags'\n  | 'notices'\n  | 'version'\n  | 'cli-telemetry'\n  | 'none';\n\nexport interface CliIoHostProps {\n  /**\n   * The initial Toolkit action the hosts starts with.\n   *\n   * @default 'none'\n   */\n  readonly currentAction?: CliAction;\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   * Whether the CLI should attempt to automatically respond to prompts.\n   *\n   * When true, operation will usually proceed without interactive confirmation.\n   * Confirmations are responded to with yes. Other prompts will respond with the default value.\n   *\n   * @default false\n   */\n  readonly autoRespond?: boolean;\n}\n\n/**\n * A type for configuring a target stream\n */\nexport type TargetStream = 'stdout' | 'stderr' | 'drop';\n\n/**\n * The result a message listener may return to influence how a message is handled.\n *\n * A listener can only update the message _text_; it cannot change any other\n * field of the message (such as its `code`), which keeps the code-keyed\n * listener registry valid.\n */\nexport interface MessageListenerResult {\n  /**\n   * Replace the text that is printed for this message.\n   *\n   * @default - the message text is left unchanged\n   */\n  readonly message?: string;\n\n  /**\n   * Skip the default processing of the message, i.e. do not write it to a stream.\n   *\n   * @default false\n   */\n  readonly preventDefault?: boolean;\n}\n\n/**\n * A registered message listener. Its return value (if any) may update the\n * message text and/or prevent the default processing.\n */\ntype MessageListenerFn = (msg: IoMessage<any>) => void | MessageListenerResult;\ninterface MessageListener {\n  readonly once: boolean;\n  readonly fn: MessageListenerFn;\n}\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   * Returns the singleton instance if it exists\n   */\n  static get(): CliIoHost | undefined {\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 _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  // Message listeners, keyed by message code. See `on`/`once`/`rewrite`/`rewriteOnce`.\n  private readonly messageListeners = new Map<IoMessageCode, MessageListener[]>();\n\n  private readonly autoRespond: boolean;\n\n  /**\n   * The telemetry session object\n   *\n   * Will remain `undefined` if the user has disabled telemetry.\n   */\n  public telemetry?: TelemetrySession;\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    this.stackProgress = props.stackProgress ?? StackActivityProgress.BAR;\n    this.autoRespond = props.autoRespond ?? false;\n\n    // Stack-activity messages are handled by the activity printer rather than\n    // written to a stream. This is wired up as message listeners.\n    this.routeStackActivityToPrinter();\n  }\n\n  public async startTelemetry(args: any, context: Context, proxyAgent?: Agent) {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const config = require('../cli-type-registry.json');\n    const validCommands = Object.keys(config.commands);\n    const cmd = args._[0];\n    if (!validCommands.includes(cmd)) {\n      // the user typed in an invalid command - no need for telemetry since the invocation is going to fail\n      // imminently anyway.\n      await this.asIoHelper().defaults.trace(`Session instantiated with an invalid command (${cmd}). Not starting telemetry.`);\n      return;\n    }\n\n    let sinks: ITelemetrySink[] = [];\n    const telemetryFilePath = args['telemetry-file'];\n    if (telemetryFilePath) {\n      try {\n        sinks.push(new FileTelemetrySink({\n          ioHost: this,\n          logFilePath: telemetryFilePath,\n        }));\n        await this.asIoHelper().defaults.trace('File Telemetry connected');\n      } catch (e: any) {\n        await this.asIoHelper().defaults.trace(`File Telemetry instantiation failed: ${e.message}`);\n      }\n    }\n\n    const telemetryEndpoint = process.env.TELEMETRY_ENDPOINT ?? 'https://cdk-cli-telemetry.us-east-1.api.aws/metrics';\n    if (canCollectTelemetry(args, context) && telemetryEndpoint) {\n      try {\n        sinks.push(new EndpointTelemetrySink({\n          ioHost: this,\n          agent: proxyAgent,\n          endpoint: telemetryEndpoint,\n        }));\n        await this.asIoHelper().defaults.trace('Endpoint Telemetry connected');\n      } catch (e: any) {\n        await this.asIoHelper().defaults.trace(`Endpoint Telemetry instantiation failed: ${e.message}`);\n      }\n    } else {\n      await this.asIoHelper().defaults.trace('Endpoint Telemetry NOT connected');\n    }\n\n    if (sinks.length > 0) {\n      this.telemetry = new TelemetrySession({\n        ioHost: this,\n        client: new Funnel({ sinks }),\n        arguments: args,\n        context: context,\n      });\n    }\n\n    await this.telemetry?.begin();\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(): IoDefaultMessages {\n    return this.asIoHelper().defaults;\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   * Register a listener that is invoked for every message with the given code.\n   *\n   * The listener may return a `MessageListenerResult` to update the message\n   * text and/or prevent the default processing (writing it to a stream);\n   * returning nothing leaves the message untouched. Returns a function that\n   * removes the listener again.\n   *\n   * @example\n   * const dispose = ioHost.on(IO.CDK_TOOLKIT_I2901, (msg) => {\n   *   myCount += msg.data.stacks.length;\n   * });\n   */\n  public on<T>(code: IoMessageMaker<T>, listener: (msg: IoMessage<T>) => void | MessageListenerResult): () => void {\n    return this.addMessageListener(code.code, { once: false, fn: listener as MessageListenerFn });\n  }\n\n  /**\n   * Like `on`, but the listener is automatically removed after it has been\n   * invoked once.\n   */\n  public once<T>(code: IoMessageMaker<T>, listener: (msg: IoMessage<T>) => void | MessageListenerResult): () => void {\n    return this.addMessageListener(code.code, { once: true, fn: listener as MessageListenerFn });\n  }\n\n  /**\n   * Register a formatter that replaces the printed text of messages with the\n   * given code. This lets a caller define _how_ a toolkit message is presented\n   * without the IoHost needing to know about it.\n   *\n   * Syntactic sugar for an `on` listener that returns `{ message }`. Returns a\n   * function that removes the formatter again.\n   *\n   * @example\n   * const dispose = ioHost.rewrite(IO.CDK_TOOLKIT_I2901, (msg) =>\n   *   serializeStructure(msg.data.stacks, true));\n   */\n  public rewrite<T>(code: IoMessageMaker<T>, formatter: (msg: IoMessage<T>) => string): () => void {\n    return this.on(code, (msg) => ({ message: formatter(msg) }));\n  }\n\n  /**\n   * Like `rewrite`, but the formatter is automatically removed after it has\n   * been applied once.\n   */\n  public rewriteOnce<T>(code: IoMessageMaker<T>, formatter: (msg: IoMessage<T>) => string): () => void {\n    return this.once(code, (msg) => ({ message: formatter(msg) }));\n  }\n\n  /**\n   * Add a listener to the registry and return a function that removes it.\n   */\n  private addMessageListener(code: IoMessageCode, listener: MessageListener): () => void {\n    const listeners = this.messageListeners.get(code) ?? [];\n    listeners.push(listener);\n    this.messageListeners.set(code, listeners);\n\n    return () => {\n      const index = listeners.indexOf(listener);\n      if (index >= 0) {\n        listeners.splice(index, 1);\n      }\n    };\n  }\n\n  /**\n   * Run all registered listeners for a message's code, in registration order.\n   *\n   * A listener may update the message text (which is passed on to subsequent\n   * listeners and the rest of the pipeline) and/or request that the default\n   * processing be skipped. `once` listeners are removed after they have run.\n   *\n   * Returns the (possibly text-updated) message and whether any listener\n   * prevented the default processing.\n   */\n  private applyMessageListeners(msg: IoMessage<unknown>): { message: IoMessage<unknown>; preventDefault: boolean } {\n    let current = msg;\n    let preventDefault = false;\n\n    const listeners = msg.code ? this.messageListeners.get(msg.code) : undefined;\n    if (listeners && listeners.length > 0) {\n      // Iterate over a copy so that `once` listeners can remove themselves safely.\n      for (const listener of [...listeners]) {\n        const result = listener.fn(current);\n\n        if (listener.once) {\n          const index = listeners.indexOf(listener);\n          if (index >= 0) {\n            listeners.splice(index, 1);\n          }\n        }\n\n        if (result) {\n          if (result.message !== undefined) {\n            current = { ...current, message: result.message };\n          }\n          if (result.preventDefault) {\n            preventDefault = true;\n          }\n        }\n      }\n    }\n\n    return { message: current, preventDefault };\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    await this.maybeEmitTelemetry(msg);\n\n    // Run any registered listeners. A listener may update the message text\n    // and/or prevent the default processing (e.g. stack-activity messages are\n    // routed to the activity printer and not written to a stream).\n    const { message, preventDefault } = this.applyMessageListeners(msg);\n    if (preventDefault) {\n      return;\n    }\n\n    if (!isMessageRelevantForLevel(message, this.logLevel)) {\n      return;\n    }\n\n    if (this.corkedCounter > 0) {\n      this.corkedLoggingBuffer.push(message);\n      return;\n    }\n\n    const output = this.formatMessage(message);\n    const stream = this.selectStream(message);\n    stream?.write(output);\n  }\n\n  private async maybeEmitTelemetry(msg: IoMessage<unknown>) {\n    try {\n      const telemetryEvent = eventFromMessage(msg);\n      if (telemetryEvent) {\n        await this.telemetry?.emit(telemetryEvent);\n      }\n    } catch (e: any) {\n      await this.defaults.trace(`Emit Telemetry Failed ${e.message}`);\n    }\n  }\n\n  /**\n   * Route stack-activity messages to the activity printer (progress bar or\n   * event list) rather than writing them to a stream.\n   *\n   * Implemented as listeners that handle the message via the printer and\n   * prevent the default processing, so the rest of the pipeline does not also\n   * emit them. The printer is created lazily on the first stack-activity message.\n   */\n  private routeStackActivityToPrinter() {\n    const route = (msg: IoMessage<unknown>): MessageListenerResult => {\n      if (!this.activityPrinter) {\n        this.activityPrinter = this.makeActivityPrinter();\n      }\n      this.activityPrinter.notify(msg);\n      return { preventDefault: true }; // handled by the printer; don't also write to a stream\n    };\n\n    this.on(IO.CDK_TOOLKIT_I5501, route);\n    this.on(IO.CDK_TOOLKIT_I5502, route);\n    this.on(IO.CDK_TOOLKIT_I5503, route);\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 (!(msg.code && approvalToolkitCodes.includes(msg.code))) {\n      return 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    // 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        responseDescription?: string;\n      } = msg.data ?? {};\n\n      const motivation = data.motivation ?? 'User input is needed';\n      const concurrency = data.concurrency ?? 0;\n      const responseDescription = data.responseDescription;\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      // In --yes mode, respond for the user if we can\n      if (this.autoRespond) {\n        // respond with yes to all confirmations\n        if (isConfirmationPrompt(msg)) {\n          await this.notify({\n            ...msg,\n            message: `${chalk.cyan(msg.message)} (auto-confirmed)`,\n          });\n          return true;\n        }\n\n        // respond with the default for all other messages\n        if (msg.defaultResponse) {\n          await this.notify({\n            ...msg,\n            message: `${chalk.cyan(msg.message)} (auto-responded with default: ${util.format(msg.defaultResponse)})`,\n          });\n          return msg.defaultResponse;\n        }\n      }\n\n      // only talk to user if STDIN is a terminal (otherwise, fail)\n      if (!this.isTTY) {\n        throw new ToolkitError('TtyNotAttached', `${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('ConcurrencyConflict', `${motivation}, but concurrency is greater than 1 so we are unable to get a confirmation from the user`);\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('AbortedByUser', 'Aborted by user');\n        }\n        return confirmed;\n      }\n\n      // Asking for a specific value\n      const prompt = extractPromptInfo(msg);\n      const desc = responseDescription ?? prompt.default;\n      const answer = await promptly.prompt(`${chalk.cyan(msg.message)}${desc ? ` (${desc})` : ''}`, {\n        default: prompt.default,\n        trim: true,\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  defaultDesc: string;\n  convertAnswer: (input: string) => string | number;\n} {\n  const isNumber = (typeof msg.defaultResponse === 'number');\n  const defaultResponse = util.format(msg.defaultResponse);\n  return {\n    default: defaultResponse,\n    defaultDesc: 'defaultDescription' in msg && msg.defaultDescription ? util.format(msg.defaultDescription) : 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.reset,\n  info: chalk.reset,\n  debug: chalk.gray,\n  trace: chalk.gray,\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>): msg is IoMessage<void> {\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\nfunction eventFromMessage(msg: IoMessage<unknown>): TelemetryEvent | undefined {\n  if (CLI_PRIVATE_IO.CDK_CLI_I1001.is(msg)) {\n    return eventResult('SYNTH', msg);\n  }\n  if (CLI_PRIVATE_IO.CDK_CLI_I2001.is(msg)) {\n    return eventResult('INVOKE', msg);\n  }\n  if (CLI_PRIVATE_IO.CDK_CLI_I3001.is(msg)) {\n    return eventResult('DEPLOY', msg);\n  }\n  if (CLI_PRIVATE_IO.CDK_CLI_I3003.is(msg)) {\n    return eventResult('ASSET', msg);\n  }\n  // Hotswap lives in the cdk-toolkit so it cannot be a CDK_CLI error code.\n  // Instead we reuse the existing Hotswap span.\n  if (IO.CDK_TOOLKIT_I5410.is(msg)) {\n    // Create a telemetry-compatible result\n    return hotswapToEventResult(msg.data);\n  }\n  return undefined;\n\n  function eventResult(eventType: TelemetryEvent['eventType'], m: IoMessage<EventResult>): TelemetryEvent {\n    return {\n      eventType,\n      duration: m.data.duration,\n      error: m.data.error,\n      counters: m.data.counters,\n    };\n  }\n}\n\nfunction hotswapToEventResult(result: HotswapResult): TelemetryEvent {\n  const nonHotswappableResources: Record<string, number> = {};\n  for (const { subject } of result.nonHotswappableChanges) {\n    if ('resourceType' in subject) {\n      const keys = 'rejectedProperties' in subject && subject.rejectedProperties\n        ? subject.rejectedProperties.map(p => `hotswapFallback:${subject.resourceType}#${p}`)\n        : [`hotswapFallback:${subject.resourceType}`];\n      for (const key of keys) {\n        nonHotswappableResources[key] = (nonHotswappableResources[key] ?? 0) + 1;\n      }\n    }\n  }\n\n  return {\n    eventType: 'HOTSWAP' as const,\n    duration: result.duration,\n    ...(result.error ? {\n      error: {\n        name: cdkCliErrorName(result.error),\n      },\n    } : {}),\n    counters: {\n      hotswapped: result.hotswapped ? 1 : 0,\n      hotswapFallback: result.hotswapFallback ? 1 : 0,\n      hotswappableChanges: result.hotswappableChanges.length,\n      nonHotswappableChanges: result.nonHotswappableChanges.length,\n      ...nonHotswappableResources,\n    },\n  };\n}\n"]}
+//# 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 type { Agent } from 'node:https';\nimport * as util from 'node:util';\nimport { RequireApproval } from '@aws-cdk/cloud-assembly-schema';\nimport { ToolkitError } from '@aws-cdk/toolkit-lib';\nimport type { HotswapResult, IIoHost, IoMessage, IoMessageCode, IoMessageLevel, IoRequest, ToolkitAction } from '@aws-cdk/toolkit-lib';\nimport chalk from 'chalk';\nimport * as promptly from 'promptly';\nimport type { IoHelper, ActivityPrinterProps, IActivityPrinter, IoMessageMaker, IoRequestMaker, IoDefaultMessages } from '../../../lib/api-private';\nimport { asIoHelper, IO, isMessageRelevantForLevel, CurrentActivityPrinter, HistoryActivityPrinter } from '../../../lib/api-private';\nimport type { Context } from '../../api/context';\nimport { StackActivityProgress } from '../../commands/deploy';\nimport { canCollectTelemetry } from '../telemetry/collect-telemetry';\nimport { cdkCliErrorName } from '../telemetry/error';\nimport type { EventResult } from '../telemetry/messages';\nimport { CLI_PRIVATE_IO } from '../telemetry/messages';\nimport type { TelemetryEvent } from '../telemetry/session';\nimport { TelemetrySession } from '../telemetry/session';\nimport { EndpointTelemetrySink } from '../telemetry/sink/endpoint-sink';\nimport { FileTelemetrySink } from '../telemetry/sink/file-sink';\nimport { Funnel } from '../telemetry/sink/funnel';\nimport type { ITelemetrySink } from '../telemetry/sink/sink-interface';\nimport { isCI } from '../util/ci';\n\nexport type { IIoHost, IoMessage, IoMessageCode, IoMessageLevel, IoRequest };\n\n/**\n * The current action being performed by the CLI. 'none' represents the absence of an action.\n */\ntype CliAction =\n  | ToolkitAction\n  | 'context'\n  | 'docs'\n  | 'flags'\n  | 'notices'\n  | 'version'\n  | 'cli-telemetry'\n  | 'none';\n\nexport interface CliIoHostProps {\n  /**\n   * The initial Toolkit action the hosts starts with.\n   *\n   * @default 'none'\n   */\n  readonly currentAction?: CliAction;\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   * Whether the CLI should attempt to automatically respond to prompts.\n   *\n   * When true, operation will usually proceed without interactive confirmation.\n   * Confirmations are responded to with yes. Other prompts will respond with the default value.\n   *\n   * @default false\n   */\n  readonly autoRespond?: boolean;\n}\n\n/**\n * A type for configuring a target stream\n */\nexport type TargetStream = 'stdout' | 'stderr' | 'drop';\n\n/**\n * The result a message listener may return to influence how a message is handled.\n *\n * A listener may update the message _text_ and/or its _level_; it cannot change\n * any other field of the message (such as its `code`), which keeps the\n * code-keyed listener registry valid.\n */\nexport interface MessageListenerResult {\n  /**\n   * Replace the text that is printed for this message.\n   *\n   * @default - the message text is left unchanged\n   */\n  readonly message?: string;\n\n  /**\n   * Override the level of this message.\n   *\n   * The new level is used for both verbosity filtering and stream selection, so\n   * this can move a message between stdout/stderr (e.g. downgrade a `result` to\n   * `info`). The `code` is intentionally left unchanged.\n   *\n   * @default - the message level is left unchanged\n   */\n  readonly level?: IoMessageLevel;\n\n  /**\n   * Skip the default handling of the message.\n   *\n   * For a notification this means it is not written to a stream. For a request\n   * it stops processing entirely: the user is not prompted, nothing is written,\n   * and the request resolves with its (possibly `respond`-overridden) default\n   * response.\n   *\n   * @default false\n   */\n  readonly preventDefault?: boolean;\n\n  /**\n   * For requests only: the value to resolve the request with. It is folded into\n   * the request's default response and skips the prompt (the request is treated\n   * as not promptable). The question is still written unless `preventDefault` is\n   * also set. Ignored for plain notifications.\n   *\n   * The presence of the key is what matters, so `false`/`0`/`''` are valid\n   * answers. Use the `respond`/`respondOnce` helpers for the common case.\n   *\n   * @default - this listener does not supply a response\n   */\n  readonly respond?: unknown;\n}\n\n/**\n * What a message listener may return: nothing, a `MessageListenerResult`, or a\n * `Promise` of either.\n *\n * Listeners may be async. The host awaits each listener before running the\n * next, so registration order — and the cumulative effect on the message — is\n * preserved regardless of whether listeners are sync or async.\n */\nexport type MessageListenerResultOrPromise = void | MessageListenerResult | Promise<void | MessageListenerResult>;\n\n/**\n * A registered message listener. Its return value (if any) may update the\n * message text and/or prevent the default processing. It may be async.\n */\ntype MessageListenerFn = (msg: IoMessage<any>) => MessageListenerResultOrPromise;\ninterface MessageListener {\n  readonly once: boolean;\n  readonly fn: MessageListenerFn;\n  /**\n   * Decides which messages this listener applies to. For a listener registered\n   * with a maker this matches by `code`; for one registered with a predicate it\n   * is the predicate itself.\n   */\n  readonly matches: (msg: IoMessage<unknown>) => boolean;\n  /**\n   * Whether this is one of the host's own internal listeners (e.g. stack-activity\n   * routing). Internal listeners are not removed by `removeAllListeners`.\n   *\n   * @default false - a user listener registered via `on`/`once`/`rewrite`/`respond`\n   */\n  readonly internal?: boolean;\n}\n\n/**\n * Selects which messages a listener applies to.\n *\n * Either a message/request *maker* — the listener fires for messages with that\n * maker's `code` (the original behavior) — or a custom *predicate* over the\n * message. A maker's `.is` type guard (e.g. `IO.CDK_TOOLKIT_I7010.is`) is a\n * convenient predicate, but any `(msg) => boolean` works (e.g. to match a family\n * of codes, or on the message level).\n */\nexport type MessageSelector<T> =\n  | IoMessageMaker<T>\n  | IoRequestMaker<T, any>\n  | ((msg: IoMessage<any>) => boolean);\n\n/**\n * How an IoHost processed a single message or request.\n *\n * This describes the message *as the host handled it*, which can differ from\n * what was emitted: listeners may rewrite the text or level, prevent it from\n * being written at all, or (for requests) answer it on the user's behalf.\n *\n * Both notifications (`notify`) and requests (`requestResponse`) are reported,\n * so an observer sees the complete, ordered stream the host handled. Use\n * `type` to tell them apart.\n */\nexport interface IoMessageObservation {\n  /**\n   * Whether this observation describes a plain notification (`notify`) or a\n   * request that asked for a response (`requestResponse`).\n   */\n  readonly type: 'notify' | 'request';\n\n  /**\n   * The message exactly as it was emitted to the host (before any listeners).\n   */\n  readonly emitted: IoMessage<unknown>;\n\n  /**\n   * The message after the host's listeners ran (text and/or level may differ).\n   */\n  readonly effective: IoMessage<unknown>;\n\n  /**\n   * Whether a listener prevented this message from being written, i.e. the user\n   * would not see it. Always `false` for requests (a request is reported once\n   * it has been resolved, regardless of how it was answered).\n   */\n  readonly dropped: boolean;\n}\n\n/**\n * An IoHost whose message handling can be observed.\n *\n * This is a CLI-internal contract used by tests to record the *effective*,\n * user-facing message stream (after listeners) without reaching into host\n * internals. It is intentionally separate from `IIoHost` so that the recorder\n * can work with any `IIoHost` and only enrich its output when the host also\n * implements this interface.\n */\nexport interface ObservableIoHost {\n  /**\n   * Register an observer that is invoked for every message the host handles —\n   * both notifications and requests — with the disposition the host computed\n   * for it (its effective form after listeners and whether it was dropped). For\n   * a request, the resolved answer is the effective message's `defaultResponse`.\n   * Returns a function that removes the observer again.\n   */\n  observeMessages(observer: (observation: IoMessageObservation) => void): () => void;\n}\n\n/**\n * A simple IO host for the CLI that writes messages to the console.\n */\nexport class CliIoHost implements IIoHost, ObservableIoHost {\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   * Returns the singleton instance if it exists\n   */\n  static get(): CliIoHost | undefined {\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 _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  // Message listeners in registration order. Each carries a matcher (by code,\n  // or a custom predicate). See `on`/`once`/`rewrite`/`respond`.\n  private readonly messageListeners: MessageListener[] = [];\n\n  // Observers of how messages are handled (see ObservableIoHost / observeMessages).\n  private readonly messageObservers = new Set<(observation: IoMessageObservation) => void>();\n\n  // True while replaying corked messages, so observers aren't notified twice.\n  private corkReplaying = false;\n\n  private readonly autoRespond: boolean;\n\n  /**\n   * The telemetry session object\n   *\n   * Will remain `undefined` if the user has disabled telemetry.\n   */\n  public telemetry?: TelemetrySession;\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    this.stackProgress = props.stackProgress ?? StackActivityProgress.BAR;\n    this.autoRespond = props.autoRespond ?? false;\n\n    // Stack-activity messages are handled by the activity printer rather than\n    // written to a stream. This is wired up as message listeners.\n    this.routeStackActivityToPrinter();\n  }\n\n  public async startTelemetry(args: any, context: Context, proxyAgent?: Agent) {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const config = require('../cli-type-registry.json');\n    const validCommands = Object.keys(config.commands);\n    const cmd = args._[0];\n    if (!validCommands.includes(cmd)) {\n      // the user typed in an invalid command - no need for telemetry since the invocation is going to fail\n      // imminently anyway.\n      await this.asIoHelper().defaults.trace(`Session instantiated with an invalid command (${cmd}). Not starting telemetry.`);\n      return;\n    }\n\n    let sinks: ITelemetrySink[] = [];\n    const telemetryFilePath = args['telemetry-file'];\n    if (telemetryFilePath) {\n      try {\n        sinks.push(new FileTelemetrySink({\n          ioHost: this,\n          logFilePath: telemetryFilePath,\n        }));\n        await this.asIoHelper().defaults.trace('File Telemetry connected');\n      } catch (e: any) {\n        await this.asIoHelper().defaults.trace(`File Telemetry instantiation failed: ${e.message}`);\n      }\n    }\n\n    const telemetryEndpoint = process.env.TELEMETRY_ENDPOINT ?? 'https://cdk-cli-telemetry.us-east-1.api.aws/metrics';\n    if (canCollectTelemetry(args, context) && telemetryEndpoint) {\n      try {\n        sinks.push(new EndpointTelemetrySink({\n          ioHost: this,\n          agent: proxyAgent,\n          endpoint: telemetryEndpoint,\n        }));\n        await this.asIoHelper().defaults.trace('Endpoint Telemetry connected');\n      } catch (e: any) {\n        await this.asIoHelper().defaults.trace(`Endpoint Telemetry instantiation failed: ${e.message}`);\n      }\n    } else {\n      await this.asIoHelper().defaults.trace('Endpoint Telemetry NOT connected');\n    }\n\n    if (sinks.length > 0) {\n      this.telemetry = new TelemetrySession({\n        ioHost: this,\n        client: new Funnel({ sinks }),\n        arguments: args,\n        context: context,\n      });\n    }\n\n    await this.telemetry?.begin();\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(): IoDefaultMessages {\n    return this.asIoHelper().defaults;\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        this.corkReplaying = true;\n        try {\n          for (const ioMessage of this.corkedLoggingBuffer) {\n            await this.notify(ioMessage);\n          }\n        } finally {\n          this.corkReplaying = false;\n        }\n        // remove all buffered messages in-place\n        this.corkedLoggingBuffer.splice(0);\n      }\n    }\n  }\n\n  /**\n   * Register a listener that is invoked for every message with the given code.\n   *\n   * The listener may return a `MessageListenerResult` to update the message\n   * text and/or prevent the default processing (writing it to a stream);\n   * returning nothing leaves the message untouched. The listener may be async\n   * (return a `Promise`); the host awaits it before processing the message\n   * further. Returns a function that removes the listener again.\n   *\n   * @example\n   * const dispose = ioHost.on(IO.CDK_TOOLKIT_I2901, async (msg) => {\n   *   myCount += msg.data.stacks.length;\n   *   await persist(myCount);\n   * });\n   *\n   * @example\n   * // Match with a custom predicate instead of a code, e.g. a maker's `.is`:\n   * const dispose = ioHost.on(IO.CDK_TOOLKIT_I7010.is, (msg) => ({ respond: true }));\n   */\n  public on<T>(\n    selector: IoMessageMaker<T> | IoRequestMaker<T, any> | ((msg: IoMessage<any>) => msg is IoMessage<T>),\n    listener: (msg: IoMessage<T>) => MessageListenerResultOrPromise,\n  ): () => void;\n  public on(\n    predicate: (msg: IoMessage<any>) => boolean,\n    listener: (msg: IoMessage<unknown>) => MessageListenerResultOrPromise,\n  ): () => void;\n  public on(selector: MessageSelector<any>, listener: MessageListenerFn): () => void {\n    return this.addMessageListener({ once: false, fn: listener, matches: messageMatcher(selector) });\n  }\n\n  /**\n   * Register an observer that is invoked for every message the host handles —\n   * both notifications and requests — with the disposition the host computed\n   * for it (its effective form after listeners and whether it was dropped). For\n   * a request, the resolved answer is the effective message's `defaultResponse`.\n   * Returns a function that removes the observer.\n   *\n   * @see ObservableIoHost\n   */\n  public observeMessages(observer: (observation: IoMessageObservation) => void): () => void {\n    this.messageObservers.add(observer);\n    return () => {\n      this.messageObservers.delete(observer);\n    };\n  }\n\n  /**\n   * Like `on`, but the listener is automatically removed after it has been\n   * invoked once.\n   */\n  public once<T>(\n    selector: IoMessageMaker<T> | IoRequestMaker<T, any> | ((msg: IoMessage<any>) => msg is IoMessage<T>),\n    listener: (msg: IoMessage<T>) => MessageListenerResultOrPromise,\n  ): () => void;\n  public once(\n    predicate: (msg: IoMessage<any>) => boolean,\n    listener: (msg: IoMessage<unknown>) => MessageListenerResultOrPromise,\n  ): () => void;\n  public once(selector: MessageSelector<any>, listener: MessageListenerFn): () => void {\n    return this.addMessageListener({ once: true, fn: listener, matches: messageMatcher(selector) });\n  }\n\n  /**\n   * Remove every message listener registered via `on`/`once`/`rewrite`/`respond`.\n   *\n   * The host's own internal listeners (such as stack-activity routing) are kept,\n   * so the host keeps working afterwards. Message observers registered via\n   * `observeMessages` are a separate mechanism and are not affected.\n   *\n   * This is mainly useful for tests that share the singleton host and need to\n   * reset listener state between cases (a leftover listener would otherwise\n   * leak into the next test).\n   */\n  public removeAllListeners(): void {\n    // Drop user listeners in place (preserving array identity for any\n    // outstanding dispose closures); keep the host's internal listeners.\n    for (let i = this.messageListeners.length - 1; i >= 0; i--) {\n      if (!this.messageListeners[i].internal) {\n        this.messageListeners.splice(i, 1);\n      }\n    }\n  }\n\n  /**\n   * Answer a request (by its code) on the user's behalf with a fixed value, so\n   * the host does not prompt. Syntactic sugar for an `on` listener returning\n   * `{ respond: value, preventDefault: suppressQuestion }`; for conditional\n   * answers or to also reword the question, use `on`/`once` directly. Returns a\n   * function that removes the responder again.\n   *\n   * @param suppressQuestion - whether to also suppress writing the question text.\n   *   Defaults to `true` (answer silently). Pass `false` to still surface the\n   *   question while answering it.\n   *\n   * @example\n   * // Under --force, auto-confirm the destroy prompt without prompting.\n   * const dispose = ioHost.respond(IO.CDK_TOOLKIT_I7010, true);\n   */\n  public respond<T, U>(code: IoRequestMaker<T, U>, value: U, suppressQuestion = true): () => void {\n    return this.addMessageListener({ once: false, fn: () => ({ respond: value, preventDefault: suppressQuestion }), matches: messageMatcher(code) });\n  }\n\n  /**\n   * Like `respond`, but the answer is given only once and then removed.\n   */\n  public respondOnce<T, U>(code: IoRequestMaker<T, U>, value: U, suppressQuestion = true): () => void {\n    return this.addMessageListener({ once: true, fn: () => ({ respond: value, preventDefault: suppressQuestion }), matches: messageMatcher(code) });\n  }\n\n  /**\n   * Register a formatter that replaces the printed text of messages with the\n   * given code. This lets a caller define _how_ a toolkit message is presented\n   * without the IoHost needing to know about it.\n   *\n   * Optionally pass a `level` to also override the message's level (which moves\n   * it between stdout/stderr and changes verbosity filtering). For the rarer\n   * case of overriding only the level, use `on`/`once` returning `{ level }`.\n   *\n   * Syntactic sugar for an `on` listener that returns `{ message, level? }`.\n   * Returns a function that removes the formatter again.\n   *\n   * @example\n   * const dispose = ioHost.rewrite(IO.CDK_TOOLKIT_I2901, (msg) =>\n   *   serializeStructure(msg.data.stacks, true));\n   */\n  public rewrite<T>(\n    code: IoMessageMaker<T> | IoRequestMaker<T, any>,\n    formatter: (msg: IoMessage<T>) => string,\n    level?: IoMessageLevel,\n  ): () => void {\n    return this.on(code, (msg) => ({ message: formatter(msg), ...(level !== undefined ? { level } : {}) }));\n  }\n\n  /**\n   * Like `rewrite`, but the formatter is automatically removed after it has\n   * been applied once.\n   */\n  public rewriteOnce<T>(\n    code: IoMessageMaker<T> | IoRequestMaker<T, any>,\n    formatter: (msg: IoMessage<T>) => string,\n    level?: IoMessageLevel,\n  ): () => void {\n    return this.once(code, (msg) => ({ message: formatter(msg), ...(level !== undefined ? { level } : {}) }));\n  }\n\n  /**\n   * Add a listener to the registry and return a function that removes it.\n   */\n  private addMessageListener(listener: MessageListener): () => void {\n    this.messageListeners.push(listener);\n\n    return () => {\n      const index = this.messageListeners.indexOf(listener);\n      if (index >= 0) {\n        this.messageListeners.splice(index, 1);\n      }\n    };\n  }\n\n  /**\n   * Run every registered listener that matches the message, in registration\n   * order. A listener matches by its code (maker) or its custom predicate.\n   *\n   * A listener may update the message text/level (passed on to subsequent\n   * listeners and the rest of the pipeline), prevent the default processing, or\n   * (for requests) answer it. `once` listeners are removed after they have run.\n   * Matching is decided against the message as emitted, so a rewrite by an\n   * earlier listener does not change which later listeners apply.\n   *\n   * Returns the (possibly updated) message, whether the default processing was\n   * prevented, and whether a listener answered the request (and with what).\n   */\n  private async applyMessageListeners<T extends IoMessage<unknown>>(msg: T): Promise<{\n    message: T;\n    preventDefault: boolean;\n    responded: boolean;\n  }> {\n    let current = msg;\n    let preventDefault = false;\n    let responded = false;\n    // Iterate over a copy so that `once` listeners can remove themselves safely.\n    for (const listener of [...this.messageListeners]) {\n      // Match against the emitted message; a listener receives the cumulatively\n      // transformed `current` message.\n      if (!listener.matches(msg)) {\n        continue;\n      }\n\n      // Listeners may be async; await each one before running the next so the\n      // cumulative effect on the message stays order-deterministic.\n      const result = await listener.fn(current);\n\n      if (listener.once) {\n        const index = this.messageListeners.indexOf(listener);\n        if (index >= 0) {\n          this.messageListeners.splice(index, 1);\n        }\n      }\n\n      if (result) {\n        if (result.message !== undefined) {\n          current = { ...current, message: result.message };\n        }\n        if (result.level !== undefined) {\n          current = { ...current, level: result.level };\n        }\n        if (result.preventDefault) {\n          preventDefault = true;\n        }\n        if ('respond' in result && 'defaultResponse' in msg) {\n          // Fold the answer into the request's default response and mark it\n          // answered, so we skip prompting and resolve with this value.\n          current = { ...current, defaultResponse: result.respond };\n          responded = true;\n        }\n      }\n    }\n\n    return { message: current, preventDefault, responded };\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    await this.maybeEmitTelemetry(msg);\n\n    // Run any registered listeners. A listener may update the message text\n    // and/or prevent the default processing (e.g. stack-activity messages are\n    // routed to the activity printer and not written to a stream).\n    const { message, preventDefault } = await this.applyMessageListeners(msg);\n\n    // Tell observers how this message was handled (its effective form and\n    // whether it was dropped). Skipped while replaying corked messages so each\n    // message is observed exactly once.\n    if (!this.corkReplaying) {\n      this.notifyObservers({ type: 'notify', emitted: msg, effective: message, dropped: preventDefault });\n    }\n\n    if (preventDefault) {\n      return;\n    }\n\n    this.writeMessage(message);\n  }\n\n  /**\n   * Notify every registered message observer of how a message or request was\n   * handled. A no-op when nothing is observing (i.e. outside of tests), so the\n   * surrounding hot paths pay nothing in production.\n   */\n  private notifyObservers(observation: IoMessageObservation): void {\n    if (this.messageObservers.size === 0) {\n      return;\n    }\n    for (const observer of this.messageObservers) {\n      observer(observation);\n    }\n  }\n\n  /**\n   * Write a (already listener-processed) message to its target stream, honoring\n   * the log level and corked-logging buffer. Shared by `notify` and the\n   * non-prompting `requestResponse` path.\n   */\n  private writeMessage(message: IoMessage<unknown>): void {\n    if (!isMessageRelevantForLevel(message, this.logLevel)) {\n      return;\n    }\n\n    if (this.corkedCounter > 0) {\n      this.corkedLoggingBuffer.push(message);\n      return;\n    }\n\n    const output = this.formatMessage(message);\n    const stream = this.selectStream(message);\n    stream?.write(output);\n  }\n\n  private async maybeEmitTelemetry(msg: IoMessage<unknown>) {\n    try {\n      const telemetryEvent = eventFromMessage(msg);\n      if (telemetryEvent) {\n        await this.telemetry?.emit(telemetryEvent);\n      }\n    } catch (e: any) {\n      await this.defaults.trace(`Emit Telemetry Failed ${e.message}`);\n    }\n  }\n\n  /**\n   * Route stack-activity messages to the activity printer (progress bar or\n   * event list) rather than writing them to a stream.\n   *\n   * Implemented as listeners that handle the message via the printer and\n   * prevent the default processing, so the rest of the pipeline does not also\n   * emit them. The printer is created lazily on the first stack-activity message.\n   */\n  private routeStackActivityToPrinter() {\n    const route = (msg: IoMessage<unknown>): MessageListenerResult => {\n      if (!this.activityPrinter) {\n        this.activityPrinter = this.makeActivityPrinter();\n      }\n      this.activityPrinter.notify(msg);\n      return { preventDefault: true }; // handled by the printer; don't also write to a stream\n    };\n\n    // A single internal listener (so it survives `removeAllListeners()` and the\n    // host keeps routing stack activity) matching any of the activity codes.\n    this.addMessageListener({\n      once: false,\n      internal: true,\n      fn: route,\n      matches: matchAny(IO.CDK_TOOLKIT_I5501, IO.CDK_TOOLKIT_I5502, IO.CDK_TOOLKIT_I5503),\n    });\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 (!(msg.code && approvalToolkitCodes.includes(msg.code))) {\n      return 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   * Registered listeners run first: a listener may reword the question (its text\n   * or level) or answer it outright via `respond` (e.g. `--force` auto-confirms\n   * a destroy). If no listener answers and the host cannot prompt, the suggested\n   * default response is used.\n   */\n  public async requestResponse<DataType, ResponseType>(msg: IoRequest<DataType, ResponseType>): Promise<ResponseType> {\n    // Listeners run exactly once here (so we don't go back through `notify`):\n    // they may answer the request, or reword/relevel the question shown below.\n    const { message, ...listenerResult } = await this.applyMessageListeners(msg);\n\n    const response = await this.resolveRequest(message, listenerResult);\n\n    // Tell observers how this request was handled: the effective (possibly reworded) question\n    // and the resolved response. When a listener answered the request with the question suppressed\n    // (`preventDefault`, e.g. `--force` auto-confirm), it is reported as `dropped` since the user never saw it.\n    this.notifyObservers({ type: 'request', emitted: msg, effective: message, dropped: listenerResult.preventDefault });\n\n    return response;\n  }\n\n  /**\n   * Resolve a request to its response: a listener's answer if one was given,\n   * otherwise the answer prompted from the user, otherwise the suggested\n   * default when the host cannot prompt.\n   *\n   * Kept separate from `requestResponse` so the response can be observed in a\n   * single place regardless of which of these paths produced it.\n   */\n  private async resolveRequest<DataType, ResponseType>(\n    msg: IoRequest<DataType, ResponseType>,\n    listenerResult: { preventDefault: boolean; responded: boolean },\n  ): Promise<ResponseType> {\n    // stop processing, a listener has taken care of it\n    if (listenerResult.preventDefault) {\n      return msg.defaultResponse;\n    }\n\n    // if a listener provided a response, we skip interaction\n    if (!isPromptableRequest(msg) || listenerResult.responded) {\n      this.writeMessage(msg);\n      return msg.defaultResponse;\n    }\n\n    const response = await this.withCorkedLogging(async (): Promise<string | number | boolean> => {\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        responseDescription?: string;\n      } = msg.data ?? {};\n\n      const motivation = data.motivation ?? 'User input is needed';\n      const concurrency = data.concurrency ?? 0;\n      const responseDescription = data.responseDescription;\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      // In --yes mode, respond for the user if we can\n      if (this.autoRespond) {\n        // respond with yes to all confirmations\n        if (isConfirmationPrompt(msg)) {\n          await this.writeMessage({\n            ...msg,\n            message: `${chalk.cyan(msg.message)} (auto-confirmed)`,\n          });\n          return true;\n        }\n\n        // respond with the default for all other messages\n        if (msg.defaultResponse) {\n          await this.writeMessage({\n            ...msg,\n            message: `${chalk.cyan(msg.message)} (auto-responded with default: ${util.format(msg.defaultResponse)})`,\n          });\n          return msg.defaultResponse;\n        }\n      }\n\n      // only talk to user if STDIN is a terminal (otherwise, fail)\n      if (!this.isTTY) {\n        throw new ToolkitError('TtyNotAttached', `${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('ConcurrencyConflict', `${motivation}, but concurrency is greater than 1 so we are unable to get a confirmation from the user`);\n      }\n\n      // Basic confirmation prompt\n      // We treat all requests with a boolean response as confirmation prompts\n      // The IoHost never aborts on a \"no\": it returns the answer and lets the\n      // calling action decide what to do (so abort handling is consistent\n      // across actions).\n      if (isConfirmationPrompt(msg)) {\n        return promptly.confirm(`${chalk.cyan(msg.message)} (y/n)`);\n      }\n\n      // Asking for a specific value\n      const prompt = extractPromptInfo(msg);\n      const desc = responseDescription ?? prompt.default;\n      const answer = await promptly.prompt(`${chalk.cyan(msg.message)}${desc ? ` (${desc})` : ''}`, {\n        default: prompt.default,\n        trim: true,\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 * Convert a `MessageSelector` into a predicate that decides whether a listener\n * applies to a message. A maker matches messages carrying its `code`; a\n * predicate (e.g. a maker's `.is`, or any `(msg) => boolean`) is used as-is.\n */\nfunction messageMatcher(selector: MessageSelector<any>): (msg: IoMessage<unknown>) => boolean {\n  if (typeof selector === 'function') {\n    return selector;\n  }\n  const { code } = selector;\n  return (msg) => msg.code === code;\n}\n\n/**\n * Combine several selectors into a single predicate that matches a message when\n * *any* of them matches. Each selector may be a maker (matched by its `code`)\n * or a predicate.\n *\n * Useful for one listener that spans multiple codes, e.g.\n * `ioHost.on(matchAny(IO.CDK_TOOLKIT_I5501, IO.CDK_TOOLKIT_I5502), listener)`.\n */\nexport function matchAny(...selectors: MessageSelector<any>[]): (msg: IoMessage<unknown>) => boolean {\n  const matchers = selectors.map(messageMatcher);\n  return (msg) => matchers.some((matches) => matches(msg));\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  defaultDesc: string;\n  convertAnswer: (input: string) => string | number;\n} {\n  const isNumber = (typeof msg.defaultResponse === 'number');\n  const defaultResponse = util.format(msg.defaultResponse);\n  return {\n    default: defaultResponse,\n    defaultDesc: 'defaultDescription' in msg && msg.defaultDescription ? util.format(msg.defaultDescription) : 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.reset,\n  info: chalk.reset,\n  debug: chalk.gray,\n  trace: chalk.gray,\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>): msg is IoMessage<void> {\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\nfunction eventFromMessage(msg: IoMessage<unknown>): TelemetryEvent | undefined {\n  if (CLI_PRIVATE_IO.CDK_CLI_I1001.is(msg)) {\n    return eventResult('SYNTH', msg);\n  }\n  if (CLI_PRIVATE_IO.CDK_CLI_I2001.is(msg)) {\n    return eventResult('INVOKE', msg);\n  }\n  if (CLI_PRIVATE_IO.CDK_CLI_I3001.is(msg)) {\n    return eventResult('DEPLOY', msg);\n  }\n  if (CLI_PRIVATE_IO.CDK_CLI_I3003.is(msg)) {\n    return eventResult('ASSET', msg);\n  }\n  // Hotswap lives in the cdk-toolkit so it cannot be a CDK_CLI error code.\n  // Instead we reuse the existing Hotswap span.\n  if (IO.CDK_TOOLKIT_I5410.is(msg)) {\n    // Create a telemetry-compatible result\n    return hotswapToEventResult(msg.data);\n  }\n  return undefined;\n\n  function eventResult(eventType: TelemetryEvent['eventType'], m: IoMessage<EventResult>): TelemetryEvent {\n    return {\n      eventType,\n      duration: m.data.duration,\n      error: m.data.error,\n      counters: m.data.counters,\n    };\n  }\n}\n\nfunction hotswapToEventResult(result: HotswapResult): TelemetryEvent {\n  const nonHotswappableResources: Record<string, number> = {};\n  for (const { subject } of result.nonHotswappableChanges) {\n    if ('resourceType' in subject) {\n      const keys = 'rejectedProperties' in subject && subject.rejectedProperties\n        ? subject.rejectedProperties.map(p => `hotswapFallback:${subject.resourceType}#${p}`)\n        : [`hotswapFallback:${subject.resourceType}`];\n      for (const key of keys) {\n        nonHotswappableResources[key] = (nonHotswappableResources[key] ?? 0) + 1;\n      }\n    }\n  }\n\n  return {\n    eventType: 'HOTSWAP' as const,\n    duration: result.duration,\n    ...(result.error ? {\n      error: {\n        name: cdkCliErrorName(result.error),\n      },\n    } : {}),\n    counters: {\n      hotswapped: result.hotswapped ? 1 : 0,\n      hotswapFallback: result.hotswapFallback ? 1 : 0,\n      hotswappableChanges: result.hotswappableChanges.length,\n      nonHotswappableChanges: result.nonHotswappableChanges.length,\n      ...nonHotswappableResources,\n    },\n  };\n}\n"]}