aws-cdk 0.0.0

package/lib/cli/cdk-toolkit.js

@@ -0,0 +1,1019 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdkToolkit = exports.AssetBuildTime = void 0;
+exports.markTesting = markTesting;
+const path = require("path");
+const util_1 = require("util");
+const cxapi = require("@aws-cdk/cx-api");
+const chalk = require("chalk");
+const chokidar = require("chokidar");
+const fs = require("fs-extra");
+const promptly = require("promptly");
+const uuid = require("uuid");
+const user_configuration_1 = require("./user-configuration");
+const bootstrap_1 = require("../api/bootstrap");
+const cloud_assembly_1 = require("../api/cxapp/cloud-assembly");
+const environments_1 = require("../api/cxapp/environments");
+const deployments_1 = require("../api/deployments");
+const garbage_collector_1 = require("../api/garbage-collection/garbage-collector");
+const common_1 = require("../api/hotswap/common");
+const find_cloudwatch_logs_1 = require("../api/logs/find-cloudwatch-logs");
+const logs_monitor_1 = require("../api/logs/logs-monitor");
+const tags_1 = require("../api/tags");
+const stack_activity_monitor_1 = require("../api/util/cloudformation/stack-activity-monitor");
+const string_manipulation_1 = require("../api/util/string-manipulation");
+const migrate_1 = require("../commands/migrate");
+const diff_1 = require("../diff");
+const import_1 = require("../import");
+const list_stacks_1 = require("../list-stacks");
+const logging_1 = require("../logging");
+const migrator_1 = require("../migrator");
+const serialize_1 = require("../serialize");
+const cli_io_host_1 = require("../toolkit/cli-io-host");
+const error_1 = require("../toolkit/error");
+const util_2 = require("../util");
+const error_2 = require("../util/error");
+const validate_notification_arn_1 = require("../util/validate-notification-arn");
+const work_graph_builder_1 = require("../util/work-graph-builder");
+// Must use a require() otherwise esbuild complains about calling a namespace
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const pLimit = require('p-limit');
+let TESTING = false;
+function markTesting() {
+    TESTING = true;
+}
+/**
+ * When to build assets
+ */
+var AssetBuildTime;
+(function (AssetBuildTime) {
+    /**
+     * Build all assets before deploying the first stack
+     *
+     * This is intended for expensive Docker image builds; so that if the Docker image build
+     * fails, no stacks are unnecessarily deployed (with the attendant wait time).
+     */
+    AssetBuildTime[AssetBuildTime["ALL_BEFORE_DEPLOY"] = 0] = "ALL_BEFORE_DEPLOY";
+    /**
+     * Build assets just-in-time, before publishing
+     */
+    AssetBuildTime[AssetBuildTime["JUST_IN_TIME"] = 1] = "JUST_IN_TIME";
+})(AssetBuildTime || (exports.AssetBuildTime = AssetBuildTime = {}));
+/**
+ * Toolkit logic
+ *
+ * The toolkit runs the `cloudExecutable` to obtain a cloud assembly and
+ * deploys applies them to `cloudFormation`.
+ */
+class CdkToolkit {
+    constructor(props) {
+        var _a;
+        this.props = props;
+        this.ioHost = (_a = props.ioHost) !== null && _a !== void 0 ? _a : cli_io_host_1.CliIoHost.instance();
+    }
+    async metadata(stackName, json) {
+        var _a;
+        const stacks = await this.selectSingleStackByName(stackName);
+        printSerializedObject((_a = stacks.firstStack.manifest.metadata) !== null && _a !== void 0 ? _a : {}, json);
+    }
+    async acknowledge(noticeId) {
+        var _a;
+        const acks = (_a = this.props.configuration.context.get('acknowledged-issue-numbers')) !== null && _a !== void 0 ? _a : [];
+        acks.push(Number(noticeId));
+        this.props.configuration.context.set('acknowledged-issue-numbers', acks);
+        await this.props.configuration.saveContext();
+    }
+    async diff(options) {
+        const stacks = await this.selectStacksForDiff(options.stackNames, options.exclusively);
+        const strict = !!options.strict;
+        const contextLines = options.contextLines || 3;
+        const stream = options.stream || process.stderr;
+        const quiet = options.quiet || false;
+        let diffs = 0;
+        const parameterMap = buildParameterMap(options.parameters);
+        if (options.templatePath !== undefined) {
+            // Compare single stack against fixed template
+            if (stacks.stackCount !== 1) {
+                throw new error_1.ToolkitError('Can only select one stack when comparing to fixed template. Use --exclusively to avoid selecting multiple stacks.');
+            }
+            if (!(await fs.pathExists(options.templatePath))) {
+                throw new error_1.ToolkitError(`There is no file at ${options.templatePath}`);
+            }
+            const template = (0, serialize_1.deserializeStructure)(await fs.readFile(options.templatePath, { encoding: 'UTF-8' }));
+            diffs = options.securityOnly
+                ? (0, util_2.numberFromBool)((0, diff_1.printSecurityDiff)(template, stacks.firstStack, diff_1.RequireApproval.Broadening, quiet))
+                : (0, diff_1.printStackDiff)(template, stacks.firstStack, strict, contextLines, quiet, undefined, undefined, false, stream);
+        }
+        else {
+            // Compare N stacks against deployed templates
+            for (const stack of stacks.stackArtifacts) {
+                const templateWithNestedStacks = await this.props.deployments.readCurrentTemplateWithNestedStacks(stack, options.compareAgainstProcessedTemplate);
+                const currentTemplate = templateWithNestedStacks.deployedRootTemplate;
+                const nestedStacks = templateWithNestedStacks.nestedStacks;
+                const migrator = new migrator_1.ResourceMigrator({
+                    deployments: this.props.deployments,
+                });
+                const resourcesToImport = await migrator.tryGetResources(await this.props.deployments.resolveEnvironment(stack));
+                if (resourcesToImport) {
+                    (0, import_1.removeNonImportResources)(stack);
+                }
+                let changeSet = undefined;
+                if (options.changeSet) {
+                    let stackExists = false;
+                    try {
+                        stackExists = await this.props.deployments.stackExists({
+                            stack,
+                            deployName: stack.stackName,
+                            tryLookupRole: true,
+                        });
+                    }
+                    catch (e) {
+                        (0, logging_1.debug)((0, error_2.formatErrorMessage)(e));
+                        if (!quiet) {
+                            stream.write(`Checking if the stack ${stack.stackName} exists before creating the changeset has failed, will base the diff on template differences (run again with -v to see the reason)\n`);
+                        }
+                        stackExists = false;
+                    }
+                    if (stackExists) {
+                        changeSet = await (0, deployments_1.createDiffChangeSet)({
+                            stack,
+                            uuid: uuid.v4(),
+                            deployments: this.props.deployments,
+                            willExecute: false,
+                            sdkProvider: this.props.sdkProvider,
+                            parameters: Object.assign({}, parameterMap['*'], parameterMap[stack.stackName]),
+                            resourcesToImport,
+                            stream,
+                        });
+                    }
+                    else {
+                        (0, logging_1.debug)(`the stack '${stack.stackName}' has not been deployed to CloudFormation or describeStacks call failed, skipping changeset creation.`);
+                    }
+                }
+                const stackCount = options.securityOnly
+                    ? (0, util_2.numberFromBool)((0, diff_1.printSecurityDiff)(currentTemplate, stack, diff_1.RequireApproval.Broadening, quiet, stack.displayName, changeSet))
+                    : (0, diff_1.printStackDiff)(currentTemplate, stack, strict, contextLines, quiet, stack.displayName, changeSet, !!resourcesToImport, stream, nestedStacks);
+                diffs += stackCount;
+            }
+        }
+        stream.write((0, util_1.format)('\n✨  Number of stacks with differences: %s\n', diffs));
+        return diffs && options.fail ? 1 : 0;
+    }
+    async deploy(options) {
+        var _a, _b, _c, _d, _e;
+        if (options.watch) {
+            return this.watch(options);
+        }
+        const startSynthTime = new Date().getTime();
+        const stackCollection = await this.selectStacksForDeploy(options.selector, options.exclusively, options.cacheCloudAssembly, options.ignoreNoStacks);
+        const elapsedSynthTime = new Date().getTime() - startSynthTime;
+        (0, logging_1.info)(`\n✨  Synthesis time: ${(0, string_manipulation_1.formatTime)(elapsedSynthTime)}s\n`);
+        if (stackCollection.stackCount === 0) {
+            (0, logging_1.error)('This app contains no stacks');
+            return;
+        }
+        const migrator = new migrator_1.ResourceMigrator({
+            deployments: this.props.deployments,
+        });
+        await migrator.tryMigrateResources(stackCollection, options);
+        const requireApproval = (_a = options.requireApproval) !== null && _a !== void 0 ? _a : diff_1.RequireApproval.Broadening;
+        const parameterMap = buildParameterMap(options.parameters);
+        if (options.hotswap !== common_1.HotswapMode.FULL_DEPLOYMENT) {
+            (0, logging_1.warning)('⚠️ The --hotswap and --hotswap-fallback flags deliberately introduce CloudFormation drift to speed up deployments');
+            (0, logging_1.warning)('⚠️ They should only be used for development - never use them for your production Stacks!\n');
+        }
+        let hotswapPropertiesFromSettings = this.props.configuration.settings.get(['hotswap']) || {};
+        let hotswapPropertyOverrides = new common_1.HotswapPropertyOverrides();
+        hotswapPropertyOverrides.ecsHotswapProperties = new common_1.EcsHotswapProperties((_b = hotswapPropertiesFromSettings.ecs) === null || _b === void 0 ? void 0 : _b.minimumHealthyPercent, (_c = hotswapPropertiesFromSettings.ecs) === null || _c === void 0 ? void 0 : _c.maximumHealthyPercent);
+        const stacks = stackCollection.stackArtifacts;
+        const stackOutputs = {};
+        const outputsFile = options.outputsFile;
+        const buildAsset = async (assetNode) => {
+            await this.props.deployments.buildSingleAsset(assetNode.assetManifestArtifact, assetNode.assetManifest, assetNode.asset, {
+                stack: assetNode.parentStack,
+                roleArn: options.roleArn,
+                stackName: assetNode.parentStack.stackName,
+            });
+        };
+        const publishAsset = async (assetNode) => {
+            await this.props.deployments.publishSingleAsset(assetNode.assetManifest, assetNode.asset, {
+                stack: assetNode.parentStack,
+                roleArn: options.roleArn,
+                stackName: assetNode.parentStack.stackName,
+            });
+        };
+        const deployStack = async (stackNode) => {
+            var _a, _b;
+            const stack = stackNode.stack;
+            if (stackCollection.stackCount !== 1) {
+                (0, logging_1.highlight)(stack.displayName);
+            }
+            if (!stack.environment) {
+                // eslint-disable-next-line max-len
+                throw new error_1.ToolkitError(`Stack ${stack.displayName} does not define an environment, and AWS credentials could not be obtained from standard locations or no region was configured.`);
+            }
+            if (Object.keys(stack.template.Resources || {}).length === 0) {
+                // The generated stack has no resources
+                if (!(await this.props.deployments.stackExists({ stack }))) {
+                    (0, logging_1.warning)('%s: stack has no resources, skipping deployment.', chalk.bold(stack.displayName));
+                }
+                else {
+                    (0, logging_1.warning)('%s: stack has no resources, deleting existing stack.', chalk.bold(stack.displayName));
+                    await this.destroy({
+                        selector: { patterns: [stack.hierarchicalId] },
+                        exclusively: true,
+                        force: true,
+                        roleArn: options.roleArn,
+                        fromDeploy: true,
+                        ci: options.ci,
+                    });
+                }
+                return;
+            }
+            if (requireApproval !== diff_1.RequireApproval.Never) {
+                const currentTemplate = await this.props.deployments.readCurrentTemplate(stack);
+                if ((0, diff_1.printSecurityDiff)(currentTemplate, stack, requireApproval)) {
+                    await askUserConfirmation(this.ioHost, concurrency, '"--require-approval" is enabled and stack includes security-sensitive updates', 'Do you wish to deploy these changes');
+                }
+            }
+            // Following are the same semantics we apply with respect to Notification ARNs (dictated by the SDK)
+            //
+            //  - undefined  =>  cdk ignores it, as if it wasn't supported (allows external management).
+            //  - []:        =>  cdk manages it, and the user wants to wipe it out.
+            //  - ['arn-1']  =>  cdk manages it, and the user wants to set it to ['arn-1'].
+            const notificationArns = (!!options.notificationArns || !!stack.notificationArns)
+                ? ((_a = options.notificationArns) !== null && _a !== void 0 ? _a : []).concat((_b = stack.notificationArns) !== null && _b !== void 0 ? _b : [])
+                : undefined;
+            for (const notificationArn of notificationArns !== null && notificationArns !== void 0 ? notificationArns : []) {
+                if (!(0, validate_notification_arn_1.validateSnsTopicArn)(notificationArn)) {
+                    throw new error_1.ToolkitError(`Notification arn ${notificationArn} is not a valid arn for an SNS topic`);
+                }
+            }
+            const stackIndex = stacks.indexOf(stack) + 1;
+            (0, logging_1.info)(`${chalk.bold(stack.displayName)}: deploying... [${stackIndex}/${stackCollection.stackCount}]`);
+            const startDeployTime = new Date().getTime();
+            let tags = options.tags;
+            if (!tags || tags.length === 0) {
+                tags = (0, tags_1.tagsForStack)(stack);
+            }
+            let elapsedDeployTime = 0;
+            try {
+                let deployResult;
+                let rollback = options.rollback;
+                let iteration = 0;
+                while (!deployResult) {
+                    if (++iteration > 2) {
+                        throw new error_1.ToolkitError('This loop should have stabilized in 2 iterations, but didn\'t. If you are seeing this error, please report it at https://github.com/aws/aws-cdk/issues/new/choose');
+                    }
+                    const r = await this.props.deployments.deployStack({
+                        stack,
+                        deployName: stack.stackName,
+                        roleArn: options.roleArn,
+                        toolkitStackName: options.toolkitStackName,
+                        reuseAssets: options.reuseAssets,
+                        notificationArns,
+                        tags,
+                        execute: options.execute,
+                        changeSetName: options.changeSetName,
+                        deploymentMethod: options.deploymentMethod,
+                        force: options.force,
+                        parameters: Object.assign({}, parameterMap['*'], parameterMap[stack.stackName]),
+                        usePreviousParameters: options.usePreviousParameters,
+                        progress,
+                        ci: options.ci,
+                        rollback,
+                        hotswap: options.hotswap,
+                        hotswapPropertyOverrides: hotswapPropertyOverrides,
+                        extraUserAgent: options.extraUserAgent,
+                        assetParallelism: options.assetParallelism,
+                        ignoreNoStacks: options.ignoreNoStacks,
+                    });
+                    switch (r.type) {
+                        case 'did-deploy-stack':
+                            deployResult = r;
+                            break;
+                        case 'failpaused-need-rollback-first': {
+                            const motivation = r.reason === 'replacement'
+                                ? `Stack is in a paused fail state (${r.status}) and change includes a replacement which cannot be deployed with "--no-rollback"`
+                                : `Stack is in a paused fail state (${r.status}) and command line arguments do not include "--no-rollback"`;
+                            if (options.force) {
+                                (0, logging_1.warning)(`${motivation}. Rolling back first (--force).`);
+                            }
+                            else {
+                                await askUserConfirmation(this.ioHost, concurrency, motivation, `${motivation}. Roll back first and then proceed with deployment`);
+                            }
+                            // Perform a rollback
+                            await this.rollback({
+                                selector: { patterns: [stack.hierarchicalId] },
+                                toolkitStackName: options.toolkitStackName,
+                                force: options.force,
+                            });
+                            // Go around through the 'while' loop again but switch rollback to true.
+                            rollback = true;
+                            break;
+                        }
+                        case 'replacement-requires-rollback': {
+                            const motivation = 'Change includes a replacement which cannot be deployed with "--no-rollback"';
+                            if (options.force) {
+                                (0, logging_1.warning)(`${motivation}. Proceeding with regular deployment (--force).`);
+                            }
+                            else {
+                                await askUserConfirmation(this.ioHost, concurrency, motivation, `${motivation}. Perform a regular deployment`);
+                            }
+                            // Go around through the 'while' loop again but switch rollback to true.
+                            rollback = true;
+                            break;
+                        }
+                        default:
+                            throw new error_1.ToolkitError(`Unexpected result type from deployStack: ${JSON.stringify(r)}. If you are seeing this error, please report it at https://github.com/aws/aws-cdk/issues/new/choose`);
+                    }
+                }
+                const message = deployResult.noOp
+                    ? ' ✅  %s (no changes)'
+                    : ' ✅  %s';
+                (0, logging_1.success)('\n' + message, stack.displayName);
+                elapsedDeployTime = new Date().getTime() - startDeployTime;
+                (0, logging_1.info)(`\n✨  Deployment time: ${(0, string_manipulation_1.formatTime)(elapsedDeployTime)}s\n`);
+                if (Object.keys(deployResult.outputs).length > 0) {
+                    (0, logging_1.info)('Outputs:');
+                    stackOutputs[stack.stackName] = deployResult.outputs;
+                }
+                for (const name of Object.keys(deployResult.outputs).sort()) {
+                    const value = deployResult.outputs[name];
+                    (0, logging_1.info)(`${chalk.cyan(stack.id)}.${chalk.cyan(name)} = ${chalk.underline(chalk.cyan(value))}`);
+                }
+                (0, logging_1.info)('Stack ARN:');
+                (0, logging_1.result)(deployResult.stackArn);
+            }
+            catch (e) {
+                // It has to be exactly this string because an integration test tests for
+                // "bold(stackname) failed: ResourceNotReady: <error>"
+                throw new error_1.ToolkitError([`❌  ${chalk.bold(stack.stackName)} failed:`, ...(e.name ? [`${e.name}:`] : []), (0, error_2.formatErrorMessage)(e)].join(' '));
+            }
+            finally {
+                if (options.cloudWatchLogMonitor) {
+                    const foundLogGroupsResult = await (0, find_cloudwatch_logs_1.findCloudWatchLogGroups)(this.props.sdkProvider, stack);
+                    options.cloudWatchLogMonitor.addLogGroups(foundLogGroupsResult.env, foundLogGroupsResult.sdk, foundLogGroupsResult.logGroupNames);
+                }
+                // If an outputs file has been specified, create the file path and write stack outputs to it once.
+                // Outputs are written after all stacks have been deployed. If a stack deployment fails,
+                // all of the outputs from successfully deployed stacks before the failure will still be written.
+                if (outputsFile) {
+                    fs.ensureFileSync(outputsFile);
+                    await fs.writeJson(outputsFile, stackOutputs, {
+                        spaces: 2,
+                        encoding: 'utf8',
+                    });
+                }
+            }
+            (0, logging_1.info)(`\n✨  Total time: ${(0, string_manipulation_1.formatTime)(elapsedSynthTime + elapsedDeployTime)}s\n`);
+        };
+        const assetBuildTime = (_d = options.assetBuildTime) !== null && _d !== void 0 ? _d : AssetBuildTime.ALL_BEFORE_DEPLOY;
+        const prebuildAssets = assetBuildTime === AssetBuildTime.ALL_BEFORE_DEPLOY;
+        const concurrency = options.concurrency || 1;
+        const progress = concurrency > 1 ? stack_activity_monitor_1.StackActivityProgress.EVENTS : options.progress;
+        if (concurrency > 1 && options.progress && options.progress != stack_activity_monitor_1.StackActivityProgress.EVENTS) {
+            (0, logging_1.warning)('⚠️ The --concurrency flag only supports --progress "events". Switching to "events".');
+        }
+        const stacksAndTheirAssetManifests = stacks.flatMap((stack) => [
+            stack,
+            ...stack.dependencies.filter(cxapi.AssetManifestArtifact.isAssetManifestArtifact),
+        ]);
+        const workGraph = new work_graph_builder_1.WorkGraphBuilder(prebuildAssets).build(stacksAndTheirAssetManifests);
+        // Unless we are running with '--force', skip already published assets
+        if (!options.force) {
+            await this.removePublishedAssets(workGraph, options);
+        }
+        const graphConcurrency = {
+            'stack': concurrency,
+            'asset-build': 1, // This will be CPU-bound/memory bound, mostly matters for Docker builds
+            'asset-publish': ((_e = options.assetParallelism) !== null && _e !== void 0 ? _e : true) ? 8 : 1, // This will be I/O-bound, 8 in parallel seems reasonable
+        };
+        await workGraph.doParallel(graphConcurrency, {
+            deployStack,
+            buildAsset,
+            publishAsset,
+        });
+    }
+    /**
+     * Roll back the given stack or stacks.
+     */
+    async rollback(options) {
+        const startSynthTime = new Date().getTime();
+        const stackCollection = await this.selectStacksForDeploy(options.selector, true);
+        const elapsedSynthTime = new Date().getTime() - startSynthTime;
+        (0, logging_1.info)(`\n✨  Synthesis time: ${(0, string_manipulation_1.formatTime)(elapsedSynthTime)}s\n`);
+        if (stackCollection.stackCount === 0) {
+            (0, logging_1.error)('No stacks selected');
+            return;
+        }
+        let anyRollbackable = false;
+        for (const stack of stackCollection.stackArtifacts) {
+            (0, logging_1.info)('Rolling back %s', chalk.bold(stack.displayName));
+            const startRollbackTime = new Date().getTime();
+            try {
+                const result = await this.props.deployments.rollbackStack({
+                    stack,
+                    roleArn: options.roleArn,
+                    toolkitStackName: options.toolkitStackName,
+                    force: options.force,
+                    validateBootstrapStackVersion: options.validateBootstrapStackVersion,
+                    orphanLogicalIds: options.orphanLogicalIds,
+                });
+                if (!result.notInRollbackableState) {
+                    anyRollbackable = true;
+                }
+                const elapsedRollbackTime = new Date().getTime() - startRollbackTime;
+                (0, logging_1.info)(`\n✨  Rollback time: ${(0, string_manipulation_1.formatTime)(elapsedRollbackTime).toString()}s\n`);
+            }
+            catch (e) {
+                (0, logging_1.error)('\n ❌  %s failed: %s', chalk.bold(stack.displayName), (0, error_2.formatErrorMessage)(e));
+                throw new error_1.ToolkitError('Rollback failed (use --force to orphan failing resources)');
+            }
+        }
+        if (!anyRollbackable) {
+            throw new error_1.ToolkitError('No stacks were in a state that could be rolled back');
+        }
+    }
+    async watch(options) {
+        const rootDir = path.dirname(path.resolve(user_configuration_1.PROJECT_CONFIG));
+        (0, logging_1.debug)("root directory used for 'watch' is: %s", rootDir);
+        const watchSettings = this.props.configuration.settings.get(['watch']);
+        if (!watchSettings) {
+            throw new error_1.ToolkitError("Cannot use the 'watch' command without specifying at least one directory to monitor. " +
+                'Make sure to add a "watch" key to your cdk.json');
+        }
+        // For the "include" subkey under the "watch" key, the behavior is:
+        // 1. No "watch" setting? We error out.
+        // 2. "watch" setting without an "include" key? We default to observing "./**".
+        // 3. "watch" setting with an empty "include" key? We default to observing "./**".
+        // 4. Non-empty "include" key? Just use the "include" key.
+        const watchIncludes = this.patternsArrayForWatch(watchSettings.include, {
+            rootDir,
+            returnRootDirIfEmpty: true,
+        });
+        (0, logging_1.debug)("'include' patterns for 'watch': %s", watchIncludes);
+        // For the "exclude" subkey under the "watch" key,
+        // the behavior is to add some default excludes in addition to the ones specified by the user:
+        // 1. The CDK output directory.
+        // 2. Any file whose name starts with a dot.
+        // 3. Any directory's content whose name starts with a dot.
+        // 4. Any node_modules and its content (even if it's not a JS/TS project, you might be using a local aws-cli package)
+        const outputDir = this.props.configuration.settings.get(['output']);
+        const watchExcludes = this.patternsArrayForWatch(watchSettings.exclude, {
+            rootDir,
+            returnRootDirIfEmpty: false,
+        }).concat(`${outputDir}/**`, '**/.*', '**/.*/**', '**/node_modules/**');
+        (0, logging_1.debug)("'exclude' patterns for 'watch': %s", watchExcludes);
+        // Since 'cdk deploy' is a relatively slow operation for a 'watch' process,
+        // introduce a concurrency latch that tracks the state.
+        // This way, if file change events arrive when a 'cdk deploy' is still executing,
+        // we will batch them, and trigger another 'cdk deploy' after the current one finishes,
+        // making sure 'cdk deploy's  always execute one at a time.
+        // Here's a diagram showing the state transitions:
+        // --------------                --------    file changed     --------------    file changed     --------------  file changed
+        // |            |  ready event   |      | ------------------> |            | ------------------> |            | --------------|
+        // | pre-ready  | -------------> | open |                     | deploying  |                     |   queued   |               |
+        // |            |                |      | <------------------ |            | <------------------ |            | <-------------|
+        // --------------                --------  'cdk deploy' done  --------------  'cdk deploy' done  --------------
+        let latch = 'pre-ready';
+        const cloudWatchLogMonitor = options.traceLogs ? new logs_monitor_1.CloudWatchLogEventMonitor() : undefined;
+        const deployAndWatch = async () => {
+            latch = 'deploying';
+            cloudWatchLogMonitor === null || cloudWatchLogMonitor === void 0 ? void 0 : cloudWatchLogMonitor.deactivate();
+            await this.invokeDeployFromWatch(options, cloudWatchLogMonitor);
+            // If latch is still 'deploying' after the 'await', that's fine,
+            // but if it's 'queued', that means we need to deploy again
+            while (latch === 'queued') {
+                // TypeScript doesn't realize latch can change between 'awaits',
+                // and thinks the above 'while' condition is always 'false' without the cast
+                latch = 'deploying';
+                (0, logging_1.info)("Detected file changes during deployment. Invoking 'cdk deploy' again");
+                await this.invokeDeployFromWatch(options, cloudWatchLogMonitor);
+            }
+            latch = 'open';
+            cloudWatchLogMonitor === null || cloudWatchLogMonitor === void 0 ? void 0 : cloudWatchLogMonitor.activate();
+        };
+        chokidar
+            .watch(watchIncludes, {
+            ignored: watchExcludes,
+            cwd: rootDir,
+        })
+            .on('ready', async () => {
+            latch = 'open';
+            (0, logging_1.debug)("'watch' received the 'ready' event. From now on, all file changes will trigger a deployment");
+            (0, logging_1.info)("Triggering initial 'cdk deploy'");
+            await deployAndWatch();
+        })
+            .on('all', async (event, filePath) => {
+            if (latch === 'pre-ready') {
+                (0, logging_1.info)(`'watch' is observing ${event === 'addDir' ? 'directory' : 'the file'} '%s' for changes`, filePath);
+            }
+            else if (latch === 'open') {
+                (0, logging_1.info)("Detected change to '%s' (type: %s). Triggering 'cdk deploy'", filePath, event);
+                await deployAndWatch();
+            }
+            else {
+                // this means latch is either 'deploying' or 'queued'
+                latch = 'queued';
+                (0, logging_1.info)("Detected change to '%s' (type: %s) while 'cdk deploy' is still running. " +
+                    'Will queue for another deployment after this one finishes', filePath, event);
+            }
+        });
+    }
+    async import(options) {
+        const stacks = await this.selectStacksForDeploy(options.selector, true, true, false);
+        if (stacks.stackCount > 1) {
+            throw new error_1.ToolkitError(`Stack selection is ambiguous, please choose a specific stack for import [${stacks.stackArtifacts.map((x) => x.id).join(', ')}]`);
+        }
+        if (!process.stdout.isTTY && !options.resourceMappingFile) {
+            throw new error_1.ToolkitError('--resource-mapping is required when input is not a terminal');
+        }
+        const stack = stacks.stackArtifacts[0];
+        (0, logging_1.highlight)(stack.displayName);
+        const resourceImporter = new import_1.ResourceImporter(stack, this.props.deployments);
+        const { additions, hasNonAdditions } = await resourceImporter.discoverImportableResources(options.force);
+        if (additions.length === 0) {
+            (0, logging_1.warning)('%s: no new resources compared to the currently deployed stack, skipping import.', chalk.bold(stack.displayName));
+            return;
+        }
+        // Prepare a mapping of physical resources to CDK constructs
+        const actualImport = !options.resourceMappingFile
+            ? await resourceImporter.askForResourceIdentifiers(additions)
+            : await resourceImporter.loadResourceIdentifiers(additions, options.resourceMappingFile);
+        if (actualImport.importResources.length === 0) {
+            (0, logging_1.warning)('No resources selected for import.');
+            return;
+        }
+        // If "--create-resource-mapping" option was passed, write the resource mapping to the given file and exit
+        if (options.recordResourceMapping) {
+            const outputFile = options.recordResourceMapping;
+            fs.ensureFileSync(outputFile);
+            await fs.writeJson(outputFile, actualImport.resourceMap, {
+                spaces: 2,
+                encoding: 'utf8',
+            });
+            (0, logging_1.info)('%s: mapping file written.', outputFile);
+            return;
+        }
+        // Import the resources according to the given mapping
+        (0, logging_1.info)('%s: importing resources into stack...', chalk.bold(stack.displayName));
+        const tags = (0, tags_1.tagsForStack)(stack);
+        await resourceImporter.importResourcesFromMap(actualImport, {
+            roleArn: options.roleArn,
+            toolkitStackName: options.toolkitStackName,
+            tags,
+            deploymentMethod: options.deploymentMethod,
+            usePreviousParameters: true,
+            progress: options.progress,
+            rollback: options.rollback,
+        });
+        // Notify user of next steps
+        (0, logging_1.info)(`Import operation complete. We recommend you run a ${chalk.blueBright('drift detection')} operation ` +
+            'to confirm your CDK app resource definitions are up-to-date. Read more here: ' +
+            chalk.underline.blueBright('https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/detect-drift-stack.html'));
+        if (actualImport.importResources.length < additions.length) {
+            (0, logging_1.info)('');
+            (0, logging_1.warning)(`Some resources were skipped. Run another ${chalk.blueBright('cdk import')} or a ${chalk.blueBright('cdk deploy')} to bring the stack up-to-date with your CDK app definition.`);
+        }
+        else if (hasNonAdditions) {
+            (0, logging_1.info)('');
+            (0, logging_1.warning)(`Your app has pending updates or deletes excluded from this import operation. Run a ${chalk.blueBright('cdk deploy')} to bring the stack up-to-date with your CDK app definition.`);
+        }
+    }
+    async destroy(options) {
+        let stacks = await this.selectStacksForDestroy(options.selector, options.exclusively);
+        // The stacks will have been ordered for deployment, so reverse them for deletion.
+        stacks = stacks.reversed();
+        if (!options.force) {
+            // eslint-disable-next-line max-len
+            const confirmed = await promptly.confirm(`Are you sure you want to delete: ${chalk.blue(stacks.stackArtifacts.map((s) => s.hierarchicalId).join(', '))} (y/n)?`);
+            if (!confirmed) {
+                return;
+            }
+        }
+        const action = options.fromDeploy ? 'deploy' : 'destroy';
+        for (const [index, stack] of stacks.stackArtifacts.entries()) {
+            (0, logging_1.success)('%s: destroying... [%s/%s]', chalk.blue(stack.displayName), index + 1, stacks.stackCount);
+            try {
+                await this.props.deployments.destroyStack({
+                    stack,
+                    deployName: stack.stackName,
+                    roleArn: options.roleArn,
+                    ci: options.ci,
+                });
+                (0, logging_1.success)(`\n ✅  %s: ${action}ed`, chalk.blue(stack.displayName));
+            }
+            catch (e) {
+                (0, logging_1.error)(`\n ❌  %s: ${action} failed`, chalk.blue(stack.displayName), e);
+                throw e;
+            }
+        }
+    }
+    async list(selectors, options = {}) {
+        var _a, _b, _c;
+        const stacks = await (0, list_stacks_1.listStacks)(this, {
+            selectors: selectors,
+        });
+        if (options.long && options.showDeps) {
+            printSerializedObject(stacks, (_a = options.json) !== null && _a !== void 0 ? _a : false);
+            return 0;
+        }
+        if (options.showDeps) {
+            const stackDeps = [];
+            for (const stack of stacks) {
+                stackDeps.push({
+                    id: stack.id,
+                    dependencies: stack.dependencies,
+                });
+            }
+            printSerializedObject(stackDeps, (_b = options.json) !== null && _b !== void 0 ? _b : false);
+            return 0;
+        }
+        if (options.long) {
+            const long = [];
+            for (const stack of stacks) {
+                long.push({
+                    id: stack.id,
+                    name: stack.name,
+                    environment: stack.environment,
+                });
+            }
+            printSerializedObject(long, (_c = options.json) !== null && _c !== void 0 ? _c : false);
+            return 0;
+        }
+        // just print stack IDs
+        for (const stack of stacks) {
+            (0, logging_1.result)(stack.id);
+        }
+        return 0; // exit-code
+    }
+    /**
+     * Synthesize the given set of stacks (called when the user runs 'cdk synth')
+     *
+     * INPUT: Stack names can be supplied using a glob filter. If no stacks are
+     * given, all stacks from the application are implicitly selected.
+     *
+     * OUTPUT: If more than one stack ends up being selected, an output directory
+     * should be supplied, where the templates will be written.
+     */
+    async synth(stackNames, exclusively, quiet, autoValidate, json) {
+        const stacks = await this.selectStacksForDiff(stackNames, exclusively, autoValidate);
+        // if we have a single stack, print it to STDOUT
+        if (stacks.stackCount === 1) {
+            if (!quiet) {
+                printSerializedObject((0, serialize_1.obscureTemplate)(stacks.firstStack.template), json !== null && json !== void 0 ? json : false);
+            }
+            return undefined;
+        }
+        // not outputting template to stdout, let's explain things to the user a little bit...
+        (0, logging_1.success)(`Successfully synthesized to ${chalk.blue(path.resolve(stacks.assembly.directory))}`);
+        (0, logging_1.info)(`Supply a stack id (${stacks.stackArtifacts.map((s) => chalk.green(s.hierarchicalId)).join(', ')}) to display its template.`);
+        return undefined;
+    }
+    /**
+     * Bootstrap the CDK Toolkit stack in the accounts used by the specified stack(s).
+     *
+     * @param userEnvironmentSpecs environment names that need to have toolkit support
+     *             provisioned, as a glob filter. If none is provided, all stacks are implicitly selected.
+     * @param options The name, role ARN, bootstrapping parameters, etc. to be used for the CDK Toolkit stack.
+     */
+    async bootstrap(userEnvironmentSpecs, options) {
+        const bootstrapper = new bootstrap_1.Bootstrapper(options.source);
+        // If there is an '--app' argument and an environment looks like a glob, we
+        // select the environments from the app. Otherwise, use what the user said.
+        const environments = await this.defineEnvironments(userEnvironmentSpecs);
+        const limit = pLimit(20);
+        // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
+        await Promise.all(environments.map((environment) => limit(async () => {
+            (0, logging_1.success)(' ⏳  Bootstrapping environment %s...', chalk.blue(environment.name));
+            try {
+                const result = await bootstrapper.bootstrapEnvironment(environment, this.props.sdkProvider, options);
+                const message = result.noOp
+                    ? ' ✅  Environment %s bootstrapped (no changes).'
+                    : ' ✅  Environment %s bootstrapped.';
+                (0, logging_1.success)(message, chalk.blue(environment.name));
+            }
+            catch (e) {
+                (0, logging_1.error)(' ❌  Environment %s failed bootstrapping: %s', chalk.blue(environment.name), e);
+                throw e;
+            }
+        })));
+    }
+    /**
+     * Garbage collects assets from a CDK app's environment
+     * @param options Options for Garbage Collection
+     */
+    async garbageCollect(userEnvironmentSpecs, options) {
+        var _a, _b, _c;
+        const environments = await this.defineEnvironments(userEnvironmentSpecs);
+        for (const environment of environments) {
+            (0, logging_1.success)(' ⏳  Garbage Collecting environment %s...', chalk.blue(environment.name));
+            const gc = new garbage_collector_1.GarbageCollector({
+                sdkProvider: this.props.sdkProvider,
+                resolvedEnvironment: environment,
+                bootstrapStackName: options.bootstrapStackName,
+                rollbackBufferDays: options.rollbackBufferDays,
+                createdBufferDays: options.createdBufferDays,
+                action: (_a = options.action) !== null && _a !== void 0 ? _a : 'full',
+                type: (_b = options.type) !== null && _b !== void 0 ? _b : 'all',
+                confirm: (_c = options.confirm) !== null && _c !== void 0 ? _c : true,
+            });
+            await gc.garbageCollect();
+        }
+        ;
+    }
+    async defineEnvironments(userEnvironmentSpecs) {
+        // By default, glob for everything
+        const environmentSpecs = userEnvironmentSpecs.length > 0 ? [...userEnvironmentSpecs] : ['**'];
+        // Partition into globs and non-globs (this will mutate environmentSpecs).
+        const globSpecs = (0, util_2.partition)(environmentSpecs, environments_1.looksLikeGlob);
+        if (globSpecs.length > 0 && !this.props.cloudExecutable.hasApp) {
+            if (userEnvironmentSpecs.length > 0) {
+                // User did request this glob
+                throw new error_1.ToolkitError(`'${globSpecs}' is not an environment name. Specify an environment name like 'aws://123456789012/us-east-1', or run in a directory with 'cdk.json' to use wildcards.`);
+            }
+            else {
+                // User did not request anything
+                throw new error_1.ToolkitError("Specify an environment name like 'aws://123456789012/us-east-1', or run in a directory with 'cdk.json'.");
+            }
+        }
+        const environments = [...(0, environments_1.environmentsFromDescriptors)(environmentSpecs)];
+        // If there is an '--app' argument, select the environments from the app.
+        if (this.props.cloudExecutable.hasApp) {
+            environments.push(...(await (0, environments_1.globEnvironmentsFromStacks)(await this.selectStacksForList([]), globSpecs, this.props.sdkProvider)));
+        }
+        return environments;
+    }
+    /**
+     * Migrates a CloudFormation stack/template to a CDK app
+     * @param options Options for CDK app creation
+     */
+    async migrate(options) {
+        var _a, _b, _c, _d, _e;
+        (0, logging_1.warning)('This command is an experimental feature.');
+        const language = (_b = (_a = options.language) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : 'typescript';
+        const environment = (0, migrate_1.setEnvironment)(options.account, options.region);
+        let generateTemplateOutput;
+        let cfn;
+        let templateToDelete;
+        try {
+            // if neither fromPath nor fromStack is provided, generate a template using cloudformation
+            const scanType = (0, migrate_1.parseSourceOptions)(options.fromPath, options.fromStack, options.stackName).source;
+            if (scanType == migrate_1.TemplateSourceOptions.SCAN) {
+                generateTemplateOutput = await (0, migrate_1.generateTemplate)({
+                    stackName: options.stackName,
+                    filters: options.filter,
+                    fromScan: options.fromScan,
+                    sdkProvider: this.props.sdkProvider,
+                    environment: environment,
+                });
+                templateToDelete = generateTemplateOutput.templateId;
+            }
+            else if (scanType == migrate_1.TemplateSourceOptions.PATH) {
+                const templateBody = (0, migrate_1.readFromPath)(options.fromPath);
+                const parsedTemplate = (0, serialize_1.deserializeStructure)(templateBody);
+                const templateId = (_d = (_c = parsedTemplate.Metadata) === null || _c === void 0 ? void 0 : _c.TemplateId) === null || _d === void 0 ? void 0 : _d.toString();
+                if (templateId) {
+                    // if we have a template id, we can call describe generated template to get the resource identifiers
+                    // resource metadata, and template source to generate the template
+                    cfn = new migrate_1.CfnTemplateGeneratorProvider(await (0, migrate_1.buildCfnClient)(this.props.sdkProvider, environment));
+                    const generatedTemplateSummary = await cfn.describeGeneratedTemplate(templateId);
+                    generateTemplateOutput = (0, migrate_1.buildGenertedTemplateOutput)(generatedTemplateSummary, templateBody, generatedTemplateSummary.GeneratedTemplateId);
+                }
+                else {
+                    generateTemplateOutput = {
+                        migrateJson: {
+                            templateBody: templateBody,
+                            source: 'localfile',
+                        },
+                    };
+                }
+            }
+            else if (scanType == migrate_1.TemplateSourceOptions.STACK) {
+                const template = await (0, migrate_1.readFromStack)(options.stackName, this.props.sdkProvider, environment);
+                if (!template) {
+                    throw new error_1.ToolkitError(`No template found for stack-name: ${options.stackName}`);
+                }
+                generateTemplateOutput = {
+                    migrateJson: {
+                        templateBody: template,
+                        source: options.stackName,
+                    },
+                };
+            }
+            else {
+                // We shouldn't ever get here, but just in case.
+                throw new error_1.ToolkitError(`Invalid source option provided: ${scanType}`);
+            }
+            const stack = (0, migrate_1.generateStack)(generateTemplateOutput.migrateJson.templateBody, options.stackName, language);
+            (0, logging_1.success)(' ⏳  Generating CDK app for %s...', chalk.blue(options.stackName));
+            await (0, migrate_1.generateCdkApp)(options.stackName, stack, language, options.outputPath, options.compress);
+            if (generateTemplateOutput) {
+                (0, migrate_1.writeMigrateJsonFile)(options.outputPath, options.stackName, generateTemplateOutput.migrateJson);
+            }
+            if ((0, migrate_1.isThereAWarning)(generateTemplateOutput)) {
+                (0, logging_1.warning)(' ⚠️  Some resources could not be migrated completely. Please review the README.md file for more information.');
+                (0, migrate_1.appendWarningsToReadme)(`${path.join((_e = options.outputPath) !== null && _e !== void 0 ? _e : process.cwd(), options.stackName)}/README.md`, generateTemplateOutput.resources);
+            }
+        }
+        catch (e) {
+            (0, logging_1.error)(' ❌  Migrate failed for `%s`: %s', options.stackName, e.message);
+            throw e;
+        }
+        finally {
+            if (templateToDelete) {
+                if (!cfn) {
+                    cfn = new migrate_1.CfnTemplateGeneratorProvider(await (0, migrate_1.buildCfnClient)(this.props.sdkProvider, environment));
+                }
+                if (!process.env.MIGRATE_INTEG_TEST) {
+                    await cfn.deleteGeneratedTemplate(templateToDelete);
+                }
+            }
+        }
+    }
+    async selectStacksForList(patterns) {
+        const assembly = await this.assembly();
+        const stacks = await assembly.selectStacks({ patterns }, { defaultBehavior: cloud_assembly_1.DefaultSelection.AllStacks });
+        // No validation
+        return stacks;
+    }
+    async selectStacksForDeploy(selector, exclusively, cacheCloudAssembly, ignoreNoStacks) {
+        const assembly = await this.assembly(cacheCloudAssembly);
+        const stacks = await assembly.selectStacks(selector, {
+            extend: exclusively ? cloud_assembly_1.ExtendedStackSelection.None : cloud_assembly_1.ExtendedStackSelection.Upstream,
+            defaultBehavior: cloud_assembly_1.DefaultSelection.OnlySingle,
+            ignoreNoStacks,
+        });
+        this.validateStacksSelected(stacks, selector.patterns);
+        await this.validateStacks(stacks);
+        return stacks;
+    }
+    async selectStacksForDiff(stackNames, exclusively, autoValidate) {
+        const assembly = await this.assembly();
+        const selectedForDiff = await assembly.selectStacks({ patterns: stackNames }, {
+            extend: exclusively ? cloud_assembly_1.ExtendedStackSelection.None : cloud_assembly_1.ExtendedStackSelection.Upstream,
+            defaultBehavior: cloud_assembly_1.DefaultSelection.MainAssembly,
+        });
+        const allStacks = await this.selectStacksForList([]);
+        const autoValidateStacks = autoValidate
+            ? allStacks.filter((art) => { var _a; return (_a = art.validateOnSynth) !== null && _a !== void 0 ? _a : false; })
+            : new cloud_assembly_1.StackCollection(assembly, []);
+        this.validateStacksSelected(selectedForDiff.concat(autoValidateStacks), stackNames);
+        await this.validateStacks(selectedForDiff.concat(autoValidateStacks));
+        return selectedForDiff;
+    }
+    async selectStacksForDestroy(selector, exclusively) {
+        const assembly = await this.assembly();
+        const stacks = await assembly.selectStacks(selector, {
+            extend: exclusively ? cloud_assembly_1.ExtendedStackSelection.None : cloud_assembly_1.ExtendedStackSelection.Downstream,
+            defaultBehavior: cloud_assembly_1.DefaultSelection.OnlySingle,
+        });
+        // No validation
+        return stacks;
+    }
+    /**
+     * Validate the stacks for errors and warnings according to the CLI's current settings
+     */
+    async validateStacks(stacks) {
+        let failAt = 'error';
+        if (this.props.ignoreErrors) {
+            failAt = 'none';
+        }
+        if (this.props.strict) {
+            failAt = 'warn';
+        }
+        await stacks.validateMetadata(failAt, stackMetadataLogger(this.props.verbose));
+    }
+    /**
+     * Validate that if a user specified a stack name there exists at least 1 stack selected
+     */
+    validateStacksSelected(stacks, stackNames) {
+        if (stackNames.length != 0 && stacks.stackCount == 0) {
+            throw new error_1.ToolkitError(`No stacks match the name(s) ${stackNames}`);
+        }
+    }
+    /**
+     * Select a single stack by its name
+     */
+    async selectSingleStackByName(stackName) {
+        const assembly = await this.assembly();
+        const stacks = await assembly.selectStacks({ patterns: [stackName] }, {
+            extend: cloud_assembly_1.ExtendedStackSelection.None,
+            defaultBehavior: cloud_assembly_1.DefaultSelection.None,
+        });
+        // Could have been a glob so check that we evaluated to exactly one
+        if (stacks.stackCount > 1) {
+            throw new error_1.ToolkitError(`This command requires exactly one stack and we matched more than one: ${stacks.stackIds}`);
+        }
+        return assembly.stackById(stacks.firstStack.id);
+    }
+    assembly(cacheCloudAssembly) {
+        return this.props.cloudExecutable.synthesize(cacheCloudAssembly);
+    }
+    patternsArrayForWatch(patterns, options) {
+        const patternsArray = patterns !== undefined ? (Array.isArray(patterns) ? patterns : [patterns]) : [];
+        return patternsArray.length > 0 ? patternsArray : options.returnRootDirIfEmpty ? [options.rootDir] : [];
+    }
+    async invokeDeployFromWatch(options, cloudWatchLogMonitor) {
+        const deployOptions = {
+            ...options,
+            requireApproval: diff_1.RequireApproval.Never,
+            // if 'watch' is called by invoking 'cdk deploy --watch',
+            // we need to make sure to not call 'deploy' with 'watch' again,
+            // as that would lead to a cycle
+            watch: false,
+            cloudWatchLogMonitor,
+            cacheCloudAssembly: false,
+            hotswap: options.hotswap,
+            extraUserAgent: `cdk-watch/hotswap-${options.hotswap !== common_1.HotswapMode.FALL_BACK ? 'on' : 'off'}`,
+            concurrency: options.concurrency,
+        };
+        try {
+            await this.deploy(deployOptions);
+        }
+        catch {
+            // just continue - deploy will show the error
+        }
+    }
+    /**
+     * Remove the asset publishing and building from the work graph for assets that are already in place
+     */
+    async removePublishedAssets(graph, options) {
+        await graph.removeUnnecessaryAssets(assetNode => this.props.deployments.isSingleAssetPublished(assetNode.assetManifest, assetNode.asset, {
+            stack: assetNode.parentStack,
+            roleArn: options.roleArn,
+            stackName: assetNode.parentStack.stackName,
+        }));
+    }
+}
+exports.CdkToolkit = CdkToolkit;
+/**
+ * Print a serialized object (YAML or JSON) to stdout.
+ */
+function printSerializedObject(obj, json) {
+    (0, logging_1.result)((0, serialize_1.serializeStructure)(obj, json));
+}
+function buildParameterMap(parameters) {
+    const parameterMap = { '*': {} };
+    for (const key in parameters) {
+        if (parameters.hasOwnProperty(key)) {
+            const [stack, parameter] = key.split(':', 2);
+            if (!parameter) {
+                parameterMap['*'][stack] = parameters[key];
+            }
+            else {
+                if (!parameterMap[stack]) {
+                    parameterMap[stack] = {};
+                }
+                parameterMap[stack][parameter] = parameters[key];
+            }
+        }
+    }
+    return parameterMap;
+}
+/**
+ * Ask the user for a yes/no confirmation
+ *
+ * Automatically fail the confirmation in case we're in a situation where the confirmation
+ * cannot be interactively obtained from a human at the keyboard.
+ */
+async function askUserConfirmation(ioHost, concurrency, motivation, question) {
+    await ioHost.withCorkedLogging(async () => {
+        // only talk to user if STDIN is a terminal (otherwise, fail)
+        if (!TESTING && !process.stdin.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`);
+        }
+        const confirmed = await promptly.confirm(`${chalk.cyan(question)} (y/n)?`);
+        if (!confirmed) {
+            throw new error_1.ToolkitError('Aborted by user');
+        }
+    });
+}
+/**
+ * Logger for processing stack metadata
+ */
+function stackMetadataLogger(verbose) {
+    const makeLogger = (level) => {
+        switch (level) {
+            case 'error':
+                return [logging_1.error, 'Error'];
+            case 'warn':
+                return [logging_1.warning, 'Warning'];
+            default:
+                return [logging_1.info, 'Info'];
+        }
+    };
+    return async (level, msg) => {
+        const [logFn, prefix] = makeLogger(level);
+        logFn(`[${prefix} at ${msg.id}] ${msg.entry.data}`);
+        if (verbose && msg.entry.trace) {
+            logFn(`  ${msg.entry.trace.join('\n  ')}`);
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-toolkit.js","sourceRoot":"","sources":["cdk-toolkit.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport { format } from 'util';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport * as chokidar from 'chokidar';\nimport * as fs from 'fs-extra';\nimport * as promptly from 'promptly';\nimport * as uuid from 'uuid';\nimport { Configuration, PROJECT_CONFIG } from './user-configuration';\nimport { SdkProvider } from '../api/aws-auth';\nimport { Bootstrapper, BootstrapEnvironmentOptions } from '../api/bootstrap';\nimport {\n  CloudAssembly,\n  DefaultSelection,\n  ExtendedStackSelection,\n  StackCollection,\n  StackSelector,\n} from '../api/cxapp/cloud-assembly';\nimport { CloudExecutable } from '../api/cxapp/cloud-executable';\nimport { environmentsFromDescriptors, globEnvironmentsFromStacks, looksLikeGlob } from '../api/cxapp/environments';\nimport { Deployments, DeploymentMethod, SuccessfulDeployStackResult, createDiffChangeSet } from '../api/deployments';\nimport { GarbageCollector } from '../api/garbage-collection/garbage-collector';\nimport { HotswapMode, HotswapPropertyOverrides, EcsHotswapProperties } from '../api/hotswap/common';\nimport { findCloudWatchLogGroups } from '../api/logs/find-cloudwatch-logs';\nimport { CloudWatchLogEventMonitor } from '../api/logs/logs-monitor';\nimport { tagsForStack, type Tag } from '../api/tags';\nimport { StackActivityProgress } from '../api/util/cloudformation/stack-activity-monitor';\nimport { formatTime } from '../api/util/string-manipulation';\nimport {\n  generateCdkApp,\n  generateStack,\n  readFromPath,\n  readFromStack,\n  setEnvironment,\n  parseSourceOptions,\n  generateTemplate,\n  FromScan,\n  TemplateSourceOptions,\n  GenerateTemplateOutput,\n  CfnTemplateGeneratorProvider,\n  writeMigrateJsonFile,\n  buildGenertedTemplateOutput,\n  appendWarningsToReadme,\n  isThereAWarning,\n  buildCfnClient,\n} from '../commands/migrate';\nimport { printSecurityDiff, printStackDiff, RequireApproval } from '../diff';\nimport { ResourceImporter, removeNonImportResources } from '../import';\nimport { listStacks } from '../list-stacks';\nimport { result as logResult, debug, error, highlight, info, success, warning } from '../logging';\nimport { ResourceMigrator } from '../migrator';\nimport { deserializeStructure, obscureTemplate, serializeStructure } from '../serialize';\nimport { CliIoHost } from '../toolkit/cli-io-host';\nimport { ToolkitError } from '../toolkit/error';\nimport { numberFromBool, partition } from '../util';\nimport { formatErrorMessage } from '../util/error';\nimport { validateSnsTopicArn } from '../util/validate-notification-arn';\nimport { Concurrency, WorkGraph } from '../util/work-graph';\nimport { WorkGraphBuilder } from '../util/work-graph-builder';\nimport { AssetBuildNode, AssetPublishNode, StackNode } from '../util/work-graph-types';\n\n// Must use a require() otherwise esbuild complains about calling a namespace\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nconst pLimit: typeof import('p-limit') = require('p-limit');\n\nlet TESTING = false;\n\nexport function markTesting() {\n  TESTING = true;\n}\n\nexport interface CdkToolkitProps {\n  /**\n   * The Cloud Executable\n   */\n  cloudExecutable: CloudExecutable;\n\n  /**\n   * The provisioning engine used to apply changes to the cloud\n   */\n  deployments: Deployments;\n\n  /**\n   * The CliIoHost that's used for I/O operations\n   */\n  ioHost?: CliIoHost;\n\n  /**\n   * Whether to be verbose\n   *\n   * @default false\n   */\n  verbose?: boolean;\n\n  /**\n   * Don't stop on error metadata\n   *\n   * @default false\n   */\n  ignoreErrors?: boolean;\n\n  /**\n   * Treat warnings in metadata as errors\n   *\n   * @default false\n   */\n  strict?: boolean;\n\n  /**\n   * Application configuration (settings and context)\n   */\n  configuration: Configuration;\n\n  /**\n   * AWS object (used by synthesizer and contextprovider)\n   */\n  sdkProvider: SdkProvider;\n}\n\n/**\n * When to build assets\n */\nexport enum AssetBuildTime {\n  /**\n   * Build all assets before deploying the first stack\n   *\n   * This is intended for expensive Docker image builds; so that if the Docker image build\n   * fails, no stacks are unnecessarily deployed (with the attendant wait time).\n   */\n  ALL_BEFORE_DEPLOY,\n\n  /**\n   * Build assets just-in-time, before publishing\n   */\n  JUST_IN_TIME,\n}\n\n/**\n * Toolkit logic\n *\n * The toolkit runs the `cloudExecutable` to obtain a cloud assembly and\n * deploys applies them to `cloudFormation`.\n */\nexport class CdkToolkit {\n  private ioHost: CliIoHost;\n\n  constructor(private readonly props: CdkToolkitProps) {\n    this.ioHost = props.ioHost ?? CliIoHost.instance();\n  }\n\n  public async metadata(stackName: string, json: boolean) {\n    const stacks = await this.selectSingleStackByName(stackName);\n    printSerializedObject(stacks.firstStack.manifest.metadata ?? {}, json);\n  }\n\n  public async acknowledge(noticeId: string) {\n    const acks = this.props.configuration.context.get('acknowledged-issue-numbers') ?? [];\n    acks.push(Number(noticeId));\n    this.props.configuration.context.set('acknowledged-issue-numbers', acks);\n    await this.props.configuration.saveContext();\n  }\n\n  public async diff(options: DiffOptions): Promise<number> {\n    const stacks = await this.selectStacksForDiff(options.stackNames, options.exclusively);\n\n    const strict = !!options.strict;\n    const contextLines = options.contextLines || 3;\n    const stream = options.stream || process.stderr;\n    const quiet = options.quiet || false;\n\n    let diffs = 0;\n    const parameterMap = buildParameterMap(options.parameters);\n\n    if (options.templatePath !== undefined) {\n      // Compare single stack against fixed template\n      if (stacks.stackCount !== 1) {\n        throw new ToolkitError(\n          'Can only select one stack when comparing to fixed template. Use --exclusively to avoid selecting multiple stacks.',\n        );\n      }\n\n      if (!(await fs.pathExists(options.templatePath))) {\n        throw new ToolkitError(`There is no file at ${options.templatePath}`);\n      }\n\n      const template = deserializeStructure(await fs.readFile(options.templatePath, { encoding: 'UTF-8' }));\n      diffs = options.securityOnly\n        ? numberFromBool(printSecurityDiff(template, stacks.firstStack, RequireApproval.Broadening, quiet))\n        : printStackDiff(template, stacks.firstStack, strict, contextLines, quiet, undefined, undefined, false, stream);\n    } else {\n      // Compare N stacks against deployed templates\n      for (const stack of stacks.stackArtifacts) {\n        const templateWithNestedStacks = await this.props.deployments.readCurrentTemplateWithNestedStacks(\n          stack,\n          options.compareAgainstProcessedTemplate,\n        );\n        const currentTemplate = templateWithNestedStacks.deployedRootTemplate;\n        const nestedStacks = templateWithNestedStacks.nestedStacks;\n\n        const migrator = new ResourceMigrator({\n          deployments: this.props.deployments,\n        });\n        const resourcesToImport = await migrator.tryGetResources(await this.props.deployments.resolveEnvironment(stack));\n        if (resourcesToImport) {\n          removeNonImportResources(stack);\n        }\n\n        let changeSet = undefined;\n\n        if (options.changeSet) {\n          let stackExists = false;\n          try {\n            stackExists = await this.props.deployments.stackExists({\n              stack,\n              deployName: stack.stackName,\n              tryLookupRole: true,\n            });\n          } catch (e: any) {\n            debug(formatErrorMessage(e));\n            if (!quiet) {\n              stream.write(\n                `Checking if the stack ${stack.stackName} exists before creating the changeset has failed, will base the diff on template differences (run again with -v to see the reason)\\n`,\n              );\n            }\n            stackExists = false;\n          }\n\n          if (stackExists) {\n            changeSet = await createDiffChangeSet({\n              stack,\n              uuid: uuid.v4(),\n              deployments: this.props.deployments,\n              willExecute: false,\n              sdkProvider: this.props.sdkProvider,\n              parameters: Object.assign({}, parameterMap['*'], parameterMap[stack.stackName]),\n              resourcesToImport,\n              stream,\n            });\n          } else {\n            debug(\n              `the stack '${stack.stackName}' has not been deployed to CloudFormation or describeStacks call failed, skipping changeset creation.`,\n            );\n          }\n        }\n\n        const stackCount = options.securityOnly\n          ? numberFromBool(\n            printSecurityDiff(\n              currentTemplate,\n              stack,\n              RequireApproval.Broadening,\n              quiet,\n              stack.displayName,\n              changeSet,\n            ),\n          )\n          : printStackDiff(\n            currentTemplate,\n            stack,\n            strict,\n            contextLines,\n            quiet,\n            stack.displayName,\n            changeSet,\n            !!resourcesToImport,\n            stream,\n            nestedStacks,\n          );\n\n        diffs += stackCount;\n      }\n    }\n\n    stream.write(format('\\n✨  Number of stacks with differences: %s\\n', diffs));\n\n    return diffs && options.fail ? 1 : 0;\n  }\n\n  public async deploy(options: DeployOptions) {\n    if (options.watch) {\n      return this.watch(options);\n    }\n\n    const startSynthTime = new Date().getTime();\n    const stackCollection = await this.selectStacksForDeploy(\n      options.selector,\n      options.exclusively,\n      options.cacheCloudAssembly,\n      options.ignoreNoStacks,\n    );\n    const elapsedSynthTime = new Date().getTime() - startSynthTime;\n    info(`\\n✨  Synthesis time: ${formatTime(elapsedSynthTime)}s\\n`);\n\n    if (stackCollection.stackCount === 0) {\n      error('This app contains no stacks');\n      return;\n    }\n\n    const migrator = new ResourceMigrator({\n      deployments: this.props.deployments,\n    });\n    await migrator.tryMigrateResources(stackCollection, options);\n\n    const requireApproval = options.requireApproval ?? RequireApproval.Broadening;\n\n    const parameterMap = buildParameterMap(options.parameters);\n\n    if (options.hotswap !== HotswapMode.FULL_DEPLOYMENT) {\n      warning(\n        '⚠️ The --hotswap and --hotswap-fallback flags deliberately introduce CloudFormation drift to speed up deployments',\n      );\n      warning('⚠️ They should only be used for development - never use them for your production Stacks!\\n');\n    }\n\n    let hotswapPropertiesFromSettings = this.props.configuration.settings.get(['hotswap']) || {};\n\n    let hotswapPropertyOverrides = new HotswapPropertyOverrides();\n    hotswapPropertyOverrides.ecsHotswapProperties = new EcsHotswapProperties(\n      hotswapPropertiesFromSettings.ecs?.minimumHealthyPercent,\n      hotswapPropertiesFromSettings.ecs?.maximumHealthyPercent,\n    );\n\n    const stacks = stackCollection.stackArtifacts;\n\n    const stackOutputs: { [key: string]: any } = {};\n    const outputsFile = options.outputsFile;\n\n    const buildAsset = async (assetNode: AssetBuildNode) => {\n      await this.props.deployments.buildSingleAsset(\n        assetNode.assetManifestArtifact,\n        assetNode.assetManifest,\n        assetNode.asset,\n        {\n          stack: assetNode.parentStack,\n          roleArn: options.roleArn,\n          stackName: assetNode.parentStack.stackName,\n        },\n      );\n    };\n\n    const publishAsset = async (assetNode: AssetPublishNode) => {\n      await this.props.deployments.publishSingleAsset(assetNode.assetManifest, assetNode.asset, {\n        stack: assetNode.parentStack,\n        roleArn: options.roleArn,\n        stackName: assetNode.parentStack.stackName,\n      });\n    };\n\n    const deployStack = async (stackNode: StackNode) => {\n      const stack = stackNode.stack;\n      if (stackCollection.stackCount !== 1) {\n        highlight(stack.displayName);\n      }\n\n      if (!stack.environment) {\n        // eslint-disable-next-line max-len\n        throw new ToolkitError(\n          `Stack ${stack.displayName} does not define an environment, and AWS credentials could not be obtained from standard locations or no region was configured.`,\n        );\n      }\n\n      if (Object.keys(stack.template.Resources || {}).length === 0) {\n        // The generated stack has no resources\n        if (!(await this.props.deployments.stackExists({ stack }))) {\n          warning('%s: stack has no resources, skipping deployment.', chalk.bold(stack.displayName));\n        } else {\n          warning('%s: stack has no resources, deleting existing stack.', chalk.bold(stack.displayName));\n          await this.destroy({\n            selector: { patterns: [stack.hierarchicalId] },\n            exclusively: true,\n            force: true,\n            roleArn: options.roleArn,\n            fromDeploy: true,\n            ci: options.ci,\n          });\n        }\n        return;\n      }\n\n      if (requireApproval !== RequireApproval.Never) {\n        const currentTemplate = await this.props.deployments.readCurrentTemplate(stack);\n        if (printSecurityDiff(currentTemplate, stack, requireApproval)) {\n          await askUserConfirmation(\n            this.ioHost,\n            concurrency,\n            '\"--require-approval\" is enabled and stack includes security-sensitive updates',\n            'Do you wish to deploy these changes',\n          );\n        }\n      }\n\n      // Following are the same semantics we apply with respect to Notification ARNs (dictated by the SDK)\n      //\n      //  - undefined  =>  cdk ignores it, as if it wasn't supported (allows external management).\n      //  - []:        =>  cdk manages it, and the user wants to wipe it out.\n      //  - ['arn-1']  =>  cdk manages it, and the user wants to set it to ['arn-1'].\n      const notificationArns = (!!options.notificationArns || !!stack.notificationArns)\n        ? (options.notificationArns ?? []).concat(stack.notificationArns ?? [])\n        : undefined;\n\n      for (const notificationArn of notificationArns ?? []) {\n        if (!validateSnsTopicArn(notificationArn)) {\n          throw new ToolkitError(`Notification arn ${notificationArn} is not a valid arn for an SNS topic`);\n        }\n      }\n\n      const stackIndex = stacks.indexOf(stack) + 1;\n      info(`${chalk.bold(stack.displayName)}: deploying... [${stackIndex}/${stackCollection.stackCount}]`);\n      const startDeployTime = new Date().getTime();\n\n      let tags = options.tags;\n      if (!tags || tags.length === 0) {\n        tags = tagsForStack(stack);\n      }\n\n      let elapsedDeployTime = 0;\n      try {\n        let deployResult: SuccessfulDeployStackResult | undefined;\n\n        let rollback = options.rollback;\n        let iteration = 0;\n        while (!deployResult) {\n          if (++iteration > 2) {\n            throw new ToolkitError('This loop should have stabilized in 2 iterations, but didn\\'t. If you are seeing this error, please report it at https://github.com/aws/aws-cdk/issues/new/choose');\n          }\n\n          const r = await this.props.deployments.deployStack({\n            stack,\n            deployName: stack.stackName,\n            roleArn: options.roleArn,\n            toolkitStackName: options.toolkitStackName,\n            reuseAssets: options.reuseAssets,\n            notificationArns,\n            tags,\n            execute: options.execute,\n            changeSetName: options.changeSetName,\n            deploymentMethod: options.deploymentMethod,\n            force: options.force,\n            parameters: Object.assign({}, parameterMap['*'], parameterMap[stack.stackName]),\n            usePreviousParameters: options.usePreviousParameters,\n            progress,\n            ci: options.ci,\n            rollback,\n            hotswap: options.hotswap,\n            hotswapPropertyOverrides: hotswapPropertyOverrides,\n            extraUserAgent: options.extraUserAgent,\n            assetParallelism: options.assetParallelism,\n            ignoreNoStacks: options.ignoreNoStacks,\n          });\n\n          switch (r.type) {\n            case 'did-deploy-stack':\n              deployResult = r;\n              break;\n\n            case 'failpaused-need-rollback-first': {\n              const motivation = r.reason === 'replacement'\n                ? `Stack is in a paused fail state (${r.status}) and change includes a replacement which cannot be deployed with \"--no-rollback\"`\n                : `Stack is in a paused fail state (${r.status}) and command line arguments do not include \"--no-rollback\"`;\n\n              if (options.force) {\n                warning(`${motivation}. Rolling back first (--force).`);\n              } else {\n                await askUserConfirmation(\n                  this.ioHost,\n                  concurrency,\n                  motivation,\n                  `${motivation}. Roll back first and then proceed with deployment`,\n                );\n              }\n\n              // Perform a rollback\n              await this.rollback({\n                selector: { patterns: [stack.hierarchicalId] },\n                toolkitStackName: options.toolkitStackName,\n                force: options.force,\n              });\n\n              // Go around through the 'while' loop again but switch rollback to true.\n              rollback = true;\n              break;\n            }\n\n            case 'replacement-requires-rollback': {\n              const motivation = 'Change includes a replacement which cannot be deployed with \"--no-rollback\"';\n\n              if (options.force) {\n                warning(`${motivation}. Proceeding with regular deployment (--force).`);\n              } else {\n                await askUserConfirmation(\n                  this.ioHost,\n                  concurrency,\n                  motivation,\n                  `${motivation}. Perform a regular deployment`,\n                );\n              }\n\n              // Go around through the 'while' loop again but switch rollback to true.\n              rollback = true;\n              break;\n            }\n\n            default:\n              throw new ToolkitError(`Unexpected result type from deployStack: ${JSON.stringify(r)}. If you are seeing this error, please report it at https://github.com/aws/aws-cdk/issues/new/choose`);\n          }\n        }\n\n        const message = deployResult.noOp\n          ? ' ✅  %s (no changes)'\n          : ' ✅  %s';\n\n        success('\\n' + message, stack.displayName);\n        elapsedDeployTime = new Date().getTime() - startDeployTime;\n        info(`\\n✨  Deployment time: ${formatTime(elapsedDeployTime)}s\\n`);\n\n        if (Object.keys(deployResult.outputs).length > 0) {\n          info('Outputs:');\n\n          stackOutputs[stack.stackName] = deployResult.outputs;\n        }\n\n        for (const name of Object.keys(deployResult.outputs).sort()) {\n          const value = deployResult.outputs[name];\n          info(`${chalk.cyan(stack.id)}.${chalk.cyan(name)} = ${chalk.underline(chalk.cyan(value))}`);\n        }\n\n        info('Stack ARN:');\n\n        logResult(deployResult.stackArn);\n      } catch (e: any) {\n        // It has to be exactly this string because an integration test tests for\n        // \"bold(stackname) failed: ResourceNotReady: <error>\"\n        throw new ToolkitError(\n          [`❌  ${chalk.bold(stack.stackName)} failed:`, ...(e.name ? [`${e.name}:`] : []), formatErrorMessage(e)].join(' '),\n        );\n      } finally {\n        if (options.cloudWatchLogMonitor) {\n          const foundLogGroupsResult = await findCloudWatchLogGroups(this.props.sdkProvider, stack);\n          options.cloudWatchLogMonitor.addLogGroups(\n            foundLogGroupsResult.env,\n            foundLogGroupsResult.sdk,\n            foundLogGroupsResult.logGroupNames,\n          );\n        }\n        // If an outputs file has been specified, create the file path and write stack outputs to it once.\n        // Outputs are written after all stacks have been deployed. If a stack deployment fails,\n        // all of the outputs from successfully deployed stacks before the failure will still be written.\n        if (outputsFile) {\n          fs.ensureFileSync(outputsFile);\n          await fs.writeJson(outputsFile, stackOutputs, {\n            spaces: 2,\n            encoding: 'utf8',\n          });\n        }\n      }\n      info(`\\n✨  Total time: ${formatTime(elapsedSynthTime + elapsedDeployTime)}s\\n`);\n    };\n\n    const assetBuildTime = options.assetBuildTime ?? AssetBuildTime.ALL_BEFORE_DEPLOY;\n    const prebuildAssets = assetBuildTime === AssetBuildTime.ALL_BEFORE_DEPLOY;\n    const concurrency = options.concurrency || 1;\n    const progress = concurrency > 1 ? StackActivityProgress.EVENTS : options.progress;\n    if (concurrency > 1 && options.progress && options.progress != StackActivityProgress.EVENTS) {\n      warning('⚠️ The --concurrency flag only supports --progress \"events\". Switching to \"events\".');\n    }\n\n    const stacksAndTheirAssetManifests = stacks.flatMap((stack) => [\n      stack,\n      ...stack.dependencies.filter(cxapi.AssetManifestArtifact.isAssetManifestArtifact),\n    ]);\n    const workGraph = new WorkGraphBuilder(prebuildAssets).build(stacksAndTheirAssetManifests);\n\n    // Unless we are running with '--force', skip already published assets\n    if (!options.force) {\n      await this.removePublishedAssets(workGraph, options);\n    }\n\n    const graphConcurrency: Concurrency = {\n      'stack': concurrency,\n      'asset-build': 1, // This will be CPU-bound/memory bound, mostly matters for Docker builds\n      'asset-publish': (options.assetParallelism ?? true) ? 8 : 1, // This will be I/O-bound, 8 in parallel seems reasonable\n    };\n\n    await workGraph.doParallel(graphConcurrency, {\n      deployStack,\n      buildAsset,\n      publishAsset,\n    });\n  }\n\n  /**\n   * Roll back the given stack or stacks.\n   */\n  public async rollback(options: RollbackOptions) {\n    const startSynthTime = new Date().getTime();\n    const stackCollection = await this.selectStacksForDeploy(options.selector, true);\n    const elapsedSynthTime = new Date().getTime() - startSynthTime;\n    info(`\\n✨  Synthesis time: ${formatTime(elapsedSynthTime)}s\\n`);\n\n    if (stackCollection.stackCount === 0) {\n      error('No stacks selected');\n      return;\n    }\n\n    let anyRollbackable = false;\n\n    for (const stack of stackCollection.stackArtifacts) {\n      info('Rolling back %s', chalk.bold(stack.displayName));\n      const startRollbackTime = new Date().getTime();\n      try {\n        const result = await this.props.deployments.rollbackStack({\n          stack,\n          roleArn: options.roleArn,\n          toolkitStackName: options.toolkitStackName,\n          force: options.force,\n          validateBootstrapStackVersion: options.validateBootstrapStackVersion,\n          orphanLogicalIds: options.orphanLogicalIds,\n        });\n        if (!result.notInRollbackableState) {\n          anyRollbackable = true;\n        }\n        const elapsedRollbackTime = new Date().getTime() - startRollbackTime;\n        info(`\\n✨  Rollback time: ${formatTime(elapsedRollbackTime).toString()}s\\n`);\n      } catch (e: any) {\n        error('\\n ❌  %s failed: %s', chalk.bold(stack.displayName), formatErrorMessage(e));\n        throw new ToolkitError('Rollback failed (use --force to orphan failing resources)');\n      }\n    }\n    if (!anyRollbackable) {\n      throw new ToolkitError('No stacks were in a state that could be rolled back');\n    }\n  }\n\n  public async watch(options: WatchOptions) {\n    const rootDir = path.dirname(path.resolve(PROJECT_CONFIG));\n    debug(\"root directory used for 'watch' is: %s\", rootDir);\n\n    const watchSettings: { include?: string | string[]; exclude: string | string[] } | undefined =\n      this.props.configuration.settings.get(['watch']);\n    if (!watchSettings) {\n      throw new ToolkitError(\n        \"Cannot use the 'watch' command without specifying at least one directory to monitor. \" +\n          'Make sure to add a \"watch\" key to your cdk.json',\n      );\n    }\n\n    // For the \"include\" subkey under the \"watch\" key, the behavior is:\n    // 1. No \"watch\" setting? We error out.\n    // 2. \"watch\" setting without an \"include\" key? We default to observing \"./**\".\n    // 3. \"watch\" setting with an empty \"include\" key? We default to observing \"./**\".\n    // 4. Non-empty \"include\" key? Just use the \"include\" key.\n    const watchIncludes = this.patternsArrayForWatch(watchSettings.include, {\n      rootDir,\n      returnRootDirIfEmpty: true,\n    });\n    debug(\"'include' patterns for 'watch': %s\", watchIncludes);\n\n    // For the \"exclude\" subkey under the \"watch\" key,\n    // the behavior is to add some default excludes in addition to the ones specified by the user:\n    // 1. The CDK output directory.\n    // 2. Any file whose name starts with a dot.\n    // 3. Any directory's content whose name starts with a dot.\n    // 4. Any node_modules and its content (even if it's not a JS/TS project, you might be using a local aws-cli package)\n    const outputDir = this.props.configuration.settings.get(['output']);\n    const watchExcludes = this.patternsArrayForWatch(watchSettings.exclude, {\n      rootDir,\n      returnRootDirIfEmpty: false,\n    }).concat(`${outputDir}/**`, '**/.*', '**/.*/**', '**/node_modules/**');\n    debug(\"'exclude' patterns for 'watch': %s\", watchExcludes);\n\n    // Since 'cdk deploy' is a relatively slow operation for a 'watch' process,\n    // introduce a concurrency latch that tracks the state.\n    // This way, if file change events arrive when a 'cdk deploy' is still executing,\n    // we will batch them, and trigger another 'cdk deploy' after the current one finishes,\n    // making sure 'cdk deploy's  always execute one at a time.\n    // Here's a diagram showing the state transitions:\n    // --------------                --------    file changed     --------------    file changed     --------------  file changed\n    // |            |  ready event   |      | ------------------> |            | ------------------> |            | --------------|\n    // | pre-ready  | -------------> | open |                     | deploying  |                     |   queued   |               |\n    // |            |                |      | <------------------ |            | <------------------ |            | <-------------|\n    // --------------                --------  'cdk deploy' done  --------------  'cdk deploy' done  --------------\n    let latch: 'pre-ready' | 'open' | 'deploying' | 'queued' = 'pre-ready';\n\n    const cloudWatchLogMonitor = options.traceLogs ? new CloudWatchLogEventMonitor() : undefined;\n    const deployAndWatch = async () => {\n      latch = 'deploying';\n      cloudWatchLogMonitor?.deactivate();\n\n      await this.invokeDeployFromWatch(options, cloudWatchLogMonitor);\n\n      // If latch is still 'deploying' after the 'await', that's fine,\n      // but if it's 'queued', that means we need to deploy again\n      while ((latch as 'deploying' | 'queued') === 'queued') {\n        // TypeScript doesn't realize latch can change between 'awaits',\n        // and thinks the above 'while' condition is always 'false' without the cast\n        latch = 'deploying';\n        info(\"Detected file changes during deployment. Invoking 'cdk deploy' again\");\n        await this.invokeDeployFromWatch(options, cloudWatchLogMonitor);\n      }\n      latch = 'open';\n      cloudWatchLogMonitor?.activate();\n    };\n\n    chokidar\n      .watch(watchIncludes, {\n        ignored: watchExcludes,\n        cwd: rootDir,\n      })\n      .on('ready', async () => {\n        latch = 'open';\n        debug(\"'watch' received the 'ready' event. From now on, all file changes will trigger a deployment\");\n        info(\"Triggering initial 'cdk deploy'\");\n        await deployAndWatch();\n      })\n      .on('all', async (event: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir', filePath?: string) => {\n        if (latch === 'pre-ready') {\n          info(`'watch' is observing ${event === 'addDir' ? 'directory' : 'the file'} '%s' for changes`, filePath);\n        } else if (latch === 'open') {\n          info(\"Detected change to '%s' (type: %s). Triggering 'cdk deploy'\", filePath, event);\n          await deployAndWatch();\n        } else {\n          // this means latch is either 'deploying' or 'queued'\n          latch = 'queued';\n          info(\n            \"Detected change to '%s' (type: %s) while 'cdk deploy' is still running. \" +\n              'Will queue for another deployment after this one finishes',\n            filePath,\n            event,\n          );\n        }\n      });\n  }\n\n  public async import(options: ImportOptions) {\n    const stacks = await this.selectStacksForDeploy(options.selector, true, true, false);\n\n    if (stacks.stackCount > 1) {\n      throw new ToolkitError(\n        `Stack selection is ambiguous, please choose a specific stack for import [${stacks.stackArtifacts.map((x) => x.id).join(', ')}]`,\n      );\n    }\n\n    if (!process.stdout.isTTY && !options.resourceMappingFile) {\n      throw new ToolkitError('--resource-mapping is required when input is not a terminal');\n    }\n\n    const stack = stacks.stackArtifacts[0];\n\n    highlight(stack.displayName);\n\n    const resourceImporter = new ResourceImporter(stack, this.props.deployments);\n    const { additions, hasNonAdditions } = await resourceImporter.discoverImportableResources(options.force);\n    if (additions.length === 0) {\n      warning(\n        '%s: no new resources compared to the currently deployed stack, skipping import.',\n        chalk.bold(stack.displayName),\n      );\n      return;\n    }\n\n    // Prepare a mapping of physical resources to CDK constructs\n    const actualImport = !options.resourceMappingFile\n      ? await resourceImporter.askForResourceIdentifiers(additions)\n      : await resourceImporter.loadResourceIdentifiers(additions, options.resourceMappingFile);\n\n    if (actualImport.importResources.length === 0) {\n      warning('No resources selected for import.');\n      return;\n    }\n\n    // If \"--create-resource-mapping\" option was passed, write the resource mapping to the given file and exit\n    if (options.recordResourceMapping) {\n      const outputFile = options.recordResourceMapping;\n      fs.ensureFileSync(outputFile);\n      await fs.writeJson(outputFile, actualImport.resourceMap, {\n        spaces: 2,\n        encoding: 'utf8',\n      });\n      info('%s: mapping file written.', outputFile);\n      return;\n    }\n\n    // Import the resources according to the given mapping\n    info('%s: importing resources into stack...', chalk.bold(stack.displayName));\n    const tags = tagsForStack(stack);\n    await resourceImporter.importResourcesFromMap(actualImport, {\n      roleArn: options.roleArn,\n      toolkitStackName: options.toolkitStackName,\n      tags,\n      deploymentMethod: options.deploymentMethod,\n      usePreviousParameters: true,\n      progress: options.progress,\n      rollback: options.rollback,\n    });\n\n    // Notify user of next steps\n    info(\n      `Import operation complete. We recommend you run a ${chalk.blueBright('drift detection')} operation ` +\n        'to confirm your CDK app resource definitions are up-to-date. Read more here: ' +\n        chalk.underline.blueBright(\n          'https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/detect-drift-stack.html',\n        ),\n    );\n    if (actualImport.importResources.length < additions.length) {\n      info('');\n      warning(\n        `Some resources were skipped. Run another ${chalk.blueBright('cdk import')} or a ${chalk.blueBright('cdk deploy')} to bring the stack up-to-date with your CDK app definition.`,\n      );\n    } else if (hasNonAdditions) {\n      info('');\n      warning(\n        `Your app has pending updates or deletes excluded from this import operation. Run a ${chalk.blueBright('cdk deploy')} to bring the stack up-to-date with your CDK app definition.`,\n      );\n    }\n  }\n\n  public async destroy(options: DestroyOptions) {\n    let stacks = await this.selectStacksForDestroy(options.selector, options.exclusively);\n\n    // The stacks will have been ordered for deployment, so reverse them for deletion.\n    stacks = stacks.reversed();\n\n    if (!options.force) {\n      // eslint-disable-next-line max-len\n      const confirmed = await promptly.confirm(\n        `Are you sure you want to delete: ${chalk.blue(stacks.stackArtifacts.map((s) => s.hierarchicalId).join(', '))} (y/n)?`,\n      );\n      if (!confirmed) {\n        return;\n      }\n    }\n\n    const action = options.fromDeploy ? 'deploy' : 'destroy';\n    for (const [index, stack] of stacks.stackArtifacts.entries()) {\n      success('%s: destroying... [%s/%s]', chalk.blue(stack.displayName), index + 1, stacks.stackCount);\n      try {\n        await this.props.deployments.destroyStack({\n          stack,\n          deployName: stack.stackName,\n          roleArn: options.roleArn,\n          ci: options.ci,\n        });\n        success(`\\n ✅  %s: ${action}ed`, chalk.blue(stack.displayName));\n      } catch (e) {\n        error(`\\n ❌  %s: ${action} failed`, chalk.blue(stack.displayName), e);\n        throw e;\n      }\n    }\n  }\n\n  public async list(\n    selectors: string[],\n    options: { long?: boolean; json?: boolean; showDeps?: boolean } = {},\n  ): Promise<number> {\n    const stacks = await listStacks(this, {\n      selectors: selectors,\n    });\n\n    if (options.long && options.showDeps) {\n      printSerializedObject(stacks, options.json ?? false);\n      return 0;\n    }\n\n    if (options.showDeps) {\n      const stackDeps = [];\n\n      for (const stack of stacks) {\n        stackDeps.push({\n          id: stack.id,\n          dependencies: stack.dependencies,\n        });\n      }\n\n      printSerializedObject(stackDeps, options.json ?? false);\n      return 0;\n    }\n\n    if (options.long) {\n      const long = [];\n\n      for (const stack of stacks) {\n        long.push({\n          id: stack.id,\n          name: stack.name,\n          environment: stack.environment,\n        });\n      }\n      printSerializedObject(long, options.json ?? false);\n      return 0;\n    }\n\n    // just print stack IDs\n    for (const stack of stacks) {\n      logResult(stack.id);\n    }\n\n    return 0; // exit-code\n  }\n\n  /**\n   * Synthesize the given set of stacks (called when the user runs 'cdk synth')\n   *\n   * INPUT: Stack names can be supplied using a glob filter. If no stacks are\n   * given, all stacks from the application are implicitly selected.\n   *\n   * OUTPUT: If more than one stack ends up being selected, an output directory\n   * should be supplied, where the templates will be written.\n   */\n  public async synth(\n    stackNames: string[],\n    exclusively: boolean,\n    quiet: boolean,\n    autoValidate?: boolean,\n    json?: boolean,\n  ): Promise<any> {\n    const stacks = await this.selectStacksForDiff(stackNames, exclusively, autoValidate);\n\n    // if we have a single stack, print it to STDOUT\n    if (stacks.stackCount === 1) {\n      if (!quiet) {\n        printSerializedObject(obscureTemplate(stacks.firstStack.template), json ?? false);\n      }\n      return undefined;\n    }\n\n    // not outputting template to stdout, let's explain things to the user a little bit...\n    success(`Successfully synthesized to ${chalk.blue(path.resolve(stacks.assembly.directory))}`);\n    info(\n      `Supply a stack id (${stacks.stackArtifacts.map((s) => chalk.green(s.hierarchicalId)).join(', ')}) to display its template.`,\n    );\n\n    return undefined;\n  }\n\n  /**\n   * Bootstrap the CDK Toolkit stack in the accounts used by the specified stack(s).\n   *\n   * @param userEnvironmentSpecs environment names that need to have toolkit support\n   *             provisioned, as a glob filter. If none is provided, all stacks are implicitly selected.\n   * @param options The name, role ARN, bootstrapping parameters, etc. to be used for the CDK Toolkit stack.\n   */\n  public async bootstrap(\n    userEnvironmentSpecs: string[],\n    options: BootstrapEnvironmentOptions,\n  ): Promise<void> {\n    const bootstrapper = new Bootstrapper(options.source);\n    // If there is an '--app' argument and an environment looks like a glob, we\n    // select the environments from the app. Otherwise, use what the user said.\n\n    const environments = await this.defineEnvironments(userEnvironmentSpecs);\n\n    const limit = pLimit(20);\n\n    // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism\n    await Promise.all(environments.map((environment) => limit(async () => {\n      success(' ⏳  Bootstrapping environment %s...', chalk.blue(environment.name));\n      try {\n        const result = await bootstrapper.bootstrapEnvironment(environment, this.props.sdkProvider, options);\n        const message = result.noOp\n          ? ' ✅  Environment %s bootstrapped (no changes).'\n          : ' ✅  Environment %s bootstrapped.';\n        success(message, chalk.blue(environment.name));\n      } catch (e) {\n        error(' ❌  Environment %s failed bootstrapping: %s', chalk.blue(environment.name), e);\n        throw e;\n      }\n    })));\n  }\n\n  /**\n   * Garbage collects assets from a CDK app's environment\n   * @param options Options for Garbage Collection\n   */\n  public async garbageCollect(userEnvironmentSpecs: string[], options: GarbageCollectionOptions) {\n    const environments = await this.defineEnvironments(userEnvironmentSpecs);\n\n    for (const environment of environments) {\n      success(' ⏳  Garbage Collecting environment %s...', chalk.blue(environment.name));\n      const gc = new GarbageCollector({\n        sdkProvider: this.props.sdkProvider,\n        resolvedEnvironment: environment,\n        bootstrapStackName: options.bootstrapStackName,\n        rollbackBufferDays: options.rollbackBufferDays,\n        createdBufferDays: options.createdBufferDays,\n        action: options.action ?? 'full',\n        type: options.type ?? 'all',\n        confirm: options.confirm ?? true,\n      });\n      await gc.garbageCollect();\n    };\n  }\n\n  private async defineEnvironments(userEnvironmentSpecs: string[]): Promise<cxapi.Environment[]> {\n    // By default, glob for everything\n    const environmentSpecs = userEnvironmentSpecs.length > 0 ? [...userEnvironmentSpecs] : ['**'];\n\n    // Partition into globs and non-globs (this will mutate environmentSpecs).\n    const globSpecs = partition(environmentSpecs, looksLikeGlob);\n    if (globSpecs.length > 0 && !this.props.cloudExecutable.hasApp) {\n      if (userEnvironmentSpecs.length > 0) {\n        // User did request this glob\n        throw new ToolkitError(\n          `'${globSpecs}' is not an environment name. Specify an environment name like 'aws://123456789012/us-east-1', or run in a directory with 'cdk.json' to use wildcards.`,\n        );\n      } else {\n        // User did not request anything\n        throw new ToolkitError(\n          \"Specify an environment name like 'aws://123456789012/us-east-1', or run in a directory with 'cdk.json'.\",\n        );\n      }\n    }\n\n    const environments: cxapi.Environment[] = [...environmentsFromDescriptors(environmentSpecs)];\n\n    // If there is an '--app' argument, select the environments from the app.\n    if (this.props.cloudExecutable.hasApp) {\n      environments.push(\n        ...(await globEnvironmentsFromStacks(await this.selectStacksForList([]), globSpecs, this.props.sdkProvider)),\n      );\n    }\n\n    return environments;\n  }\n\n  /**\n   * Migrates a CloudFormation stack/template to a CDK app\n   * @param options Options for CDK app creation\n   */\n  public async migrate(options: MigrateOptions): Promise<void> {\n    warning('This command is an experimental feature.');\n    const language = options.language?.toLowerCase() ?? 'typescript';\n    const environment = setEnvironment(options.account, options.region);\n    let generateTemplateOutput: GenerateTemplateOutput | undefined;\n    let cfn: CfnTemplateGeneratorProvider | undefined;\n    let templateToDelete: string | undefined;\n\n    try {\n      // if neither fromPath nor fromStack is provided, generate a template using cloudformation\n      const scanType = parseSourceOptions(options.fromPath, options.fromStack, options.stackName).source;\n      if (scanType == TemplateSourceOptions.SCAN) {\n        generateTemplateOutput = await generateTemplate({\n          stackName: options.stackName,\n          filters: options.filter,\n          fromScan: options.fromScan,\n          sdkProvider: this.props.sdkProvider,\n          environment: environment,\n        });\n        templateToDelete = generateTemplateOutput.templateId;\n      } else if (scanType == TemplateSourceOptions.PATH) {\n        const templateBody = readFromPath(options.fromPath!);\n\n        const parsedTemplate = deserializeStructure(templateBody);\n        const templateId = parsedTemplate.Metadata?.TemplateId?.toString();\n        if (templateId) {\n          // if we have a template id, we can call describe generated template to get the resource identifiers\n          // resource metadata, and template source to generate the template\n          cfn = new CfnTemplateGeneratorProvider(await buildCfnClient(this.props.sdkProvider, environment));\n          const generatedTemplateSummary = await cfn.describeGeneratedTemplate(templateId);\n          generateTemplateOutput = buildGenertedTemplateOutput(\n            generatedTemplateSummary,\n            templateBody,\n            generatedTemplateSummary.GeneratedTemplateId!,\n          );\n        } else {\n          generateTemplateOutput = {\n            migrateJson: {\n              templateBody: templateBody,\n              source: 'localfile',\n            },\n          };\n        }\n      } else if (scanType == TemplateSourceOptions.STACK) {\n        const template = await readFromStack(options.stackName, this.props.sdkProvider, environment);\n        if (!template) {\n          throw new ToolkitError(`No template found for stack-name: ${options.stackName}`);\n        }\n        generateTemplateOutput = {\n          migrateJson: {\n            templateBody: template,\n            source: options.stackName,\n          },\n        };\n      } else {\n        // We shouldn't ever get here, but just in case.\n        throw new ToolkitError(`Invalid source option provided: ${scanType}`);\n      }\n      const stack = generateStack(generateTemplateOutput.migrateJson.templateBody, options.stackName, language);\n      success(' ⏳  Generating CDK app for %s...', chalk.blue(options.stackName));\n      await generateCdkApp(options.stackName, stack!, language, options.outputPath, options.compress);\n      if (generateTemplateOutput) {\n        writeMigrateJsonFile(options.outputPath, options.stackName, generateTemplateOutput.migrateJson);\n      }\n      if (isThereAWarning(generateTemplateOutput)) {\n        warning(\n          ' ⚠️  Some resources could not be migrated completely. Please review the README.md file for more information.',\n        );\n        appendWarningsToReadme(\n          `${path.join(options.outputPath ?? process.cwd(), options.stackName)}/README.md`,\n          generateTemplateOutput.resources!,\n        );\n      }\n    } catch (e) {\n      error(' ❌  Migrate failed for `%s`: %s', options.stackName, (e as Error).message);\n      throw e;\n    } finally {\n      if (templateToDelete) {\n        if (!cfn) {\n          cfn = new CfnTemplateGeneratorProvider(await buildCfnClient(this.props.sdkProvider, environment));\n        }\n        if (!process.env.MIGRATE_INTEG_TEST) {\n          await cfn.deleteGeneratedTemplate(templateToDelete);\n        }\n      }\n    }\n  }\n\n  private async selectStacksForList(patterns: string[]) {\n    const assembly = await this.assembly();\n    const stacks = await assembly.selectStacks({ patterns }, { defaultBehavior: DefaultSelection.AllStacks });\n\n    // No validation\n\n    return stacks;\n  }\n\n  private async selectStacksForDeploy(\n    selector: StackSelector,\n    exclusively?: boolean,\n    cacheCloudAssembly?: boolean,\n    ignoreNoStacks?: boolean,\n  ): Promise<StackCollection> {\n    const assembly = await this.assembly(cacheCloudAssembly);\n    const stacks = await assembly.selectStacks(selector, {\n      extend: exclusively ? ExtendedStackSelection.None : ExtendedStackSelection.Upstream,\n      defaultBehavior: DefaultSelection.OnlySingle,\n      ignoreNoStacks,\n    });\n\n    this.validateStacksSelected(stacks, selector.patterns);\n    await this.validateStacks(stacks);\n\n    return stacks;\n  }\n\n  private async selectStacksForDiff(\n    stackNames: string[],\n    exclusively?: boolean,\n    autoValidate?: boolean,\n  ): Promise<StackCollection> {\n    const assembly = await this.assembly();\n\n    const selectedForDiff = await assembly.selectStacks(\n      { patterns: stackNames },\n      {\n        extend: exclusively ? ExtendedStackSelection.None : ExtendedStackSelection.Upstream,\n        defaultBehavior: DefaultSelection.MainAssembly,\n      },\n    );\n\n    const allStacks = await this.selectStacksForList([]);\n    const autoValidateStacks = autoValidate\n      ? allStacks.filter((art) => art.validateOnSynth ?? false)\n      : new StackCollection(assembly, []);\n\n    this.validateStacksSelected(selectedForDiff.concat(autoValidateStacks), stackNames);\n    await this.validateStacks(selectedForDiff.concat(autoValidateStacks));\n\n    return selectedForDiff;\n  }\n\n  private async selectStacksForDestroy(selector: StackSelector, exclusively?: boolean) {\n    const assembly = await this.assembly();\n    const stacks = await assembly.selectStacks(selector, {\n      extend: exclusively ? ExtendedStackSelection.None : ExtendedStackSelection.Downstream,\n      defaultBehavior: DefaultSelection.OnlySingle,\n    });\n\n    // No validation\n\n    return stacks;\n  }\n\n  /**\n   * Validate the stacks for errors and warnings according to the CLI's current settings\n   */\n  private async validateStacks(stacks: StackCollection) {\n    let failAt: 'warn' | 'error' | 'none' = 'error';\n    if (this.props.ignoreErrors) { failAt = 'none'; }\n    if (this.props.strict) { failAt = 'warn'; }\n\n    await stacks.validateMetadata(failAt, stackMetadataLogger(this.props.verbose));\n  }\n\n  /**\n   * Validate that if a user specified a stack name there exists at least 1 stack selected\n   */\n  private validateStacksSelected(stacks: StackCollection, stackNames: string[]) {\n    if (stackNames.length != 0 && stacks.stackCount == 0) {\n      throw new ToolkitError(`No stacks match the name(s) ${stackNames}`);\n    }\n  }\n\n  /**\n   * Select a single stack by its name\n   */\n  private async selectSingleStackByName(stackName: string) {\n    const assembly = await this.assembly();\n\n    const stacks = await assembly.selectStacks(\n      { patterns: [stackName] },\n      {\n        extend: ExtendedStackSelection.None,\n        defaultBehavior: DefaultSelection.None,\n      },\n    );\n\n    // Could have been a glob so check that we evaluated to exactly one\n    if (stacks.stackCount > 1) {\n      throw new ToolkitError(`This command requires exactly one stack and we matched more than one: ${stacks.stackIds}`);\n    }\n\n    return assembly.stackById(stacks.firstStack.id);\n  }\n\n  public assembly(cacheCloudAssembly?: boolean): Promise<CloudAssembly> {\n    return this.props.cloudExecutable.synthesize(cacheCloudAssembly);\n  }\n\n  private patternsArrayForWatch(\n    patterns: string | string[] | undefined,\n    options: { rootDir: string; returnRootDirIfEmpty: boolean },\n  ): string[] {\n    const patternsArray: string[] = patterns !== undefined ? (Array.isArray(patterns) ? patterns : [patterns]) : [];\n    return patternsArray.length > 0 ? patternsArray : options.returnRootDirIfEmpty ? [options.rootDir] : [];\n  }\n\n  private async invokeDeployFromWatch(\n    options: WatchOptions,\n    cloudWatchLogMonitor?: CloudWatchLogEventMonitor,\n  ): Promise<void> {\n    const deployOptions: DeployOptions = {\n      ...options,\n      requireApproval: RequireApproval.Never,\n      // if 'watch' is called by invoking 'cdk deploy --watch',\n      // we need to make sure to not call 'deploy' with 'watch' again,\n      // as that would lead to a cycle\n      watch: false,\n      cloudWatchLogMonitor,\n      cacheCloudAssembly: false,\n      hotswap: options.hotswap,\n      extraUserAgent: `cdk-watch/hotswap-${options.hotswap !== HotswapMode.FALL_BACK ? 'on' : 'off'}`,\n      concurrency: options.concurrency,\n    };\n\n    try {\n      await this.deploy(deployOptions);\n    } catch {\n      // just continue - deploy will show the error\n    }\n  }\n\n  /**\n   * Remove the asset publishing and building from the work graph for assets that are already in place\n   */\n  private async removePublishedAssets(graph: WorkGraph, options: DeployOptions) {\n    await graph.removeUnnecessaryAssets(assetNode => this.props.deployments.isSingleAssetPublished(assetNode.assetManifest, assetNode.asset, {\n      stack: assetNode.parentStack,\n      roleArn: options.roleArn,\n      stackName: assetNode.parentStack.stackName,\n    }));\n  }\n}\n\n/**\n * Print a serialized object (YAML or JSON) to stdout.\n */\nfunction printSerializedObject(obj: any, json: boolean) {\n  logResult(serializeStructure(obj, json));\n}\n\nexport interface DiffOptions {\n  /**\n   * Stack names to diff\n   */\n  stackNames: string[];\n\n  /**\n   * Name of the toolkit stack, if not the default name\n   *\n   * @default 'CDKToolkit'\n   */\n  readonly toolkitStackName?: string;\n\n  /**\n   * Only select the given stack\n   *\n   * @default false\n   */\n  exclusively?: boolean;\n\n  /**\n   * Used a template from disk instead of from the server\n   *\n   * @default Use from the server\n   */\n  templatePath?: string;\n\n  /**\n   * Strict diff mode\n   *\n   * @default false\n   */\n  strict?: boolean;\n\n  /**\n   * How many lines of context to show in the diff\n   *\n   * @default 3\n   */\n  contextLines?: number;\n\n  /**\n   * Where to write the default\n   *\n   * @default stderr\n   */\n  stream?: NodeJS.WritableStream;\n\n  /**\n   * Whether to fail with exit code 1 in case of diff\n   *\n   * @default false\n   */\n  fail?: boolean;\n\n  /**\n   * Only run diff on broadened security changes\n   *\n   * @default false\n   */\n  securityOnly?: boolean;\n\n  /**\n   * Whether to run the diff against the template after the CloudFormation Transforms inside it have been executed\n   * (as opposed to the original template, the default, which contains the unprocessed Transforms).\n   *\n   * @default false\n   */\n  compareAgainstProcessedTemplate?: boolean;\n\n  /*\n   * Run diff in quiet mode without printing the diff statuses\n   *\n   * @default false\n   */\n  quiet?: boolean;\n\n  /**\n   * Additional parameters for CloudFormation at diff time, used to create a change set\n   * @default {}\n   */\n  parameters?: { [name: string]: string | undefined };\n\n  /**\n   * Whether or not to create, analyze, and subsequently delete a changeset\n   *\n   * @default true\n   */\n  changeSet?: boolean;\n}\n\ninterface CfnDeployOptions {\n  /**\n   * Criteria for selecting stacks to deploy\n   */\n  selector: StackSelector;\n\n  /**\n   * Name of the toolkit stack to use/deploy\n   *\n   * @default CDKToolkit\n   */\n  toolkitStackName?: string;\n\n  /**\n   * Role to pass to CloudFormation for deployment\n   */\n  roleArn?: string;\n\n  /**\n   * Optional name to use for the CloudFormation change set.\n   * If not provided, a name will be generated automatically.\n   *\n   * @deprecated Use 'deploymentMethod' instead\n   */\n  changeSetName?: string;\n\n  /**\n   * Whether to execute the ChangeSet\n   * Not providing `execute` parameter will result in execution of ChangeSet\n   *\n   * @default true\n   * @deprecated Use 'deploymentMethod' instead\n   */\n  execute?: boolean;\n\n  /**\n   * Deployment method\n   */\n  readonly deploymentMethod?: DeploymentMethod;\n\n  /**\n   * Display mode for stack deployment progress.\n   *\n   * @default - StackActivityProgress.Bar - stack events will be displayed for\n   *   the resource currently being deployed.\n   */\n  progress?: StackActivityProgress;\n\n  /**\n   * Rollback failed deployments\n   *\n   * @default true\n   */\n  readonly rollback?: boolean;\n}\n\ninterface WatchOptions extends Omit<CfnDeployOptions, 'execute'> {\n  /**\n   * Only select the given stack\n   *\n   * @default false\n   */\n  exclusively?: boolean;\n\n  /**\n   * Reuse the assets with the given asset IDs\n   */\n  reuseAssets?: string[];\n\n  /**\n   * Always deploy, even if templates are identical.\n   * @default false\n   */\n  force?: boolean;\n\n  /**\n   * Whether to perform a 'hotswap' deployment.\n   * A 'hotswap' deployment will attempt to short-circuit CloudFormation\n   * and update the affected resources like Lambda functions directly.\n   *\n   * @default - `HotswapMode.FALL_BACK` for regular deployments, `HotswapMode.HOTSWAP_ONLY` for 'watch' deployments\n   */\n  readonly hotswap: HotswapMode;\n\n  /**\n   * The extra string to append to the User-Agent header when performing AWS SDK calls.\n   *\n   * @default - nothing extra is appended to the User-Agent header\n   */\n  readonly extraUserAgent?: string;\n\n  /**\n   * Whether to show CloudWatch logs for hotswapped resources\n   * locally in the users terminal\n   *\n   * @default - false\n   */\n  readonly traceLogs?: boolean;\n\n  /**\n   * Maximum number of simultaneous deployments (dependency permitting) to execute.\n   * The default is '1', which executes all deployments serially.\n   *\n   * @default 1\n   */\n  readonly concurrency?: number;\n}\n\nexport interface DeployOptions extends CfnDeployOptions, WatchOptions {\n  /**\n   * ARNs of SNS topics that CloudFormation will notify with stack related events\n   */\n  notificationArns?: string[];\n\n  /**\n   * What kind of security changes require approval\n   *\n   * @default RequireApproval.Broadening\n   */\n  requireApproval?: RequireApproval;\n\n  /**\n   * Tags to pass to CloudFormation for deployment\n   */\n  tags?: Tag[];\n\n  /**\n   * Additional parameters for CloudFormation at deploy time\n   * @default {}\n   */\n  parameters?: { [name: string]: string | undefined };\n\n  /**\n   * Use previous values for unspecified parameters\n   *\n   * If not set, all parameters must be specified for every deployment.\n   *\n   * @default true\n   */\n  usePreviousParameters?: boolean;\n\n  /**\n   * Path to file where stack outputs will be written after a successful deploy as JSON\n   * @default - Outputs are not written to any file\n   */\n  outputsFile?: string;\n\n  /**\n   * Whether we are on a CI system\n   *\n   * @default false\n   */\n  readonly ci?: boolean;\n\n  /**\n   * Whether this 'deploy' command should actually delegate to the 'watch' command.\n   *\n   * @default false\n   */\n  readonly watch?: boolean;\n\n  /**\n   * Whether we should cache the Cloud Assembly after the first time it has been synthesized.\n   * The default is 'true', we only don't want to do it in case the deployment is triggered by\n   * 'cdk watch'.\n   *\n   * @default true\n   */\n  readonly cacheCloudAssembly?: boolean;\n\n  /**\n   * Allows adding CloudWatch log groups to the log monitor via\n   * cloudWatchLogMonitor.setLogGroups();\n   *\n   * @default - not monitoring CloudWatch logs\n   */\n  readonly cloudWatchLogMonitor?: CloudWatchLogEventMonitor;\n\n  /**\n   * Maximum number of simultaneous deployments (dependency permitting) to execute.\n   * The default is '1', which executes all deployments serially.\n   *\n   * @default 1\n   */\n  readonly concurrency?: number;\n\n  /**\n   * Build/publish assets for a single stack in parallel\n   *\n   * Independent of whether stacks are being done in parallel or no.\n   *\n   * @default true\n   */\n  readonly assetParallelism?: boolean;\n\n  /**\n   * When to build assets\n   *\n   * The default is the Docker-friendly default.\n   *\n   * @default AssetBuildTime.ALL_BEFORE_DEPLOY\n   */\n  readonly assetBuildTime?: AssetBuildTime;\n\n  /**\n   * Whether to deploy if the app contains no stacks.\n   *\n   * @default false\n   */\n  readonly ignoreNoStacks?: boolean;\n}\n\nexport interface RollbackOptions {\n  /**\n   * Criteria for selecting stacks to deploy\n   */\n  readonly selector: StackSelector;\n\n  /**\n   * Name of the toolkit stack to use/deploy\n   *\n   * @default CDKToolkit\n   */\n  readonly toolkitStackName?: string;\n\n  /**\n   * Role to pass to CloudFormation for deployment\n   *\n   * @default - Default stack role\n   */\n  readonly roleArn?: string;\n\n  /**\n   * Whether to force the rollback or not\n   *\n   * @default false\n   */\n  readonly force?: boolean;\n\n  /**\n   * Logical IDs of resources to orphan\n   *\n   * @default - No orphaning\n   */\n  readonly orphanLogicalIds?: string[];\n\n  /**\n   * Whether to validate the version of the bootstrap stack permissions\n   *\n   * @default true\n   */\n  readonly validateBootstrapStackVersion?: boolean;\n}\n\nexport interface ImportOptions extends CfnDeployOptions {\n  /**\n   * Build a physical resource mapping and write it to the given file, without performing the actual import operation\n   *\n   * @default - No file\n   */\n\n  readonly recordResourceMapping?: string;\n\n  /**\n   * Path to a file with the physical resource mapping to CDK constructs in JSON format\n   *\n   * @default - No mapping file\n   */\n  readonly resourceMappingFile?: string;\n\n  /**\n   * Allow non-addition changes to the template\n   *\n   * @default false\n   */\n  readonly force?: boolean;\n}\n\nexport interface DestroyOptions {\n  /**\n   * Criteria for selecting stacks to deploy\n   */\n  selector: StackSelector;\n\n  /**\n   * Whether to exclude stacks that depend on the stacks to be deleted\n   */\n  exclusively: boolean;\n\n  /**\n   * Whether to skip prompting for confirmation\n   */\n  force: boolean;\n\n  /**\n   * The arn of the IAM role to use\n   */\n  roleArn?: string;\n\n  /**\n   * Whether the destroy request came from a deploy.\n   */\n  fromDeploy?: boolean;\n\n  /**\n   * Whether we are on a CI system\n   *\n   * @default false\n   */\n  readonly ci?: boolean;\n}\n\n/**\n * Options for the garbage collection\n */\nexport interface GarbageCollectionOptions {\n  /**\n   * The action to perform.\n   *\n   * @default 'full'\n   */\n  readonly action: 'print' | 'tag' | 'delete-tagged' | 'full';\n\n  /**\n   * The type of the assets to be garbage collected.\n   *\n   * @default 'all'\n   */\n  readonly type: 's3' | 'ecr' | 'all';\n\n  /**\n   * Elapsed time between an asset being marked as isolated and actually deleted.\n   *\n   * @default 0\n   */\n  readonly rollbackBufferDays: number;\n\n  /**\n   * Refuse deletion of any assets younger than this number of days.\n   */\n  readonly createdBufferDays: number;\n\n  /**\n   * The stack name of the bootstrap stack.\n   *\n   * @default DEFAULT_TOOLKIT_STACK_NAME\n   */\n  readonly bootstrapStackName?: string;\n\n  /**\n   * Skips the prompt before actual deletion begins\n   *\n   * @default false\n   */\n  readonly confirm?: boolean;\n}\n\nexport interface MigrateOptions {\n  /**\n   * The name assigned to the generated stack. This is also used to get\n   * the stack from the user's account if `--from-stack` is used.\n   */\n  readonly stackName: string;\n\n  /**\n   * The target language for the generated the CDK app.\n   *\n   * @default typescript\n   */\n  readonly language?: string;\n\n  /**\n   * The local path of the template used to generate the CDK app.\n   *\n   * @default - Local path is not used for the template source.\n   */\n  readonly fromPath?: string;\n\n  /**\n   * Whether to get the template from an existing CloudFormation stack.\n   *\n   * @default false\n   */\n  readonly fromStack?: boolean;\n\n  /**\n   * The output path at which to create the CDK app.\n   *\n   * @default - The current directory\n   */\n  readonly outputPath?: string;\n\n  /**\n   * The account from which to retrieve the template of the CloudFormation stack.\n   *\n   * @default - Uses the account for the credentials in use by the user.\n   */\n  readonly account?: string;\n\n  /**\n   * The region from which to retrieve the template of the CloudFormation stack.\n   *\n   * @default - Uses the default region for the credentials in use by the user.\n   */\n  readonly region?: string;\n\n  /**\n   * Filtering criteria used to select the resources to be included in the generated CDK app.\n   *\n   * @default - Include all resources\n   */\n  readonly filter?: string[];\n\n  /**\n   * Whether to initiate a new account scan for generating the CDK app.\n   *\n   * @default false\n   */\n  readonly fromScan?: FromScan;\n\n  /**\n   * Whether to zip the generated cdk app folder.\n   *\n   * @default false\n   */\n  readonly compress?: boolean;\n}\n\nfunction buildParameterMap(\n  parameters:\n  | {\n    [name: string]: string | undefined;\n  }\n  | undefined,\n): { [name: string]: { [name: string]: string | undefined } } {\n  const parameterMap: {\n    [name: string]: { [name: string]: string | undefined };\n  } = { '*': {} };\n  for (const key in parameters) {\n    if (parameters.hasOwnProperty(key)) {\n      const [stack, parameter] = key.split(':', 2);\n      if (!parameter) {\n        parameterMap['*'][stack] = parameters[key];\n      } else {\n        if (!parameterMap[stack]) {\n          parameterMap[stack] = {};\n        }\n        parameterMap[stack][parameter] = parameters[key];\n      }\n    }\n  }\n\n  return parameterMap;\n}\n\n/**\n * Ask the user for a yes/no confirmation\n *\n * Automatically fail the confirmation in case we're in a situation where the confirmation\n * cannot be interactively obtained from a human at the keyboard.\n */\nasync function askUserConfirmation(\n  ioHost: CliIoHost,\n  concurrency: number,\n  motivation: string,\n  question: string,\n) {\n  await ioHost.withCorkedLogging(async () => {\n    // only talk to user if STDIN is a terminal (otherwise, fail)\n    if (!TESTING && !process.stdin.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    const confirmed = await promptly.confirm(`${chalk.cyan(question)} (y/n)?`);\n    if (!confirmed) { throw new ToolkitError('Aborted by user'); }\n  });\n}\n\n/**\n * Logger for processing stack metadata\n */\nfunction stackMetadataLogger(verbose?: boolean): (level: 'info' | 'error' | 'warn', msg: cxapi.SynthesisMessage) => Promise<void> {\n  const makeLogger = (level: string): [logger: (m: string) => void, prefix: string] => {\n    switch (level) {\n      case 'error':\n        return [error, 'Error'];\n      case 'warn':\n        return [warning, 'Warning'];\n      default:\n        return [info, 'Info'];\n    }\n  };\n\n  return async (level, msg) => {\n    const [logFn, prefix] = makeLogger(level);\n    logFn(`[${prefix} at ${msg.id}] ${msg.entry.data}`);\n\n    if (verbose && msg.entry.trace) {\n      logFn(`  ${msg.entry.trace.join('\\n  ')}`);\n    }\n  };\n}\n"]}