"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 __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
    if (value !== null && value !== void 0) {
        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
        var dispose, inner;
        if (async) {
            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
            dispose = value[Symbol.asyncDispose];
        }
        if (dispose === void 0) {
            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
            dispose = value[Symbol.dispose];
            if (async) inner = dispose;
        }
        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
        env.stack.push({ value: value, dispose: dispose, async: async });
    }
    else if (async) {
        env.stack.push({ async: true });
    }
    return value;
};
var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
    return function (env) {
        function fail(e) {
            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
            env.hasError = true;
        }
        var r, s = 0;
        function next() {
            while (r = env.stack.pop()) {
                try {
                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
                    if (r.dispose) {
                        var result = r.dispose.call(r.value);
                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
                    }
                    else s |= 1;
                }
                catch (e) {
                    fail(e);
                }
            }
            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
            if (env.hasError) throw env.error;
        }
        return next();
    };
})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
    var e = new Error(message);
    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
});
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.CliIoHost = void 0;
exports.matchAny = matchAny;
exports.suppressMessages = suppressMessages;
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_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");
const error_1 = require("../telemetry/error");
const messages_1 = require("../telemetry/messages");
const session_1 = require("../telemetry/session");
const endpoint_sink_1 = require("../telemetry/sink/endpoint-sink");
const file_sink_1 = require("../telemetry/sink/file-sink");
const funnel_1 = require("../telemetry/sink/funnel");
const ci_1 = require("../util/ci");
/**
 * Make a plain remover function usable as a `Disposable` (see `DisposeListener`).
 */
function disposeListener(dispose) {
    return Object.assign(dispose, { [Symbol.dispose]: dispose });
}
/**
 * A simple IO host for the CLI that writes messages to the console.
 */
class CliIoHost {
    /**
     * Returns the singleton instance
     */
    static instance(props = {}, forceNew = false) {
        if (forceNew || !CliIoHost._instance) {
            CliIoHost._instance = new CliIoHost(props);
        }
        return CliIoHost._instance;
    }
    /**
     * Returns the singleton instance if it exists
     */
    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 = {}) {
        this.currentAction = props.currentAction ?? 'none';
        this.isTTY = props.isTTY ?? process.stdout.isTTY ?? false;
        this.logLevel = props.logLevel ?? 'info';
        this.isCI = props.isCI ?? (0, ci_1.isCI)();
        this.requireDeployApproval = props.requireDeployApproval ?? cloud_assembly_schema_1.RequireApproval.BROADENING;
        this.stackProgress = props.stackProgress ?? deploy_1.StackActivityProgress.BAR;
        this.autoRespond = props.autoRespond ?? false;
        // Stack-activity messages are handled by the activity printer rather than
        // written to a stream. This is wired up as message listeners.
        this.routeStackActivityToPrinter();
    }
    async startTelemetry(args, context, proxyAgent) {
        // eslint-disable-next-line @typescript-eslint/no-require-imports
        const config = require('../cli-type-registry.json');
        const validCommands = Object.keys(config.commands);
        const cmd = args._[0];
        if (!validCommands.includes(cmd)) {
            // the user typed in an invalid command - no need for telemetry since the invocation is going to fail
            // imminently anyway.
            await this.asIoHelper().defaults.trace(`Session instantiated with an invalid command (${cmd}). Not starting telemetry.`);
            return;
        }
        let sinks = [];
        const telemetryFilePath = args['telemetry-file'];
        if (telemetryFilePath) {
            try {
                sinks.push(new file_sink_1.FileTelemetrySink({
                    ioHost: this,
                    logFilePath: telemetryFilePath,
                }));
                await this.asIoHelper().defaults.trace('File Telemetry connected');
            }
            catch (e) {
                await this.asIoHelper().defaults.trace(`File Telemetry instantiation failed: ${e.message}`);
            }
        }
        const telemetryEndpoint = process.env.TELEMETRY_ENDPOINT ?? 'https://cdk-cli-telemetry.us-east-1.api.aws/metrics';
        if ((0, collect_telemetry_1.canCollectTelemetry)(args, context) && telemetryEndpoint) {
            try {
                sinks.push(new endpoint_sink_1.EndpointTelemetrySink({
                    ioHost: this,
                    agent: proxyAgent,
                    endpoint: telemetryEndpoint,
                }));
                await this.asIoHelper().defaults.trace('Endpoint Telemetry connected');
            }
            catch (e) {
                await this.asIoHelper().defaults.trace(`Endpoint Telemetry instantiation failed: ${e.message}`);
            }
        }
        else {
            await this.asIoHelper().defaults.trace('Endpoint Telemetry NOT connected');
        }
        if (sinks.length > 0) {
            this.telemetry = new session_1.TelemetrySession({
                ioHost: this,
                client: new funnel_1.Funnel({ sinks }),
                arguments: args,
                context: context,
            });
        }
        await this.telemetry?.begin();
    }
    /**
     * Update the stackProgress preference.
     */
    set stackProgress(type) {
        this._progress = type;
    }
    /**
     * Gets the stackProgress value.
     *
     * This takes into account other state of the ioHost,
     * like if isTTY and isCI.
     */
    get stackProgress() {
        // We can always use EVENTS and ERRORS_ONLY
        if (this._progress === deploy_1.StackActivityProgress.EVENTS || this._progress === deploy_1.StackActivityProgress.ERRORS_ONLY) {
            return this._progress;
        }
        // if a debug message (and thus any more verbose messages) are relevant to the current log level, we have verbose logging
        const verboseLogging = (0, api_private_1.isMessageRelevantForLevel)({ level: 'debug' }, this.logLevel);
        if (verboseLogging) {
            return deploy_1.StackActivityProgress.EVENTS;
        }
        // On Windows we cannot use fancy output
        const isWindows = process.platform === 'win32';
        if (isWindows) {
            return deploy_1.StackActivityProgress.EVENTS;
        }
        // On some CI systems (such as CircleCI) output still reports as a TTY so we also
        // need an individual check for whether we're running on CI.
        // see: https://discuss.circleci.com/t/circleci-terminal-is-a-tty-but-term-is-not-set/9965
        const fancyOutputAvailable = this.isTTY && !this.isCI;
        if (!fancyOutputAvailable) {
            return deploy_1.StackActivityProgress.EVENTS;
        }
        // Use the user preference
        return this._progress;
    }
    get defaults() {
        return this.asIoHelper().defaults;
    }
    asIoHelper() {
        return (0, api_private_1.asIoHelper)(this, this.currentAction);
    }
    /**
     * Executes a block of code with corked logging. All log messages during execution
     * are buffered and only written when all nested cork blocks complete (when CORK_COUNTER reaches 0).
     * The corking is bound to the specific instance of the CliIoHost.
     *
     * @param block - Async function to execute with corked logging
     * @returns Promise that resolves with the block's return value
     */
    async withCorkedLogging(block) {
        this.corkedCounter++;
        try {
            return await block();
        }
        finally {
            this.corkedCounter--;
            if (this.corkedCounter === 0) {
                // Process each buffered message through notify
                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);
            }
        }
    }
    /**
     * 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.
     *
     * @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
     * // Under --force, auto-confirm the destroy prompt without prompting.
     * const dispose = ioHost.respond(IO.CDK_TOOLKIT_I7010, true);
     */
    respond(code, value, suppressQuestion = true) {
        return this.addMessageListener({ once: false, fn: () => ({ respond: value, preventDefault: suppressQuestion }), matches: messageMatcher(code) });
    }
    /**
     * Like `respond`, but the answer is given only once and then removed.
     */
    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.
     *
     * 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, 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, level) {
        return this.once(code, (msg) => ({ message: formatter(msg), ...(level !== undefined ? { level } : {}) }));
    }
    /**
     * Add a listener to the registry and return a remover for it (callable and
     * `using`-compatible, see `DisposeListener`).
     */
    addMessageListener(listener) {
        this.messageListeners.push(listener);
        return disposeListener(() => {
            const index = this.messageListeners.indexOf(listener);
            if (index >= 0) {
                this.messageListeners.splice(index, 1);
            }
        });
    }
    /**
     * 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, level, and/or action (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
     * transformation by an earlier listener does not change which later listeners
     * apply.
     *
     * Returns the (possibly updated) message, whether the default processing was
     * prevented, and whether a listener answered the request (and with what).
     */
    async applyMessageListeners(msg) {
        let current = msg;
        let preventDefault = false;
        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.level !== undefined) {
                    current = { ...current, level: result.level };
                }
                if (result.action !== undefined) {
                    current = { ...current, action: result.action };
                }
                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, responded };
    }
    /**
     * Notifies the host of a message.
     * The caller waits until the notification completes.
     */
    async notify(msg) {
        await this.maybeEmitTelemetry(msg);
        // Run any registered listeners. A listener may update the message text,
        // level, and/or action or prevent the default processing (e.g.
        // stack-activity messages are routed to the activity printer and not
        // written to a stream).
        //
        // Skip this while replaying corked messages: the listeners already ran on
        // the first pass, and running them again would re-transform an
        // already-transformed message.
        const { message, preventDefault } = this.corkReplaying
            ? { message: msg, preventDefault: false }
            : 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;
        }
        if (this.corkedCounter > 0) {
            this.corkedLoggingBuffer.push(message);
            return;
        }
        const output = this.formatMessage(message);
        const stream = this.selectStream(message);
        stream?.write(output);
    }
    async maybeEmitTelemetry(msg) {
        try {
            const telemetryEvent = eventFromMessage(msg);
            if (telemetryEvent) {
                await this.telemetry?.emit(telemetryEvent);
            }
        }
        catch (e) {
            await this.defaults.trace(`Emit Telemetry Failed ${e.message}`);
        }
    }
    /**
     * Route stack-activity messages to the activity printer (progress bar or
     * event list) rather than writing them to a stream.
     *
     * Implemented as listeners that handle the message via the printer and
     * prevent the default processing, so the rest of the pipeline does not also
     * emit them. The printer is created lazily on the first stack-activity message.
     */
    routeStackActivityToPrinter() {
        const route = (msg) => {
            if (!this.activityPrinter) {
                this.activityPrinter = this.makeActivityPrinter();
            }
            this.activityPrinter.notify(msg);
            return { preventDefault: true }; // handled by the printer; don't also write to a stream
        };
        // 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
     * they require approval
     */
    skipApprovalStep(msg) {
        const approvalToolkitCodes = ['CDK_TOOLKIT_I5060'];
        if (!(msg.code && approvalToolkitCodes.includes(msg.code))) {
            return false;
        }
        switch (this.requireDeployApproval) {
            // Never require approval
            case cloud_assembly_schema_1.RequireApproval.NEVER:
                return true;
            // Always require approval
            case cloud_assembly_schema_1.RequireApproval.ANYCHANGE:
                return false;
            // Require approval if changes include broadening permissions
            case cloud_assembly_schema_1.RequireApproval.BROADENING:
                return ['none', 'non-broadening'].includes(msg.data?.permissionChangeType);
        }
    }
    /**
     * Determines the output stream, based on message and configuration.
     */
    selectStream(msg) {
        if (isNoticesMessage(msg)) {
            return targetStreamObject(this.noticesDestination);
        }
        return this.selectStreamFromLevel(msg.level);
    }
    /**
     * Determines the output stream, based on message level and configuration.
     */
    selectStreamFromLevel(level) {
        // The stream selection policy for the CLI is the following:
        //
        //   (1) Messages of level `result` always go to `stdout`
        //   (2) Messages of level `error` always go to `stderr`.
        //   (3a) All remaining messages go to `stderr`.
        //   (3b) If we are in CI mode, all remaining messages go to `stdout`.
        //
        switch (level) {
            case 'error':
                return process.stderr;
            case 'result':
                return process.stdout;
            default:
                return this.isCI ? process.stdout : process.stderr;
        }
    }
    /**
     * Notifies the host of a message that requires a response.
     *
     * 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) {
        // Listeners run exactly once here (so we don't go back through `notify`):
        // they may answer the request, or reword/relevel/retag 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 () => {
            // prepare prompt data
            // @todo this format is not defined anywhere, probably should be
            const data = msg.data ?? {};
            const motivation = data.motivation ?? 'User input is needed';
            const concurrency = data.concurrency ?? 0;
            const responseDescription = data.responseDescription;
            // Special approval prompt
            // Determine if the message needs approval. If it does, continue (it is a basic confirmation prompt)
            // If it does not, return success (true). We only check messages with codes that we are aware
            // are requires approval codes.
            if (this.skipApprovalStep(msg)) {
                return true;
            }
            // In --yes mode, respond for the user if we can
            if (this.autoRespond) {
                // respond with yes to all confirmations
                if (isConfirmationPrompt(msg)) {
                    await this.writeMessage({
                        ...msg,
                        message: `${chalk_1.default.cyan(msg.message)} (auto-confirmed)`,
                    });
                    return true;
                }
                // respond with the default for all other messages
                if (msg.defaultResponse !== undefined) {
                    await this.writeMessage({
                        ...msg,
                        message: `${chalk_1.default.cyan(msg.message)} (auto-responded with default: ${util.format(msg.defaultResponse)})`,
                    });
                    return msg.defaultResponse;
                }
            }
            // only talk to user if STDIN is a terminal (otherwise, fail)
            if (!this.isTTY) {
                throw new toolkit_lib_1.ToolkitError('TtyNotAttached', `${motivation}, but terminal (TTY) is not attached so we are unable to get a confirmation from the user`);
            }
            // only talk to user if concurrency is 1 (otherwise, fail)
            if (concurrency > 1) {
                throw new toolkit_lib_1.ToolkitError('ConcurrencyConflict', `${motivation}, but concurrency is greater than 1 so we are unable to get a confirmation from the user`);
            }
            // 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)) {
                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_1.default.cyan(msg.message)}${desc ? ` (${desc})` : ''}`, {
                default: prompt.default,
                trim: true,
            });
            return prompt.convertAnswer(answer);
        });
        // We need to cast this because it is impossible to narrow the generic type
        // isPromptableRequest ensures that the response type is one we can prompt for
        // the remaining code ensure we are indeed returning the correct type
        return response;
    }
    /**
     * Formats a message for console output with optional color support
     */
    formatMessage(msg) {
        // apply provided style or a default style if we're in TTY mode
        let message_text;
        if (msg.code === 'CDK_TOOLKIT_E9600') {
            // Message is pre-styled
            message_text = msg.message;
        }
        else {
            message_text = this.isTTY
                ? styleMap[msg.level](msg.message)
                : msg.message;
        }
        // prepend timestamp if IoMessageLevel is DEBUG or TRACE. Postpend a newline.
        return ((msg.level === 'debug' || msg.level === 'trace')
            ? `[${this.formatTime(msg.time)}] ${message_text}`
            : message_text) + '\n';
    }
    /**
     * Formats date to HH:MM:SS
     */
    formatTime(d) {
        const pad = (n) => n.toString().padStart(2, '0');
        return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
    }
    /**
     * Get an instance of the ActivityPrinter
     */
    makeActivityPrinter() {
        const props = {
            stream: this.selectStreamFromLevel('info'),
        };
        switch (this.stackProgress) {
            case deploy_1.StackActivityProgress.EVENTS:
                return new api_private_1.HistoryActivityPrinter(props);
            case deploy_1.StackActivityProgress.BAR:
                return new api_private_1.CurrentActivityPrinter(props);
            case deploy_1.StackActivityProgress.ERRORS_ONLY:
                return new api_private_1.ErrorsOnlyActivityPrinter(props);
        }
    }
}
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));
}
/**
 * Method decorator that suppresses the given IoHost messages for the duration
 * of the decorated method.
 *
 * Before the method runs, a single `preventDefault` listener covering all
 * given selectors is registered on the instance's `ioHost`; when the method
 * settles (returns or throws), exactly that listener is removed again. This
 * replaces the manual pattern of registering drop-listeners at the top of a
 * method and cleaning them up in a `finally`, and — unlike a blanket
 * `removeAllListeners()` — it does not disturb listeners registered elsewhere.
 *
 * The decorated method must be async and live on a class whose instances carry
 * the `CliIoHost` on an `ioHost` property (like `CdkToolkit`).
 *
 * @example
 * class CdkToolkit {
 *   \@suppressMessages(IO.CDK_TOOLKIT_I1001, IO.CDK_TOOLKIT_I1000)
 *   public async metadata(stackName: string, json: boolean) {
 *     // I1001/I1000 are dropped while this runs
 *   }
 * }
 */
function suppressMessages(...selectors) {
    return function (_target, _propertyKey, descriptor) {
        const original = descriptor.value;
        if (!original) {
            throw new toolkit_lib_1.ToolkitError('InvalidDecoratorTarget', 'suppressMessages can only decorate methods');
        }
        descriptor.value = async function (...args) {
            const env_1 = { stack: [], error: void 0, hasError: false };
            try {
                const _suppress = __addDisposableResource(env_1, this.ioHost.on(matchAny(...selectors), () => ({ preventDefault: true })), false);
                // `return await` (not a bare `return`) so the listener is only disposed
                // after the method has actually settled.
                return await original.apply(this, args);
            }
            catch (e_1) {
                env_1.error = e_1;
                env_1.hasError = true;
            }
            finally {
                __disposeResources(env_1);
            }
        };
    };
}
/**
 * This IoHost implementation considers a request promptable, if:
 * - it's a yes/no confirmation
 * - asking for a string or number value
 */
function isPromptableRequest(msg) {
    return isConfirmationPrompt(msg)
        || typeof msg.defaultResponse === 'string'
        || typeof msg.defaultResponse === 'number';
}
/**
 * Check if the request is a confirmation prompt
 * We treat all requests with a boolean response as confirmation prompts
 */
function isConfirmationPrompt(msg) {
    return typeof msg.defaultResponse === 'boolean';
}
/**
 * Helper to extract information for promptly from the request
 */
function extractPromptInfo(msg) {
    const isNumber = (typeof msg.defaultResponse === 'number');
    const defaultResponse = util.format(msg.defaultResponse);
    return {
        default: defaultResponse,
        defaultDesc: 'defaultDescription' in msg && msg.defaultDescription ? util.format(msg.defaultDescription) : defaultResponse,
        convertAnswer: isNumber ? (v) => Number(v) : (v) => String(v),
    };
}
const styleMap = {
    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) {
        case 'stderr':
            return process.stderr;
        case 'stdout':
            return process.stdout;
        case 'drop':
            return undefined;
    }
}
function isNoticesMessage(msg) {
    return api_private_1.IO.CDK_TOOLKIT_I0100.is(msg) || api_private_1.IO.CDK_TOOLKIT_W0101.is(msg) || api_private_1.IO.CDK_TOOLKIT_E0101.is(msg) || api_private_1.IO.CDK_TOOLKIT_I0101.is(msg);
}
function eventFromMessage(msg) {
    if (messages_1.CLI_PRIVATE_IO.CDK_CLI_I1001.is(msg)) {
        return eventResult('SYNTH', msg);
    }
    if (messages_1.CLI_PRIVATE_IO.CDK_CLI_I2001.is(msg)) {
        return eventResult('INVOKE', msg);
    }
    if (messages_1.CLI_PRIVATE_IO.CDK_CLI_I3001.is(msg)) {
        return eventResult('DEPLOY', msg);
    }
    if (messages_1.CLI_PRIVATE_IO.CDK_CLI_I3003.is(msg)) {
        return eventResult('ASSET', msg);
    }
    // Hotswap lives in the cdk-toolkit so it cannot be a CDK_CLI error code.
    // Instead we reuse the existing Hotswap span.
    if (api_private_1.IO.CDK_TOOLKIT_I5410.is(msg)) {
        // Create a telemetry-compatible result
        return hotswapToEventResult(msg.data);
    }
    return undefined;
    function eventResult(eventType, m) {
        return {
            eventType,
            duration: m.data.duration,
            error: m.data.error,
            counters: m.data.counters,
        };
    }
}
function hotswapToEventResult(result) {
    const nonHotswappableResources = {};
    for (const { subject } of result.nonHotswappableChanges) {
        if ('resourceType' in subject) {
            const keys = 'rejectedProperties' in subject && subject.rejectedProperties
                ? subject.rejectedProperties.map(p => `hotswapFallback:${subject.resourceType}#${p}`)
                : [`hotswapFallback:${subject.resourceType}`];
            for (const key of keys) {
                nonHotswappableResources[key] = (nonHotswappableResources[key] ?? 0) + 1;
            }
        }
    }
    return {
        eventType: 'HOTSWAP',
        duration: result.duration,
        ...(result.error ? {
            error: {
                name: (0, error_1.cdkCliErrorName)(result.error),
            },
        } : {}),
        counters: {
            hotswapped: result.hotswapped ? 1 : 0,
            hotswapFallback: result.hotswapFallback ? 1 : 0,
            hotswappableChanges: result.hotswappableChanges.length,
            nonHotswappableChanges: result.nonHotswappableChanges.length,
            ...nonHotswappableResources,
        },
    };
}
//# 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, ErrorsOnlyActivityPrinter } 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  | 'lsp'\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_, _level_, and/or _action_; it cannot\n * change other fields (such as its `code`), which keeps the code-keyed listener\n * 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   * Override the action associated with this message.\n   *\n   * The override affects subsequent listeners and presentation/observation of\n   * the effective message. Matching and telemetry continue to use the action\n   * on the originally emitted message.\n   *\n   * @default - the message action is left unchanged\n   */\n  readonly action?: ToolkitAction;\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, level, and/or action or prevent the default processing. It may\n * 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 * Removes a previously registered message listener.\n *\n * Callable directly (`dispose()`), and also a `Disposable`, so it can be bound\n * to the enclosing scope with a `using` declaration — the listener is then\n * removed when the scope exits, even on an early return or a throw:\n *\n * ```ts\n * using _fmt = ioHost.rewrite(IO.CDK_TOOLKIT_I2901, format);\n * ```\n *\n * `using x = cond ? ioHost.on(...) : undefined` is also valid: disposal is\n * simply skipped for `undefined`, which makes conditional listeners cheap.\n */\nexport interface DisposeListener {\n  (): void;\n  [Symbol.dispose](): void;\n}\n\n/**\n * Make a plain remover function usable as a `Disposable` (see `DisposeListener`).\n */\nfunction disposeListener(dispose: () => void): DisposeListener {\n  return Object.assign(dispose, { [Symbol.dispose]: dispose });\n}\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, level, and/or action 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 and ERRORS_ONLY\n    if (this._progress === StackActivityProgress.EVENTS || this._progress === StackActivityProgress.ERRORS_ONLY) {\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, level, and/or action or prevent the default processing (writing it to\n   * a stream); returning nothing leaves the message untouched. The listener may\n   * be async (return a `Promise`); the host awaits it before processing the\n   * message 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  ): DisposeListener;\n  public on(\n    predicate: (msg: IoMessage<any>) => boolean,\n    listener: (msg: IoMessage<unknown>) => MessageListenerResultOrPromise,\n  ): DisposeListener;\n  public on(selector: MessageSelector<any>, listener: MessageListenerFn): DisposeListener {\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  ): DisposeListener;\n  public once(\n    predicate: (msg: IoMessage<any>) => boolean,\n    listener: (msg: IoMessage<unknown>) => MessageListenerResultOrPromise,\n  ): DisposeListener;\n  public once(selector: MessageSelector<any>, listener: MessageListenerFn): DisposeListener {\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): DisposeListener {\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): DisposeListener {\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  ): DisposeListener {\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  ): DisposeListener {\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 remover for it (callable and\n   * `using`-compatible, see `DisposeListener`).\n   */\n  private addMessageListener(listener: MessageListener): DisposeListener {\n    this.messageListeners.push(listener);\n\n    return disposeListener(() => {\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, and/or action (passed on to\n   * subsequent listeners and the rest of the pipeline), prevent the default\n   * processing, or (for requests) answer it. `once` listeners are removed after\n   * they have run. Matching is decided against the message as emitted, so a\n   * transformation by an earlier listener does not change which later listeners\n   * 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.action !== undefined) {\n          current = { ...current, action: result.action };\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    // level, and/or action or prevent the default processing (e.g.\n    // stack-activity messages are routed to the activity printer and not\n    // written to a stream).\n    //\n    // Skip this while replaying corked messages: the listeners already ran on\n    // the first pass, and running them again would re-transform an\n    // already-transformed message.\n    const { message, preventDefault } = this.corkReplaying\n      ? { message: msg, preventDefault: false }\n      : 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/retag 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 !== undefined) {\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;\n    if (msg.code === 'CDK_TOOLKIT_E9600') {\n      // Message is pre-styled\n      message_text = msg.message;\n    } else {\n      message_text = this.isTTY\n        ? styleMap[msg.level](msg.message)\n        : msg.message;\n    }\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      case StackActivityProgress.ERRORS_ONLY:\n        return new ErrorsOnlyActivityPrinter(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 * Method decorator that suppresses the given IoHost messages for the duration\n * of the decorated method.\n *\n * Before the method runs, a single `preventDefault` listener covering all\n * given selectors is registered on the instance's `ioHost`; when the method\n * settles (returns or throws), exactly that listener is removed again. This\n * replaces the manual pattern of registering drop-listeners at the top of a\n * method and cleaning them up in a `finally`, and — unlike a blanket\n * `removeAllListeners()` — it does not disturb listeners registered elsewhere.\n *\n * The decorated method must be async and live on a class whose instances carry\n * the `CliIoHost` on an `ioHost` property (like `CdkToolkit`).\n *\n * @example\n * class CdkToolkit {\n *   \\@suppressMessages(IO.CDK_TOOLKIT_I1001, IO.CDK_TOOLKIT_I1000)\n *   public async metadata(stackName: string, json: boolean) {\n *     // I1001/I1000 are dropped while this runs\n *   }\n * }\n */\nexport function suppressMessages(...selectors: MessageSelector<any>[]) {\n  return function <A extends any[], R>(\n    _target: object,\n    _propertyKey: string | symbol,\n    descriptor: TypedPropertyDescriptor<(...args: A) => Promise<R>>,\n  ): void {\n    const original = descriptor.value;\n    if (!original) {\n      throw new ToolkitError('InvalidDecoratorTarget', 'suppressMessages can only decorate methods');\n    }\n    descriptor.value = async function (this: { readonly ioHost: CliIoHost }, ...args: A): Promise<R> {\n      using _suppress = this.ioHost.on(matchAny(...selectors), () => ({ preventDefault: true }));\n      // `return await` (not a bare `return`) so the listener is only disposed\n      // after the method has actually settled.\n      return await original.apply(this, args);\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"]}