aws-cdk 2.177.0 → 2.178.0

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

@@ -2,13 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CliIoHost = exports.levelPriority = void 0;
 exports.isCI = isCI;
+const util = require("node:util");
 const chalk = require("chalk");
+const promptly = require("promptly");
+const error_1 = require("./error");
 exports.levelPriority = {
     error: 0,
-    warn: 1,
-    info: 2,
-    debug: 3,
-    trace: 4,
+    result: 1,
+    warn: 2,
+    info: 3,
+    debug: 4,
+    trace: 5,
 };
 /**
  * A simple IO host for the CLI that writes messages to the console.
@@ -24,6 +28,9 @@ class CliIoHost {
         return CliIoHost._instance;
     }
     constructor(props = {}) {
+        // Corked Logging
+        this.corkedCounter = 0;
+        this.corkedLoggingBuffer = [];
         this._currentAction = props.currentAction ?? 'none';
         this._isTTY = props.isTTY ?? process.stdout.isTTY ?? false;
         this._logLevel = props.logLevel ?? 'info';
@@ -91,6 +98,31 @@ class CliIoHost {
     set logLevel(level) {
         this._logLevel = level;
     }
+    /**
+     * Executes a block of code with corked logging. All log messages during execution
+     * are buffered and only written when all nested cork blocks complete (when CORK_COUNTER reaches 0).
+     * The corking is bound to the specific instance of the CliIoHost.
+     *
+     * @param block - Async function to execute with corked logging
+     * @returns Promise that resolves with the block's return value
+     */
+    async withCorkedLogging(block) {
+        this.corkedCounter++;
+        try {
+            return await block();
+        }
+        finally {
+            this.corkedCounter--;
+            if (this.corkedCounter === 0) {
+                // Process each buffered message through notify
+                for (const ioMessage of this.corkedLoggingBuffer) {
+                    await this.notify(ioMessage);
+                }
+                // remove all buffered messages in-place
+                this.corkedLoggingBuffer.splice(0);
+            }
+        }
+    }
     /**
      * Notifies the host of a message.
      * The caller waits until the notification completes.
@@ -102,34 +134,33 @@ class CliIoHost {
         if (exports.levelPriority[msg.level] > exports.levelPriority[this.logLevel]) {
             return;
         }
+        if (this.corkedCounter > 0) {
+            this.corkedLoggingBuffer.push(msg);
+            return;
+        }
         const output = this.formatMessage(msg);
-        const stream = this.stream(msg.level, msg.forceStdout ?? false);
-        return new Promise((resolve, reject) => {
-            stream.write(output, (err) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
+        const stream = this.selectStream(msg.level);
+        stream.write(output);
     }
     /**
-     * Determines which output stream to use based on log level and configuration.
+     * Determines the output stream, based on message level and configuration.
      */
-    stream(level, forceStdout) {
-        // For legacy purposes all log streams are written to stderr by default, unless
-        // specified otherwise, by passing `forceStdout`, which is used by the `data()` logging function, or
-        // if the CDK is running in a CI environment. This is because some CI environments will immediately
-        // fail if stderr is written to. In these cases, we detect if we are in a CI environment and
-        // write all messages to stdout instead.
-        if (forceStdout) {
-            return process.stdout;
+    selectStream(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;
         }
-        if (level == 'error')
-            return process.stderr;
-        return CliIoHost.instance().isCI ? process.stdout : process.stderr;
     }
     /**
      * Notifies the host of a message that requires a response.
@@ -138,11 +169,49 @@ class CliIoHost {
      * default response from the input message will be used.
      */
     async requestResponse(msg) {
+        // First call out to a registered instance if we have one
         if (this._internalIoHost) {
             return this._internalIoHost.requestResponse(msg);
         }
-        await this.notify(msg);
-        return msg.defaultResponse;
+        // If the request cannot be prompted for by the CliIoHost, we just accept the default
+        if (!isPromptableRequest(msg)) {
+            await this.notify(msg);
+            return msg.defaultResponse;
+        }
+        const response = await this.withCorkedLogging(async () => {
+            // prepare prompt data
+            // @todo this format is not defined anywhere, probably should be
+            const data = msg.data ?? {};
+            const motivation = data.motivation ?? 'User input is needed';
+            const concurrency = data.concurrency ?? 0;
+            // only talk to user if STDIN is a terminal (otherwise, fail)
+            if (!this.isTTY) {
+                throw new error_1.ToolkitError(`${motivation}, but terminal (TTY) is not attached so we are unable to get a confirmation from the user`);
+            }
+            // only talk to user if concurrency is 1 (otherwise, fail)
+            if (concurrency > 1) {
+                throw new error_1.ToolkitError(`${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
+            if (isConfirmationPrompt(msg)) {
+                const confirmed = await promptly.confirm(`${chalk.cyan(msg.message)} (y/n)`);
+                if (!confirmed) {
+                    throw new error_1.ToolkitError('Aborted by user');
+                }
+                return confirmed;
+            }
+            // Asking for a specific value
+            const prompt = extractPromptInfo(msg);
+            const answer = await promptly.prompt(`${chalk.cyan(msg.message)} (${prompt.default})`, {
+                default: prompt.default,
+            });
+            return prompt.convertAnswer(answer);
+        });
+        // We need to cast this because it is impossible to narrow the generic type
+        // isPromptableRequest ensures that the response type is one we can prompt for
+        // the remaining code ensure we are indeed returning the correct type
+        return response;
     }
     /**
      * Formats a message for console output with optional color support
@@ -166,9 +235,37 @@ class CliIoHost {
     }
 }
 exports.CliIoHost = CliIoHost;
+/**
+ * This IoHost implementation considers a request promptable, if:
+ * - it's a yes/no confirmation
+ * - asking for a string or number value
+ */
+function isPromptableRequest(msg) {
+    return isConfirmationPrompt(msg)
+        || typeof msg.defaultResponse === 'string'
+        || typeof msg.defaultResponse === 'number';
+}
+/**
+ * Check if the request is a confirmation prompt
+ * We treat all requests with a boolean response as confirmation prompts
+ */
+function isConfirmationPrompt(msg) {
+    return typeof msg.defaultResponse === 'boolean';
+}
+/**
+ * Helper to extract information for promptly from the request
+ */
+function extractPromptInfo(msg) {
+    const isNumber = (typeof msg.defaultResponse === 'number');
+    return {
+        default: util.format(msg.defaultResponse),
+        convertAnswer: isNumber ? (v) => Number(v) : (v) => String(v),
+    };
+}
 const styleMap = {
     error: chalk.red,
     warn: chalk.yellow,
+    result: chalk.white,
     info: chalk.white,
     debug: chalk.gray,
     trace: chalk.gray,
@@ -180,4 +277,4 @@ const styleMap = {
 function isCI() {
     return process.env.CI !== undefined && process.env.CI !== 'false' && process.env.CI !== '0';
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli-io-host.js","sourceRoot":"","sources":["cli-io-host.ts"],"names":[],"mappings":"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","sourcesContent":["import * as chalk from 'chalk';\n\nexport type IoMessageCodeCategory = 'TOOLKIT' | 'SDK' | 'ASSETS';\nexport type IoCodeLevel = 'E' | 'W' | 'I';\nexport type IoMessageSpecificCode<L extends IoCodeLevel> = `CDK_${IoMessageCodeCategory}_${L}${number}${number}${number}${number}`;\nexport type IoMessageCode = IoMessageSpecificCode<IoCodeLevel>;\n\n/**\n * Basic message structure for toolkit notifications.\n * Messages are emitted by the toolkit and handled by the IoHost.\n */\nexport interface IoMessage<T> {\n  /**\n   * The time the message was emitted.\n   */\n  readonly time: Date;\n\n  /**\n   * The log level of the message.\n   */\n  readonly level: IoMessageLevel;\n\n  /**\n   * The action that triggered the message.\n   */\n  readonly action: ToolkitAction;\n\n  /**\n   * A short message code uniquely identifying a message type using the format CDK_[CATEGORY]_[E/W/I][000-999].\n   *\n   * The level indicator follows these rules:\n   * - 'E' for error level messages\n   * - 'W' for warning level messages\n   * - 'I' for info/debug/trace level messages\n   *\n   * Codes ending in 000 are generic messages, while codes ending in 001-999 are specific to a particular message.\n   * The following are examples of valid and invalid message codes:\n   * ```ts\n   * 'CDK_ASSETS_I000'       // valid: generic assets info message\n   * 'CDK_TOOLKIT_E002'      // valid: specific toolkit error message\n   * 'CDK_SDK_W023'          // valid: specific sdk warning message\n   * ```\n   */\n  readonly code: IoMessageCode;\n\n  /**\n   * The message text.\n   */\n  readonly message: string;\n\n  /**\n   * If true, the message will be written to stdout\n   * regardless of any other parameters.\n   *\n   * @default false\n   */\n  readonly forceStdout?: boolean;\n\n  /**\n   * The data attached to the message.\n   */\n  readonly data?: T;\n}\n\nexport interface IoRequest<T, U> extends IoMessage<T> {\n  /**\n   * The default response that will be used if no data is returned.\n   */\n  readonly defaultResponse: U;\n}\n\nexport type IoMessageLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';\n\nexport const levelPriority: Record<IoMessageLevel, number> = {\n  error: 0,\n  warn: 1,\n  info: 2,\n  debug: 3,\n  trace: 4,\n};\n\n/**\n * The current action being performed by the CLI. 'none' represents the absence of an action.\n */\nexport type ToolkitAction =\n| 'bootstrap'\n| 'synth'\n| 'list'\n| 'diff'\n| 'deploy'\n| 'rollback'\n| 'watch'\n| 'destroy'\n| 'context'\n| 'docs'\n| 'doctor'\n| 'gc'\n| 'import'\n| 'metadata'\n| 'notices'\n| 'init'\n| 'migrate'\n| 'version';\n\nexport interface IIoHost {\n  /**\n   * Notifies the host of a message.\n   * The caller waits until the notification completes.\n   */\n  notify<T>(msg: IoMessage<T>): Promise<void>;\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  requestResponse<T, U>(msg: IoRequest<T, U>): Promise<U>;\n}\n\nexport interface CliIoHostProps {\n  /**\n   * The initial Toolkit action the hosts starts with.\n   *\n   * @default 'none'\n   */\n  readonly currentAction?: ToolkitAction;\n\n  /**\n   * Determines the verbosity of the output.\n   *\n   * The CliIoHost will still receive all messages and requests,\n   * but only the messages included in this level will be printed.\n   *\n   * @default 'info'\n   */\n  readonly logLevel?: IoMessageLevel;\n\n  /**\n   * Overrides the automatic TTY detection.\n   *\n   * When TTY is disabled, the CLI will have no interactions or color.\n   *\n   * @default - determined from the current process\n   */\n  readonly isTTY?: boolean;\n\n  /**\n   * Whether the CliIoHost is running in CI mode.\n   *\n   * In CI mode, all non-error output goes to stdout instead of stderr.\n   * Set to false in the CliIoHost constructor it will be overwritten if the CLI CI argument is passed\n   *\n   * @default - determined from the environment, specifically based on `process.env.CI`\n   */\n  readonly isCI?: boolean;\n}\n\n/**\n * A simple IO host for the CLI that writes messages to the console.\n */\nexport class CliIoHost implements IIoHost {\n  /**\n   * Returns the singleton instance\n   */\n  static instance(props: CliIoHostProps = {}, forceNew = false): CliIoHost {\n    if (forceNew || !CliIoHost._instance) {\n      CliIoHost._instance = new CliIoHost(props);\n    }\n    return CliIoHost._instance;\n  }\n\n  /**\n   * Singleton instance of the CliIoHost\n   */\n  private static _instance: CliIoHost | undefined;\n\n  private _currentAction: ToolkitAction;\n  private _isCI: boolean;\n  private _isTTY: boolean;\n  private _logLevel: IoMessageLevel;\n  private _internalIoHost?: IIoHost;\n\n  private constructor(props: CliIoHostProps = {}) {\n    this._currentAction = props.currentAction ?? 'none' as ToolkitAction;\n    this._isTTY = props.isTTY ?? process.stdout.isTTY ?? false;\n    this._logLevel = props.logLevel ?? 'info';\n    this._isCI = props.isCI ?? isCI();\n  }\n\n  /**\n   * Returns the singleton instance\n   */\n  public registerIoHost(ioHost: IIoHost) {\n    if (ioHost !== this) {\n      this._internalIoHost = ioHost;\n    }\n  }\n\n  /**\n   * The current action being performed by the CLI.\n   */\n  public get currentAction(): ToolkitAction {\n    return this._currentAction;\n  }\n\n  /**\n   * Sets the current action being performed by the CLI.\n   *\n   * @param action The action being performed by the CLI.\n   */\n  public set currentAction(action: ToolkitAction) {\n    this._currentAction = action;\n  }\n\n  /**\n   * Whether the host can use interactions and message styling.\n   */\n  public get isTTY(): boolean {\n    return this._isTTY;\n  }\n\n  /**\n   * Set TTY mode, i.e can the host use interactions and message styling.\n   *\n   * @param value set TTY mode\n   */\n  public set isTTY(value: boolean) {\n    this._isTTY = value;\n  }\n\n  /**\n   * Whether the CliIoHost is running in CI mode. In CI mode, all non-error output goes to stdout instead of stderr.\n   */\n  public get isCI(): boolean {\n    return this._isCI;\n  }\n\n  /**\n   * Set the CI mode. In CI mode, all non-error output goes to stdout instead of stderr.\n   * @param value set the CI mode\n   */\n  public set isCI(value: boolean) {\n    this._isCI = value;\n  }\n\n  /**\n   * The current threshold. Messages with a lower priority level will be ignored.\n   */\n  public get logLevel(): IoMessageLevel {\n    return this._logLevel;\n  }\n\n  /**\n   * Sets the current threshold. Messages with a lower priority level will be ignored.\n   * @param level The new log level threshold\n   */\n  public set logLevel(level: IoMessageLevel) {\n    this._logLevel = level;\n  }\n\n  /**\n   * Notifies the host of a message.\n   * The caller waits until the notification completes.\n   */\n  public async notify<T>(msg: IoMessage<T>): Promise<void> {\n    if (this._internalIoHost) {\n      return this._internalIoHost.notify(msg);\n    }\n\n    if (levelPriority[msg.level] > levelPriority[this.logLevel]) {\n      return;\n    }\n\n    const output = this.formatMessage(msg);\n    const stream = this.stream(msg.level, msg.forceStdout ?? false);\n\n    return new Promise((resolve, reject) => {\n      stream.write(output, (err) => {\n        if (err) {\n          reject(err);\n        } else {\n          resolve();\n        }\n      });\n    });\n  }\n\n  /**\n   * Determines which output stream to use based on log level and configuration.\n   */\n  private stream(level: IoMessageLevel, forceStdout: boolean) {\n    // For legacy purposes all log streams are written to stderr by default, unless\n    // specified otherwise, by passing `forceStdout`, which is used by the `data()` logging function, or\n    // if the CDK is running in a CI environment. This is because some CI environments will immediately\n    // fail if stderr is written to. In these cases, we detect if we are in a CI environment and\n    // write all messages to stdout instead.\n    if (forceStdout) {\n      return process.stdout;\n    }\n    if (level == 'error') return process.stderr;\n    return CliIoHost.instance().isCI ? process.stdout : process.stderr;\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<T, U>(msg: IoRequest<T, U>): Promise<U> {\n    if (this._internalIoHost) {\n      return this._internalIoHost.requestResponse(msg);\n    }\n\n    await this.notify(msg);\n    return msg.defaultResponse;\n  }\n\n  /**\n   * Formats a message for console output with optional color support\n   */\n  private formatMessage(msg: IoMessage<any>): 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\nconst styleMap: Record<IoMessageLevel, (str: string) => string> = {\n  error: chalk.red,\n  warn: chalk.yellow,\n  info: chalk.white,\n  debug: chalk.gray,\n  trace: chalk.gray,\n};\n\n/**\n * Returns true if the current process is running in a CI environment\n * @returns true if the current process is running in a CI environment\n */\nexport function isCI(): boolean {\n  return process.env.CI !== undefined && process.env.CI !== 'false' && process.env.CI !== '0';\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli-io-host.js","sourceRoot":"","sources":["cli-io-host.ts"],"names":[],"mappings":"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","sourcesContent":["import * as util from 'node:util';\nimport * as chalk from 'chalk';\nimport * as promptly from 'promptly';\nimport { ToolkitError } from './error';\n\nexport type IoMessageCodeCategory = 'TOOLKIT' | 'SDK' | 'ASSETS';\nexport type IoCodeLevel = 'E' | 'W' | 'I';\nexport type IoMessageSpecificCode<L extends IoCodeLevel> = `CDK_${IoMessageCodeCategory}_${L}${number}${number}${number}${number}`;\nexport type IoMessageCode = IoMessageSpecificCode<IoCodeLevel>;\n\n/**\n * Basic message structure for toolkit notifications.\n * Messages are emitted by the toolkit and handled by the IoHost.\n */\nexport interface IoMessage<T> {\n  /**\n   * The time the message was emitted.\n   */\n  readonly time: Date;\n\n  /**\n   * The log level of the message.\n   */\n  readonly level: IoMessageLevel;\n\n  /**\n   * The action that triggered the message.\n   */\n  readonly action: ToolkitAction;\n\n  /**\n   * A short message code uniquely identifying a message type using the format CDK_[CATEGORY]_[E/W/I][000-999].\n   *\n   * The level indicator follows these rules:\n   * - 'E' for error level messages\n   * - 'W' for warning level messages\n   * - 'I' for info/debug/trace level messages\n   *\n   * Codes ending in 000 are generic messages, while codes ending in 001-999 are specific to a particular message.\n   * The following are examples of valid and invalid message codes:\n   * ```ts\n   * 'CDK_ASSETS_I000'       // valid: generic assets info message\n   * 'CDK_TOOLKIT_E002'      // valid: specific toolkit error message\n   * 'CDK_SDK_W023'          // valid: specific sdk warning message\n   * ```\n   */\n  readonly code: IoMessageCode;\n\n  /**\n   * The message text.\n   */\n  readonly message: string;\n\n  /**\n   * The data attached to the message.\n   */\n  readonly data?: T;\n}\n\nexport interface IoRequest<T, U> extends IoMessage<T> {\n  /**\n   * The default response that will be used if no data is returned.\n   */\n  readonly defaultResponse: U;\n}\n\nexport type IoMessageLevel = 'error' | 'result' | 'warn' | 'info' | 'debug' | 'trace';\n\nexport const levelPriority: Record<IoMessageLevel, number> = {\n  error: 0,\n  result: 1,\n  warn: 2,\n  info: 3,\n  debug: 4,\n  trace: 5,\n};\n\n/**\n * The current action being performed by the CLI. 'none' represents the absence of an action.\n */\nexport type ToolkitAction =\n| 'assembly'\n| 'bootstrap'\n| 'synth'\n| 'list'\n| 'diff'\n| 'deploy'\n| 'rollback'\n| 'watch'\n| 'destroy'\n| 'context'\n| 'docs'\n| 'doctor'\n| 'gc'\n| 'import'\n| 'metadata'\n| 'notices'\n| 'init'\n| 'migrate'\n| 'version';\n\nexport interface IIoHost {\n  /**\n   * Notifies the host of a message.\n   * The caller waits until the notification completes.\n   */\n  notify<T>(msg: IoMessage<T>): Promise<void>;\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  requestResponse<T, U>(msg: IoRequest<T, U>): Promise<U>;\n}\n\nexport interface CliIoHostProps {\n  /**\n   * The initial Toolkit action the hosts starts with.\n   *\n   * @default 'none'\n   */\n  readonly currentAction?: ToolkitAction;\n\n  /**\n   * Determines the verbosity of the output.\n   *\n   * The CliIoHost will still receive all messages and requests,\n   * but only the messages included in this level will be printed.\n   *\n   * @default 'info'\n   */\n  readonly logLevel?: IoMessageLevel;\n\n  /**\n   * Overrides the automatic TTY detection.\n   *\n   * When TTY is disabled, the CLI will have no interactions or color.\n   *\n   * @default - determined from the current process\n   */\n  readonly isTTY?: boolean;\n\n  /**\n   * Whether the CliIoHost is running in CI mode.\n   *\n   * In CI mode, all non-error output goes to stdout instead of stderr.\n   * Set to false in the CliIoHost constructor it will be overwritten if the CLI CI argument is passed\n   *\n   * @default - determined from the environment, specifically based on `process.env.CI`\n   */\n  readonly isCI?: boolean;\n}\n\n/**\n * A simple IO host for the CLI that writes messages to the console.\n */\nexport class CliIoHost implements IIoHost {\n  /**\n   * Returns the singleton instance\n   */\n  static instance(props: CliIoHostProps = {}, forceNew = false): CliIoHost {\n    if (forceNew || !CliIoHost._instance) {\n      CliIoHost._instance = new CliIoHost(props);\n    }\n    return CliIoHost._instance;\n  }\n\n  /**\n   * Singleton instance of the CliIoHost\n   */\n  private static _instance: CliIoHost | undefined;\n\n  // internal state for getters/setter\n  private _currentAction: ToolkitAction;\n  private _isCI: boolean;\n  private _isTTY: boolean;\n  private _logLevel: IoMessageLevel;\n  private _internalIoHost?: IIoHost;\n\n  // Corked Logging\n  private corkedCounter = 0;\n  private readonly corkedLoggingBuffer: IoMessage<any>[] = [];\n\n  private constructor(props: CliIoHostProps = {}) {\n    this._currentAction = props.currentAction ?? 'none' as ToolkitAction;\n    this._isTTY = props.isTTY ?? process.stdout.isTTY ?? false;\n    this._logLevel = props.logLevel ?? 'info';\n    this._isCI = props.isCI ?? isCI();\n  }\n\n  /**\n   * Returns the singleton instance\n   */\n  public registerIoHost(ioHost: IIoHost) {\n    if (ioHost !== this) {\n      this._internalIoHost = ioHost;\n    }\n  }\n\n  /**\n   * The current action being performed by the CLI.\n   */\n  public get currentAction(): ToolkitAction {\n    return this._currentAction;\n  }\n\n  /**\n   * Sets the current action being performed by the CLI.\n   *\n   * @param action The action being performed by the CLI.\n   */\n  public set currentAction(action: ToolkitAction) {\n    this._currentAction = action;\n  }\n\n  /**\n   * Whether the host can use interactions and message styling.\n   */\n  public get isTTY(): boolean {\n    return this._isTTY;\n  }\n\n  /**\n   * Set TTY mode, i.e can the host use interactions and message styling.\n   *\n   * @param value set TTY mode\n   */\n  public set isTTY(value: boolean) {\n    this._isTTY = value;\n  }\n\n  /**\n   * Whether the CliIoHost is running in CI mode. In CI mode, all non-error output goes to stdout instead of stderr.\n   */\n  public get isCI(): boolean {\n    return this._isCI;\n  }\n\n  /**\n   * Set the CI mode. In CI mode, all non-error output goes to stdout instead of stderr.\n   * @param value set the CI mode\n   */\n  public set isCI(value: boolean) {\n    this._isCI = value;\n  }\n\n  /**\n   * The current threshold. Messages with a lower priority level will be ignored.\n   */\n  public get logLevel(): IoMessageLevel {\n    return this._logLevel;\n  }\n\n  /**\n   * Sets the current threshold. Messages with a lower priority level will be ignored.\n   * @param level The new log level threshold\n   */\n  public set logLevel(level: IoMessageLevel) {\n    this._logLevel = level;\n  }\n\n  /**\n   * Executes a block of code with corked logging. All log messages during execution\n   * are buffered and only written when all nested cork blocks complete (when CORK_COUNTER reaches 0).\n   * The corking is bound to the specific instance of the CliIoHost.\n   *\n   * @param block - Async function to execute with corked logging\n   * @returns Promise that resolves with the block's return value\n   */\n  public async withCorkedLogging<T>(block: () => Promise<T>): Promise<T> {\n    this.corkedCounter++;\n    try {\n      return await block();\n    } finally {\n      this.corkedCounter--;\n      if (this.corkedCounter === 0) {\n        // Process each buffered message through notify\n        for (const ioMessage of this.corkedLoggingBuffer) {\n          await this.notify(ioMessage);\n        }\n        // remove all buffered messages in-place\n        this.corkedLoggingBuffer.splice(0);\n      }\n    }\n  }\n\n  /**\n   * Notifies the host of a message.\n   * The caller waits until the notification completes.\n   */\n  public async notify<T>(msg: IoMessage<T>): Promise<void> {\n    if (this._internalIoHost) {\n      return this._internalIoHost.notify(msg);\n    }\n\n    if (levelPriority[msg.level] > levelPriority[this.logLevel]) {\n      return;\n    }\n\n    if (this.corkedCounter > 0) {\n      this.corkedLoggingBuffer.push(msg);\n      return;\n    }\n\n    const output = this.formatMessage(msg);\n    const stream = this.selectStream(msg.level);\n    stream.write(output);\n  }\n\n  /**\n   * Determines the output stream, based on message level and configuration.\n   */\n  private selectStream(level: IoMessageLevel) {\n    // The stream selection policy for the CLI is the following:\n    //\n    //   (1) Messages of level `result` always go to `stdout`\n    //   (2) Messages of level `error` always go to `stderr`.\n    //   (3a) All remaining messages go to `stderr`.\n    //   (3b) If we are in CI mode, all remaining messages go to `stdout`.\n    //\n    switch (level) {\n      case 'error':\n        return process.stderr;\n      case 'result':\n        return process.stdout;\n      default:\n        return this.isCI ? process.stdout : process.stderr;\n    }\n  }\n\n  /**\n   * Notifies the host of a message that requires a response.\n   *\n   * If the host does not return a response the suggested\n   * default response from the input message will be used.\n   */\n  public async requestResponse<DataType, ResponseType>(msg: IoRequest<DataType, ResponseType>): Promise<ResponseType> {\n    // First call out to a registered instance if we have one\n    if (this._internalIoHost) {\n      return this._internalIoHost.requestResponse(msg);\n    }\n\n    // If the request cannot be prompted for by the CliIoHost, we just accept the default\n    if (!isPromptableRequest(msg)) {\n      await this.notify(msg);\n      return msg.defaultResponse;\n    }\n\n    const response = await this.withCorkedLogging(async (): Promise<string | number | true> => {\n      // prepare prompt data\n      // @todo this format is not defined anywhere, probably should be\n      const data: {\n        motivation?: string;\n        concurrency?: number;\n      } = msg.data ?? {};\n\n      const motivation = data.motivation ?? 'User input is needed';\n      const concurrency = data.concurrency ?? 0;\n\n      // only talk to user if STDIN is a terminal (otherwise, fail)\n      if (!this.isTTY) {\n        throw new ToolkitError(`${motivation}, but terminal (TTY) is not attached so we are unable to get a confirmation from the user`);\n      }\n\n      // only talk to user if concurrency is 1 (otherwise, fail)\n      if (concurrency > 1) {\n        throw new ToolkitError(`${motivation}, but concurrency is greater than 1 so we are unable to get a confirmation from the user`);\n      }\n\n      // Basic confirmation prompt\n      // We treat all requests with a boolean response as confirmation prompts\n      if (isConfirmationPrompt(msg)) {\n        const confirmed = await promptly.confirm(`${chalk.cyan(msg.message)} (y/n)`);\n        if (!confirmed) {\n          throw new ToolkitError('Aborted by user');\n        }\n        return confirmed;\n      }\n\n      // Asking for a specific value\n      const prompt = extractPromptInfo(msg);\n      const answer = await promptly.prompt(`${chalk.cyan(msg.message)} (${prompt.default})`, {\n        default: prompt.default,\n      });\n      return prompt.convertAnswer(answer);\n    });\n\n    // We need to cast this because it is impossible to narrow the generic type\n    // isPromptableRequest ensures that the response type is one we can prompt for\n    // the remaining code ensure we are indeed returning the correct type\n    return response as ResponseType;\n  }\n\n  /**\n   * Formats a message for console output with optional color support\n   */\n  private formatMessage(msg: IoMessage<any>): 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/**\n * This IoHost implementation considers a request promptable, if:\n * - it's a yes/no confirmation\n * - asking for a string or number value\n */\nfunction isPromptableRequest(msg: IoRequest<any, any>): msg is IoRequest<any, string | number | boolean> {\n  return isConfirmationPrompt(msg)\n    || typeof msg.defaultResponse === 'string'\n    || typeof msg.defaultResponse === 'number';\n}\n\n/**\n * Check if the request is a confirmation prompt\n * We treat all requests with a boolean response as confirmation prompts\n */\nfunction isConfirmationPrompt(msg: IoRequest<any, any>): msg is IoRequest<any, boolean> {\n  return typeof msg.defaultResponse === 'boolean';\n}\n\n/**\n * Helper to extract information for promptly from the request\n */\nfunction extractPromptInfo(msg: IoRequest<any, any>): {\n  default: string;\n  convertAnswer: (input: string) => string | number;\n} {\n  const isNumber = (typeof msg.defaultResponse === 'number');\n  return {\n    default: util.format(msg.defaultResponse),\n    convertAnswer: isNumber ? (v) => Number(v) : (v) => String(v),\n  };\n}\n\nconst styleMap: Record<IoMessageLevel, (str: string) => string> = {\n  error: chalk.red,\n  warn: chalk.yellow,\n  result: chalk.white,\n  info: chalk.white,\n  debug: chalk.gray,\n  trace: chalk.gray,\n};\n\n/**\n * Returns true if the current process is running in a CI environment\n * @returns true if the current process is running in a CI environment\n */\nexport function isCI(): boolean {\n  return process.env.CI !== undefined && process.env.CI !== 'false' && process.env.CI !== '0';\n}\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aws-cdk",
   "description": "CDK Toolkit, the command line tool for CDK apps",
-  "version": "2.177.0",
+  "version": "2.178.0",
   "bin": {
     "cdk": "bin/cdk"
   },
@@ -103,10 +103,10 @@
   },
   "license": "Apache-2.0",
   "devDependencies": {
-    "@aws-cdk/cdk-build-tools": "2.177.0-alpha.0",
-    "@aws-cdk/cli-plugin-contract": "2.177.0",
-    "@aws-cdk/pkglint": "2.177.0-alpha.0",
-    "@aws-cdk/user-input-gen": "2.177.0-alpha.0",
+    "@aws-cdk/cdk-build-tools": "2.178.0-alpha.0",
+    "@aws-cdk/cli-plugin-contract": "2.178.0",
+    "@aws-cdk/pkglint": "2.178.0-alpha.0",
+    "@aws-cdk/user-input-gen": "2.178.0-alpha.0",
     "@octokit/rest": "^18.12.0",
     "@types/archiver": "^5.3.4",
     "@types/fs-extra": "^9.0.13",
@@ -121,7 +121,7 @@
     "@types/uuid": "^8.3.4",
     "@types/wrap-ansi": "^3.0.0",
     "@types/yargs": "^15.0.19",
-    "aws-cdk-lib": "2.177.0",
+    "aws-cdk-lib": "2.178.0",
     "aws-sdk-client-mock": "^4.0.1",
     "aws-sdk-client-mock-jest": "^4.0.1",
     "axios": "^1.7.7",
@@ -139,9 +139,9 @@
     "ts-mock-imports": "^1.3.16",
     "xml-js": "^1.6.11",
     "@aws-cdk/cloud-assembly-schema": "^39.2.0",
-    "@aws-cdk/cloudformation-diff": "2.177.0",
-    "@aws-cdk/cx-api": "2.177.0",
-    "@aws-cdk/region-info": "2.177.0",
+    "@aws-cdk/cloudformation-diff": "2.178.0",
+    "@aws-cdk/cx-api": "2.178.0",
+    "@aws-cdk/region-info": "2.178.0",
     "@aws-sdk/client-appsync": "^3.699.0",
     "@aws-sdk/client-cloudformation": "^3.699.0",
     "@aws-sdk/client-cloudwatch-logs": "^3.699.0",
@@ -173,7 +173,7 @@
     "@smithy/util-waiter": "^3.2.0",
     "archiver": "^5.3.2",
     "camelcase": "^6.3.0",
-    "cdk-assets": "^3.0.0-rc.123",
+    "cdk-assets": "^3.0.0-rc.127",
     "cdk-from-cfn": "^0.162.0",
     "chalk": "^4",
     "chokidar": "^3.6.0",

package/test/_helpers/prompts.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Sends a response to a prompt to stdin
+ * When using this in tests, call just before the prompt runs.
+ *
+ * @example
+ * ```ts
+ * sendResponse('y');
+ * await prompt('Confirm (y/n)?');
+ * ```
+ */
+export declare function sendResponse(res: string, delay?: number): void;

package/test/_helpers/prompts.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendResponse = sendResponse;
+/**
+ * Sends a response to a prompt to stdin
+ * When using this in tests, call just before the prompt runs.
+ *
+ * @example
+ * ```ts
+ * sendResponse('y');
+ * await prompt('Confirm (y/n)?');
+ * ```
+ */
+function sendResponse(res, delay = 0) {
+    if (!delay) {
+        setImmediate(() => process.stdin.emit('data', `${res}\n`));
+    }
+    else {
+        setTimeout(() => process.stdin.emit('data', `${res}\n`), delay);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvbXB0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInByb21wdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFVQSxvQ0FNQztBQWhCRDs7Ozs7Ozs7O0dBU0c7QUFDSCxTQUFnQixZQUFZLENBQUMsR0FBVyxFQUFFLEtBQUssR0FBRyxDQUFDO0lBQ2pELElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNYLFlBQVksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsR0FBRyxHQUFHLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDN0QsQ0FBQztTQUFNLENBQUM7UUFDTixVQUFVLENBQUMsR0FBRyxFQUFFLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLEdBQUcsR0FBRyxJQUFJLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FBQztJQUNsRSxDQUFDO0FBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogU2VuZHMgYSByZXNwb25zZSB0byBhIHByb21wdCB0byBzdGRpblxuICogV2hlbiB1c2luZyB0aGlzIGluIHRlc3RzLCBjYWxsIGp1c3QgYmVmb3JlIHRoZSBwcm9tcHQgcnVucy5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHNcbiAqIHNlbmRSZXNwb25zZSgneScpO1xuICogYXdhaXQgcHJvbXB0KCdDb25maXJtICh5L24pPycpO1xuICogYGBgXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzZW5kUmVzcG9uc2UocmVzOiBzdHJpbmcsIGRlbGF5ID0gMCkge1xuICBpZiAoIWRlbGF5KSB7XG4gICAgc2V0SW1tZWRpYXRlKCgpID0+IHByb2Nlc3Muc3RkaW4uZW1pdCgnZGF0YScsIGAke3Jlc31cXG5gKSk7XG4gIH0gZWxzZSB7XG4gICAgc2V0VGltZW91dCgoKSA9PiBwcm9jZXNzLnN0ZGluLmVtaXQoJ2RhdGEnLCBgJHtyZXN9XFxuYCksIGRlbGF5KTtcbiAgfVxufVxuIl19

package/test/api/aws-auth/sdk-logger.test.js

@@ -1,20 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const sdk_logger_1 = require("../../../lib/api/aws-auth/sdk-logger");
-const logging = require("../../../lib/logging");
 describe(sdk_logger_1.SdkToCliLogger, () => {
-    const logger = new sdk_logger_1.SdkToCliLogger();
-    const trace = jest.spyOn(logging, 'trace');
+    const ioHost = {
+        notify: jest.fn(),
+        requestResponse: jest.fn(),
+    };
+    const logger = new sdk_logger_1.SdkToCliLogger(ioHost);
     beforeEach(() => {
-        trace.mockReset();
+        ioHost.notify.mockReset();
     });
-    test.each(['trace', 'debug'])('%s method does not call trace', (meth) => {
-        logger[meth]('test');
-        expect(trace).not.toHaveBeenCalled();
+    test.each(['trace', 'debug'])('%s method does not call notify', (method) => {
+        logger[method]('test');
+        expect(ioHost.notify).not.toHaveBeenCalled();
     });
-    test.each(['info', 'warn', 'error'])('%s method logs to trace', (meth) => {
-        logger[meth]('test');
-        expect(trace).toHaveBeenCalled();
+    test.each(['info', 'warn', 'error'])('%s method logs to notify', (method) => {
+        logger[method]('test');
+        expect(ioHost.notify).toHaveBeenCalled();
     });
 });
 const SUCCESS_CALL = {
@@ -70,4 +72,4 @@ test('formatting a failing SDK call includes the error', () => {
     const output = (0, sdk_logger_1.formatSdkLoggerContent)([ERROR_CALL]);
     expect(output).toContain('it failed');
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2RrLWxvZ2dlci50ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsic2RrLWxvZ2dlci50ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEscUVBQThGO0FBRTlGLFFBQVEsQ0FBQywyQkFBYyxFQUFFLEdBQUcsRUFBRTtJQUM1QixNQUFNLE1BQU0sR0FBRztRQUNiLE1BQU0sRUFBRSxJQUFJLENBQUMsRUFBRSxFQUFFO1FBQ2pCLGVBQWUsRUFBRSxJQUFJLENBQUMsRUFBRSxFQUFFO0tBQzNCLENBQUM7SUFDRixNQUFNLE1BQU0sR0FBRyxJQUFJLDJCQUFjLENBQUMsTUFBTSxDQUFDLENBQUM7SUFFMUMsVUFBVSxDQUFDLEdBQUcsRUFBRTtRQUNkLE1BQU0sQ0FBQyxNQUFNLENBQUMsU0FBUyxFQUFFLENBQUM7SUFDNUIsQ0FBQyxDQUFDLENBQUM7SUFFSCxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBZ0MsQ0FBQyxDQUFDLGdDQUFnQyxFQUFFLENBQUMsTUFBTSxFQUFFLEVBQUU7UUFDeEcsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ3ZCLE1BQU0sQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsR0FBRyxDQUFDLGdCQUFnQixFQUFFLENBQUM7SUFDL0MsQ0FBQyxDQUFDLENBQUM7SUFFSCxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxPQUFPLENBQWdDLENBQUMsQ0FBQywwQkFBMEIsRUFBRSxDQUFDLE1BQU0sRUFBRSxFQUFFO1FBQ3pHLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUN2QixNQUFNLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLGdCQUFnQixFQUFFLENBQUM7SUFDM0MsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDLENBQUMsQ0FBQztBQUVILE1BQU0sWUFBWSxHQUFHO0lBQ25CLFVBQVUsRUFBRSxVQUFVO0lBQ3RCLFdBQVcsRUFBRSwwQkFBMEI7SUFDdkMsS0FBSyxFQUFFO1FBQ0wsTUFBTSxFQUFFLE9BQU87UUFDZixtQkFBbUIsRUFBRSxTQUFTO0tBQy9CO0lBQ0QsTUFBTSxFQUFFLEVBQUUsa0JBQWtCLEVBQUUsY0FBYyxFQUFFO0lBQzlDLFFBQVEsRUFBRTtRQUNSLGNBQWMsRUFBRSxHQUFHO1FBQ25CLFNBQVMsRUFBRSxNQUFNO1FBQ2pCLGlCQUFpQixFQUFFLEtBQUs7UUFDeEIsSUFBSSxFQUFFLFNBQVM7UUFDZixRQUFRLEVBQUUsQ0FBQztRQUNYLGVBQWUsRUFBRSxFQUFFO0tBQ3BCO0NBQ0YsQ0FBQztBQUVGLE1BQU0sVUFBVSxHQUFHO0lBQ2pCLFVBQVUsRUFBRSxVQUFVO0lBQ3RCLFdBQVcsRUFBRSwwQkFBMEI7SUFDdkMsS0FBSyxFQUFFO1FBQ0wsTUFBTSxFQUFFLE9BQU87UUFDZixtQkFBbUIsRUFBRSxTQUFTO0tBQy9CO0lBQ0QsS0FBSyxFQUFFLElBQUksS0FBSyxDQUFDLFdBQVcsQ0FBQztJQUM3QixRQUFRLEVBQUU7UUFDUixjQUFjLEVBQUUsR0FBRztRQUNuQixRQUFRLEVBQUUsQ0FBQztRQUNYLGVBQWUsRUFBRSxFQUFFO0tBQ3BCO0NBQ0YsQ0FBQztBQUVGLElBQUksQ0FBQywyREFBMkQsRUFBRSxHQUFHLEVBQUU7SUFDckUsTUFBTSxNQUFNLEdBQUcsSUFBQSxtQ0FBc0IsRUFBQyxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUM7SUFDdEQsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLGVBQWUsRUFBRSxDQUFDO0FBQ25DLENBQUMsQ0FBQyxDQUFDO0FBRUgsSUFBSSxDQUFDLHdEQUF3RCxFQUFFLEdBQUcsRUFBRTtJQUNsRSxNQUFNLE1BQU0sR0FBRyxJQUFBLG1DQUFzQixFQUFDLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQztJQUNwRCxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsZUFBZSxFQUFFLENBQUM7QUFDbkMsQ0FBQyxDQUFDLENBQUM7QUFFSCxJQUFJLENBQUMsa0ZBQWtGLEVBQUUsR0FBRyxFQUFFO0lBQzVGLE1BQU0sTUFBTSxHQUFHLElBQUEsbUNBQXNCLEVBQUMsQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFDO0lBQ3RELE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxTQUFTLENBQUMsWUFBWSxDQUFDLENBQUM7SUFDdkMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUNuQyxDQUFDLENBQUMsQ0FBQztBQUVILElBQUksQ0FBQywrRUFBK0UsRUFBRSxHQUFHLEVBQUU7SUFDekYsTUFBTSxNQUFNLEdBQUcsSUFBQSxtQ0FBc0IsRUFBQyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUM7SUFDcEQsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLFNBQVMsQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUN2QyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0FBQ25DLENBQUMsQ0FBQyxDQUFDO0FBRUgsSUFBSSxDQUFDLGtEQUFrRCxFQUFFLEdBQUcsRUFBRTtJQUM1RCxNQUFNLE1BQU0sR0FBRyxJQUFBLG1DQUFzQixFQUFDLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQztJQUNwRCxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsU0FBUyxDQUFDLFdBQVcsQ0FBQyxDQUFDO0FBQ3hDLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZm9ybWF0U2RrTG9nZ2VyQ29udGVudCwgU2RrVG9DbGlMb2dnZXIgfSBmcm9tICcuLi8uLi8uLi9saWIvYXBpL2F3cy1hdXRoL3Nkay1sb2dnZXInO1xuXG5kZXNjcmliZShTZGtUb0NsaUxvZ2dlciwgKCkgPT4ge1xuICBjb25zdCBpb0hvc3QgPSB7XG4gICAgbm90aWZ5OiBqZXN0LmZuKCksXG4gICAgcmVxdWVzdFJlc3BvbnNlOiBqZXN0LmZuKCksXG4gIH07XG4gIGNvbnN0IGxvZ2dlciA9IG5ldyBTZGtUb0NsaUxvZ2dlcihpb0hvc3QpO1xuXG4gIGJlZm9yZUVhY2goKCkgPT4ge1xuICAgIGlvSG9zdC5ub3RpZnkubW9ja1Jlc2V0KCk7XG4gIH0pO1xuXG4gIHRlc3QuZWFjaChbJ3RyYWNlJywgJ2RlYnVnJ10gYXMgQXJyYXk8a2V5b2YgU2RrVG9DbGlMb2dnZXI+KSgnJXMgbWV0aG9kIGRvZXMgbm90IGNhbGwgbm90aWZ5JywgKG1ldGhvZCkgPT4ge1xuICAgIGxvZ2dlclttZXRob2RdKCd0ZXN0Jyk7XG4gICAgZXhwZWN0KGlvSG9zdC5ub3RpZnkpLm5vdC50b0hhdmVCZWVuQ2FsbGVkKCk7XG4gIH0pO1xuXG4gIHRlc3QuZWFjaChbJ2luZm8nLCAnd2FybicsICdlcnJvciddIGFzIEFycmF5PGtleW9mIFNka1RvQ2xpTG9nZ2VyPikoJyVzIG1ldGhvZCBsb2dzIHRvIG5vdGlmeScsIChtZXRob2QpID0+IHtcbiAgICBsb2dnZXJbbWV0aG9kXSgndGVzdCcpO1xuICAgIGV4cGVjdChpb0hvc3Qubm90aWZ5KS50b0hhdmVCZWVuQ2FsbGVkKCk7XG4gIH0pO1xufSk7XG5cbmNvbnN0IFNVQ0NFU1NfQ0FMTCA9IHtcbiAgY2xpZW50TmFtZTogJ1MzQ2xpZW50JyxcbiAgY29tbWFuZE5hbWU6ICdHZXRCdWNrZXRMb2NhdGlvbkNvbW1hbmQnLFxuICBpbnB1dDoge1xuICAgIEJ1Y2tldDogJy4uLi4uJyxcbiAgICBFeHBlY3RlZEJ1Y2tldE93bmVyOiB1bmRlZmluZWQsXG4gIH0sXG4gIG91dHB1dDogeyBMb2NhdGlvbkNvbnN0cmFpbnQ6ICdldS1jZW50cmFsLTEnIH0sXG4gIG1ldGFkYXRhOiB7XG4gICAgaHR0cFN0YXR1c0NvZGU6IDIwMCxcbiAgICByZXF1ZXN0SWQ6ICcuLi4uJyxcbiAgICBleHRlbmRlZFJlcXVlc3RJZDogJy4uLicsXG4gICAgY2ZJZDogdW5kZWZpbmVkLFxuICAgIGF0dGVtcHRzOiAyLFxuICAgIHRvdGFsUmV0cnlEZWxheTogMzAsXG4gIH0sXG59O1xuXG5jb25zdCBFUlJPUl9DQUxMID0ge1xuICBjbGllbnROYW1lOiAnUzNDbGllbnQnLFxuICBjb21tYW5kTmFtZTogJ0dldEJ1Y2tldExvY2F0aW9uQ29tbWFuZCcsXG4gIGlucHV0OiB7XG4gICAgQnVja2V0OiAnLi4uLi4nLFxuICAgIEV4cGVjdGVkQnVja2V0T3duZXI6IHVuZGVmaW5lZCxcbiAgfSxcbiAgZXJyb3I6IG5ldyBFcnJvcignaXQgZmFpbGVkJyksXG4gIG1ldGFkYXRhOiB7XG4gICAgaHR0cFN0YXR1c0NvZGU6IDIwMCxcbiAgICBhdHRlbXB0czogMixcbiAgICB0b3RhbFJldHJ5RGVsYXk6IDMwLFxuICB9LFxufTtcblxudGVzdCgnZm9ybWF0dGluZyBhIHN1Y2Nlc3NmdWwgU0RLIGNhbGwgbG9va3MgYnJvYWRseSByZWFzb25hYmxlJywgKCkgPT4ge1xuICBjb25zdCBvdXRwdXQgPSBmb3JtYXRTZGtMb2dnZXJDb250ZW50KFtTVUNDRVNTX0NBTExdKTtcbiAgZXhwZWN0KG91dHB1dCkudG9NYXRjaFNuYXBzaG90KCk7XG59KTtcblxudGVzdCgnZm9ybWF0dGluZyBhIGZhaWxpbmcgU0RLIGNhbGwgbG9va3MgYnJvYWRseSByZWFzb25hYmxlJywgKCkgPT4ge1xuICBjb25zdCBvdXRwdXQgPSBmb3JtYXRTZGtMb2dnZXJDb250ZW50KFtFUlJPUl9DQUxMXSk7XG4gIGV4cGVjdChvdXRwdXQpLnRvTWF0Y2hTbmFwc2hvdCgpO1xufSk7XG5cbnRlc3QoJ2Zvcm1hdHRpbmcgYSBzdWNjZXNzZnVsIFNESyBjYWxsIGluY2x1ZGVzIGF0dGVtcHRzIGFuZCByZXRyaWVzIGlmIGdyZWF0ZXIgdGhhbiAxJywgKCkgPT4ge1xuICBjb25zdCBvdXRwdXQgPSBmb3JtYXRTZGtMb2dnZXJDb250ZW50KFtTVUNDRVNTX0NBTExdKTtcbiAgZXhwZWN0KG91dHB1dCkudG9Db250YWluKCcyIGF0dGVtcHRzJyk7XG4gIGV4cGVjdChvdXRwdXQpLnRvQ29udGFpbignMzBtcycpO1xufSk7XG5cbnRlc3QoJ2Zvcm1hdHRpbmcgYSBmYWlsaW5nIFNESyBjYWxsIGluY2x1ZGVzIGF0dGVtcHRzIGFuZCByZXRyaWVzIGlmIGdyZWF0ZXIgdGhhbiAxJywgKCkgPT4ge1xuICBjb25zdCBvdXRwdXQgPSBmb3JtYXRTZGtMb2dnZXJDb250ZW50KFtFUlJPUl9DQUxMXSk7XG4gIGV4cGVjdChvdXRwdXQpLnRvQ29udGFpbignMiBhdHRlbXB0cycpO1xuICBleHBlY3Qob3V0cHV0KS50b0NvbnRhaW4oJzMwbXMnKTtcbn0pO1xuXG50ZXN0KCdmb3JtYXR0aW5nIGEgZmFpbGluZyBTREsgY2FsbCBpbmNsdWRlcyB0aGUgZXJyb3InLCAoKSA9PiB7XG4gIGNvbnN0IG91dHB1dCA9IGZvcm1hdFNka0xvZ2dlckNvbnRlbnQoW0VSUk9SX0NBTExdKTtcbiAgZXhwZWN0KG91dHB1dCkudG9Db250YWluKCdpdCBmYWlsZWQnKTtcbn0pO1xuIl19