aws-cdk
Version:
AWS CDK Toolkit CLI, the command line tool for CDK apps
1,787 lines • 320 kB
JavaScript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
if (value !== null && value !== void 0) {
if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
var dispose, inner;
if (async) {
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
dispose = value[Symbol.asyncDispose];
}
if (dispose === void 0) {
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
dispose = value[Symbol.dispose];
if (async) inner = dispose;
}
if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
env.stack.push({ value: value, dispose: dispose, async: async });
}
else if (async) {
env.stack.push({ async: true });
}
return value;
};
var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
return function (env) {
function fail(e) {
env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
env.hasError = true;
}
var r, s = 0;
function next() {
while (r = env.stack.pop()) {
try {
if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
if (r.dispose) {
var result = r.dispose.call(r.value);
if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
}
else s |= 1;
}
catch (e) {
fail(e);
}
}
if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
if (env.hasError) throw env.error;
}
return next();
};
})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
});
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.CdkToolkit = exports.AssetBuildTime = void 0;
exports.displayFlagsMessage = displayFlagsMessage;
const node_crypto_1 = require("node:crypto");
const path = __importStar(require("node:path"));
const node_util_1 = require("node:util");
const cxapi = __importStar(require("@aws-cdk/cloud-assembly-api"));
const cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema");
const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
const chalk_1 = __importDefault(require("chalk"));
const chokidar = __importStar(require("chokidar"));
const handler_js_1 = require("chokidar/handler.js");
const fs = __importStar(require("fs-extra"));
const io_host_1 = require("./io-host");
const user_configuration_1 = require("./user-configuration");
const api_private_1 = require("../../lib/api-private");
const api_1 = require("../api");
const bootstrap_1 = require("../api/bootstrap");
const cloud_assembly_1 = require("../api/cloud-assembly");
const deploy_private_1 = require("../api/deploy-private");
const refactor_1 = require("../api/refactor");
const deploy_1 = require("../commands/deploy");
const list_stacks_1 = require("../commands/list-stacks");
const migrate_1 = require("../commands/migrate");
const cxapp_1 = require("../cxapp");
const util_1 = require("../util");
const collect_telemetry_1 = require("./telemetry/collect-telemetry");
const error_1 = require("./telemetry/error");
const messages_1 = require("./telemetry/messages");
const operations_1 = require("../commands/flags/operations");
// Must use a require() otherwise esbuild complains about calling a namespace
// eslint-disable-next-line @typescript-eslint/no-require-imports,@typescript-eslint/consistent-type-imports
const pLimit = require('p-limit');
/**
* File events that we care about from chokidar.
* In chokidar v4, EventName includes additional events like 'error', 'raw', 'ready', 'all'
* that we need to filter out in the 'all' handler.
*/
const FILE_EVENTS = [handler_js_1.EVENTS.ADD, handler_js_1.EVENTS.ADD_DIR, handler_js_1.EVENTS.CHANGE, handler_js_1.EVENTS.UNLINK, handler_js_1.EVENTS.UNLINK_DIR];
/**
* Type guard to check if an event is a file event we should process.
*/
function isFileEvent(event) {
return FILE_EVENTS.includes(event);
}
/**
* 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["ALL_BEFORE_DEPLOY"] = "all-before-deploy";
/**
* Build assets just-in-time, before publishing
*/
AssetBuildTime["JUST_IN_TIME"] = "just-in-time";
})(AssetBuildTime || (exports.AssetBuildTime = AssetBuildTime = {}));
/**
* Custom implementation of the public Toolkit to integrate with the legacy CdkToolkit
*
* This overwrites how an sdkProvider is acquired
* in favor of the one provided directly to CdkToolkit.
*/
class InternalToolkit extends toolkit_lib_1.Toolkit {
_sdkProvider;
constructor(sdkProvider, options) {
super(options);
this._sdkProvider = sdkProvider;
}
/**
* Access to the AWS SDK
* @internal
*/
async sdkProvider(_action) {
return this._sdkProvider;
}
}
/**
* Toolkit logic
*
* The toolkit runs the `cloudExecutable` to obtain a cloud assembly and
* deploys applies them to `cloudFormation`.
*/
class CdkToolkit {
props;
ioHost;
toolkitStackName;
toolkit;
constructor(props) {
this.props = props;
this.ioHost = props.ioHost ?? io_host_1.CliIoHost.instance();
this.toolkitStackName = props.toolkitStackName ?? api_1.DEFAULT_TOOLKIT_STACK_NAME;
// We don't have the toolkit check unstable features. Instead, the error
// messages the CLI give are slightly different, and so they need to be checked
// separately. Instead, the Toolkit we use has all unstable features automatically
// enabled.
const iPromiseUnstablenessIsCheckedByTheCli = {
'publish-assets': true,
'diagnose': true,
'flags': true,
'orphan': true,
'refactor': true,
'validate': true,
};
this.toolkit = new InternalToolkit(props.sdkProvider, {
assemblyFailureAt: this.validateMetadataFailAt(),
color: true,
emojis: true,
ioHost: this.ioHost,
toolkitStackName: this.toolkitStackName,
unstableFeatures: Object.keys(iPromiseUnstablenessIsCheckedByTheCli),
});
}
async metadata(stackName, json) {
const env_1 = { stack: [], error: void 0, hasError: false };
try {
const _formatter = __addDisposableResource(env_1, this.ioHost.once(api_private_1.IO.CDK_TOOLKIT_I2901, (msg) => ({
action: 'metadata',
message: (0, util_1.serializeStructure)(msg.data.stacks[0]?.metadata ?? {}, json),
})), false);
await this.toolkit.list(this.props.cloudExecutable, {
stacks: {
patterns: [stackName],
strategy: api_1.StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE,
expand: cloud_assembly_1.ExpandStackSelection.NONE,
},
});
}
catch (e_1) {
env_1.error = e_1;
env_1.hasError = true;
}
finally {
__disposeResources(env_1);
}
}
async acknowledge(noticeId) {
const issueNumber = Number(noticeId);
if (!Number.isInteger(issueNumber)) {
throw new toolkit_lib_1.ToolkitError('InvalidAcknowledgementId', `Invalid notice ID '${noticeId}': 'cdk acknowledge' only accepts numeric notice IDs (e.g. 'cdk acknowledge 12345'). ` +
'Scoped construct warnings such as \'@aws-cdk/aws-ecs:minHealthyPercent\' are acknowledged in code with ' +
'Annotations.of(scope).acknowledgeWarning(\'<id>\').');
}
const acks = new Set(this.props.configuration.context.get('acknowledged-issue-numbers') ?? []);
acks.add(issueNumber);
this.props.configuration.context.set('acknowledged-issue-numbers', Array.from(acks));
await this.props.configuration.saveContext();
}
async cliTelemetryStatus(args) {
const canCollect = (0, collect_telemetry_1.canCollectTelemetry)(args, this.props.configuration.context);
if (canCollect) {
await this.ioHost.asIoHelper().defaults.info('CLI Telemetry is enabled. See https://docs.aws.amazon.com/cdk/v2/guide/cli-telemetry.html for ways to disable.');
}
else {
await this.ioHost.asIoHelper().defaults.info('CLI Telemetry is disabled. See https://docs.aws.amazon.com/cdk/v2/guide/cli-telemetry.html for ways to enable.');
}
}
async cliTelemetry(enable) {
this.props.configuration.context.set('cli-telemetry', enable);
await this.props.configuration.saveContext();
await this.ioHost.asIoHelper().defaults.info(`Telemetry ${enable ? 'enabled' : 'disabled'}`);
}
async diff(options) {
const assembly = await this.assembly();
const stacks = await this.selectTopLevelOrMatchingStacks(assembly, options.stackNames, options.exclusively);
await this.validateStacks(stacks);
const strict = !!options.strict;
const contextLines = options.contextLines || 3;
const quiet = options.quiet || false;
const failOn = options.failOn ?? cloud_assembly_schema_1.RequireApproval.NEVER;
let diffs = 0;
let hasBroadeningChanges = false;
const destructiveChanges = [];
const parameterMap = buildParameterMap(options.parameters);
if (options.templatePath !== undefined) {
// Compare single stack against fixed template
if (stacks.stackCount !== 1) {
throw new toolkit_lib_1.ToolkitError('SingleStackRequired', '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 toolkit_lib_1.ToolkitError('TemplateNotFound', `There is no file at ${options.templatePath}`);
}
if (options.importExistingResources) {
throw new toolkit_lib_1.ToolkitError('ImportWithTemplatePath', 'Can only use --import-existing-resources flag when comparing against deployed stacks.');
}
const template = (0, util_1.deserializeStructure)(await fs.readFile(options.templatePath, { encoding: 'utf-8' }));
const formatter = new api_1.DiffFormatter({
templateInfo: {
oldTemplate: template,
newTemplate: stacks.firstStack,
},
});
if (options.securityOnly) {
const securityDiff = formatter.formatSecurityDiff({ quiet });
// Warn, count, and display the diff only if the reported changes are broadening permissions
if (securityDiff.permissionChangeType === toolkit_lib_1.PermissionChangeType.BROADENING) {
hasBroadeningChanges = true;
await this.ioHost.asIoHelper().defaults.warn('This deployment will make potentially sensitive changes according to your current security approval level.\nPlease confirm you intend to make the following modifications:\n');
await this.ioHost.asIoHelper().defaults.info(securityDiff.formattedDiff);
diffs += securityDiff.numStacksWithChanges;
}
}
else {
const diff = formatter.formatStackDiff({
strict,
contextLines,
quiet,
});
diffs = diff.numStacksWithChanges;
await this.ioHost.asIoHelper().defaults.info(diff.formattedDiff);
if (failOn === cloud_assembly_schema_1.RequireApproval.BROADENING) {
hasBroadeningChanges = formatter.formatSecurityDiff().permissionChangeType === toolkit_lib_1.PermissionChangeType.BROADENING;
}
}
if (failOn === cloud_assembly_schema_1.RequireApproval.DESTRUCTIVE) {
destructiveChanges.push(...(0, api_1.findDestructiveChanges)(formatter.displayedDiffs, formatter.constructPaths));
}
}
else {
const allMappings = options.includeMoves
? await (0, refactor_1.mappingsByEnvironment)(stacks.stackArtifacts, this.props.sdkProvider, true)
: [];
// 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 environment = await this.props.deployments.resolveEnvironment(stack);
const migrator = new api_1.ResourceMigrator({
deployments: this.props.deployments,
ioHelper: (0, api_private_1.asIoHelper)(this.ioHost, 'diff'),
});
const resourcesToImport = await migrator.tryGetResources(environment);
if (resourcesToImport) {
(0, api_1.removeNonImportResources)(stack);
}
const changeSet = (options.method !== 'template')
? (await this.tryCreateDiffChangeSet(stack, options, parameterMap, resourcesToImport, quiet))?.changeSet
: undefined;
const mappings = allMappings.find(m => m.environment.region === stack.environment.region && m.environment.account === stack.environment.account)?.mappings ?? {};
const formatter = new api_1.DiffFormatter({
templateInfo: {
oldTemplate: currentTemplate,
newTemplate: stack,
changeSet,
isImport: !!resourcesToImport,
nestedStacks,
mappings,
environment,
},
});
if (options.securityOnly) {
const securityDiff = formatter.formatSecurityDiff({ quiet });
// Warn, count, and display the diff only if the reported changes are broadening permissions
if (securityDiff.permissionChangeType === toolkit_lib_1.PermissionChangeType.BROADENING) {
hasBroadeningChanges = true;
await this.ioHost.asIoHelper().defaults.warn('This deployment will make potentially sensitive changes according to your current security approval level.\nPlease confirm you intend to make the following modifications:\n');
await this.ioHost.asIoHelper().defaults.info(securityDiff.formattedDiff);
diffs += securityDiff.numStacksWithChanges;
}
}
else {
const diff = formatter.formatStackDiff({
strict,
contextLines,
quiet,
});
await this.ioHost.asIoHelper().defaults.info(diff.formattedDiff);
diffs += diff.numStacksWithChanges;
if (failOn === cloud_assembly_schema_1.RequireApproval.BROADENING
&& formatter.formatSecurityDiff().permissionChangeType === toolkit_lib_1.PermissionChangeType.BROADENING) {
hasBroadeningChanges = true;
}
}
if (failOn === cloud_assembly_schema_1.RequireApproval.DESTRUCTIVE) {
destructiveChanges.push(...(0, api_1.findDestructiveChanges)(formatter.displayedDiffs, formatter.constructPaths));
}
}
}
await this.ioHost.asIoHelper().defaults.info((0, node_util_1.format)('\n✨ Number of stacks with differences: %s\n', diffs));
if (destructiveChanges.length > 0) {
const lines = destructiveChanges.map(c => ` ${(0, api_1.formatDestructiveChange)(c)}`);
await this.ioHost.asIoHelper().defaults.error(`❌ Found ${destructiveChanges.length} destructive change(s) (--fail-on=destructive):\n${lines.join('\n')}\n`);
}
return diffFails(failOn, diffs, hasBroadeningChanges, destructiveChanges.length > 0) ? 1 : 0;
}
/**
* Try to create a diff changeset for the given stack.
* Returns undefined if the stack cannot be accessed and changeSetOnly is not set.
*/
async tryCreateDiffChangeSet(stack, options, parameterMap, resourcesToImport, quiet) {
try {
// we don't actually need to know if the stack exists here
// we just use this to flush our any permissions issues and drop the result
void await this.props.deployments.stackExists({
stack,
deployName: stack.stackName,
tryLookupRole: true,
});
}
catch (e) {
if (options.method === 'change-set') {
throw toolkit_lib_1.ToolkitError.withCause('DescribeStacksFailed', `Could not access stack '${stack.stackName}'. Please check your permissions or use '--method=auto' to allow falling back to a template diff.`, e);
}
await this.ioHost.asIoHelper().defaults.debug((0, util_1.formatErrorMessage)(e));
if (!quiet) {
await this.ioHost.asIoHelper().defaults.info(`Could not access stack '${stack.stackName}', falling back to template diff. Use '--method=change-set' to fail instead. Run with -v to see the reason.\n`);
}
return undefined;
}
return api_private_1.cfnApi.createDiffChangeSet((0, api_private_1.asIoHelper)(this.ioHost, 'diff'), {
stack,
uuid: (0, node_crypto_1.randomUUID)(),
deployments: this.props.deployments,
sdkProvider: this.props.sdkProvider,
parameters: Object.assign({}, parameterMap['*'], parameterMap[stack.stackName]),
resourcesToImport,
importExistingResources: options.importExistingResources,
changeSetName: options.changeSetName,
failOnError: options.method === 'change-set',
});
}
async deploy(options) {
const env_2 = { stack: [], error: void 0, hasError: false };
try {
if (options.watch) {
return this.watch(options);
}
// set progress from options, this includes user and app config
if (options.progress) {
this.ioHost.stackProgress = options.progress;
}
// the ioHost uses this internally to determine if a confirmation
// is actually needed, so it needs the same value we determine here.
const requireApproval = options.requireApproval ?? cloud_assembly_schema_1.RequireApproval.BROADENING;
this.ioHost.requireDeployApproval = requireApproval;
// toolkit-lib emits the approval request (I5060) without mentioning
// `--require-approval`. The CLI owns that flag, so it adds the framing here.
// Both deploy paths resolve through this host, so one listener covers both.
// Method-scoped (`using`): `deploy()` can run repeatedly (watch mode), and
// each run must register a rewrite for its own `requireApproval` value.
const _approvalFraming = __addDisposableResource(env_2, this.ioHost.rewrite(api_private_1.IO.CDK_TOOLKIT_I5060, (msg) => {
const updateTypeText = requireApproval === cloud_assembly_schema_1.RequireApproval.DESTRUCTIVE
? 'destructive updates'
: msg.data.permissionChangeType !== toolkit_lib_1.PermissionChangeType.NONE
? 'security-sensitive updates'
: 'updates';
return `Stack includes ${updateTypeText} and "--require-approval" is set to '${requireApproval}'.\nDo you wish to deploy these changes?`;
}), false);
// execute-change-set is a new flow that we can just delegate to toolkit-lib
if (options.deploymentMethod?.method === 'execute-change-set') {
await this.toolkit.deploy(this.props.cloudExecutable, {
deploymentMethod: options.deploymentMethod,
stacks: {
patterns: options.selector.patterns,
strategy: api_1.StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE,
expand: cloud_assembly_1.ExpandStackSelection.NONE,
},
roleArn: options.roleArn,
forceDeployment: options.force,
rollback: options.rollback,
reuseAssets: options.reuseAssets,
concurrency: options.concurrency,
traceLogs: options.traceLogs,
notificationArns: options.notificationArns,
tags: options.tags,
outputsFile: options.outputsFile,
assetParallelism: options.assetParallelism,
assetBuildConcurrency: options.assetBuildConcurrency,
assetBuildTime: options.assetBuildTime,
parameters: undefined, // parameters are only set during change set creation, so this is explicitly unset because change set already exists
});
return;
}
const startSynthTime = new Date().getTime();
const assembly = await this.assembly(options.cacheCloudAssembly);
const stackCollection = await assembly.selectStacks(options.selector);
await this.validateStacks(stackCollection);
const elapsedSynthTime = new Date().getTime() - startSynthTime;
await this.ioHost.asIoHelper().defaults.info(`\n✨ Synthesis time: ${(0, util_1.formatTime)(elapsedSynthTime)}s\n`);
if (stackCollection.stackCount === 0) {
await this.ioHost.asIoHelper().defaults.error('This app contains no stacks');
return;
}
const migrator = new api_1.ResourceMigrator({
deployments: this.props.deployments,
ioHelper: (0, api_private_1.asIoHelper)(this.ioHost, 'deploy'),
});
await migrator.tryMigrateResources(stackCollection, {
toolkitStackName: this.toolkitStackName,
...options,
});
if (options.deploymentMethod?.method === 'hotswap') {
await this.ioHost.asIoHelper().defaults.warn('⚠️ The --hotswap and --hotswap-fallback flags deliberately introduce CloudFormation drift to speed up deployments');
await this.ioHost.asIoHelper().defaults.warn('⚠️ They should only be used for development - never use them for your production Stacks!\n');
}
const stacks = stackCollection.stackArtifacts;
const assetBuildTime = options.assetBuildTime ?? AssetBuildTime.ALL_BEFORE_DEPLOY;
const prebuildAssets = assetBuildTime === AssetBuildTime.ALL_BEFORE_DEPLOY;
const concurrency = options.concurrency || 1;
if (concurrency > 1) {
// the "bar" progress output doesn't support concurrency, fall back to "events"
if (this.ioHost.stackProgress === deploy_1.StackActivityProgress.BAR) {
this.ioHost.stackProgress = deploy_1.StackActivityProgress.EVENTS;
}
// ...but only warn if the user explicitly requested "bar" progress
if (options.progress === deploy_1.StackActivityProgress.BAR) {
await this.ioHost.asIoHelper().defaults.warn('⚠️ The --concurrency flag does not support --progress "bar". Switching to "events".');
}
}
const stacksAndTheirAssetManifests = stacks.flatMap((stack) => [
stack,
...stack.dependencies.filter(x => cxapi.AssetManifestArtifact.isAssetManifestArtifact(x)),
]);
const workGraph = new api_1.WorkGraphBuilder((0, api_private_1.asIoHelper)(this.ioHost, 'deploy'), 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': (options.assetParallelism ?? true) ? options.assetBuildConcurrency ?? 1 : 1, // This will be CPU-bound/memory bound, mostly matters for Docker builds
'asset-publish': (options.assetParallelism ?? true) ? 8 : 1, // This will be I/O-bound, 8 in parallel seems reasonable
'marker': 1,
};
const deploymentActions = new WorkGraphDeploymentActions(this.props.deployments, this.ioHost, this, {
roleArn: options.roleArn,
force: options.force,
stackCount: stackCollection.stackCount,
notificationArns: options.notificationArns,
deploymentMethod: options.deploymentMethod,
toolkitStackName: this.toolkitStackName,
reuseAssets: options.reuseAssets,
tags: options.tags,
parameters: options.parameters,
usePreviousParameters: options.usePreviousParameters,
rollback: options.rollback,
concurrency,
requireApproval,
assetParallelism: options.assetParallelism,
extraUserAgent: options.extraUserAgent,
cloudWatchLogMonitor: options.cloudWatchLogMonitor,
sdkProvider: this.props.sdkProvider,
express: options.express,
});
const startDeployTime = Date.now();
await workGraph.doParallel(graphConcurrency, deploymentActions);
if (options.outputsFile) {
// 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.
await deploymentActions.writeOutputs(options.outputsFile);
}
// Add a timer on the COMMAND span for the full deployment wait time (not the same as the sum of all DEPLOY
// spans because of parallelism).
this.ioHost.telemetry?.commandSpan?.addTimer('totalDeployTime', Date.now() - startDeployTime);
await this.ioHost.asIoHelper().defaults.info(`\n✨ Total time: ${(0, util_1.formatTime)(Date.now() - startSynthTime)}s\n`);
}
catch (e_2) {
env_2.error = e_2;
env_2.hasError = true;
}
finally {
__disposeResources(env_2);
}
}
/**
* Detect infrastructure drift for the given stack(s)
*/
async drift(options) {
const driftResults = await this.toolkit.drift(this.props.cloudExecutable, {
stacks: options.selector,
});
const totalDrifts = Object.values(driftResults).reduce((total, current) => total + (current.numResourcesWithDrift ?? 0), 0);
return totalDrifts > 0 && options.fail ? 1 : 0;
}
/**
* Validate synthesized templates against policy rules
*/
async validate(options) {
// Implicitly switch 'debug' mode to true; more stack traces = more useful.
this.props.cloudExecutable.switchOnDebugging();
// `watch` is a CLI-only flag; strip it before crossing into toolkit-lib so
// it does not leak into the library's validate action.
const { watch, ...validateOptions } = options;
if (watch) {
return this.validateWatch(validateOptions);
}
const result = await this.toolkit.validate(this.props.cloudExecutable, validateOptions);
return result.conclusion === 'failure' ? 1 : 0;
}
/**
* Continuously validate the project, re-synthesizing and re-validating on
* every file change. Never deploys.
*
* The files to observe are configured with the "watch" key of `cdk.json`,
* exactly like `cdk deploy --watch`.
*/
async validateWatch(options) {
const rootDir = path.dirname(path.resolve(user_configuration_1.PROJECT_CONFIG));
const watchSettings = this.props.configuration.settings.get(['watch']);
if (!watchSettings) {
throw new toolkit_lib_1.ToolkitError('WatchConfigMissing', "Cannot use '--watch' without specifying at least one directory to monitor. " +
'Make sure to add a "watch" key to your cdk.json');
}
const include = this.patternsArrayForWatch(watchSettings.include, {
defaultPattern: '**',
returnDefaultIfEmpty: true,
});
// Pass the user's excludes explicitly; toolkit-lib always appends the
// outdir, dot-file, and node_modules excludes on top of these.
const exclude = this.patternsArrayForWatch(watchSettings.exclude, {
defaultPattern: '',
returnDefaultIfEmpty: false,
});
const watcher = await this.toolkit.watchValidate(this.props.cloudExecutable.uncachedSource(), {
...options,
watchDir: rootDir,
include,
exclude,
});
return watcher.waitForEnd();
}
/**
* Diagnose errors
*/
async diagnose(options) {
// Implicitly switch 'debug' mode to true; more stack traces = more useful.
this.props.cloudExecutable.switchOnDebugging();
const results = await this.toolkit.diagnose(this.props.cloudExecutable, options);
if (results.stacks.some(s => s.result.type !== 'no-problem')) {
return 1;
}
return 0;
}
/**
* Roll back the given stack or stacks.
*/
async rollback(options) {
const startSynthTime = new Date().getTime();
const assembly = await this.assembly();
const stackCollection = await assembly.selectStacks(options.selector);
await this.validateStacks(stackCollection);
const elapsedSynthTime = new Date().getTime() - startSynthTime;
await this.ioHost.asIoHelper().defaults.info(`\n✨ Synthesis time: ${(0, util_1.formatTime)(elapsedSynthTime)}s\n`);
if (stackCollection.stackCount === 0) {
await this.ioHost.asIoHelper().defaults.error('No stacks selected');
return;
}
let anyRollbackable = false;
for (const stack of stackCollection.stackArtifacts) {
await this.ioHost.asIoHelper().defaults.info('Rolling back %s', chalk_1.default.bold(stack.displayName));
const startRollbackTime = new Date().getTime();
try {
const result = await this.props.deployments.rollbackStack({
stack,
roleArn: options.roleArn,
toolkitStackName: options.toolkitStackName,
orphanFailedResources: options.force,
validateBootstrapStackVersion: options.validateBootstrapStackVersion,
orphanLogicalIds: options.orphanLogicalIds,
});
if (!result.notInRollbackableState) {
anyRollbackable = true;
}
const elapsedRollbackTime = new Date().getTime() - startRollbackTime;
await this.ioHost.asIoHelper().defaults.info(`\n✨ Rollback time: ${(0, util_1.formatTime)(elapsedRollbackTime).toString()}s\n`);
}
catch (e) {
await this.ioHost.asIoHelper().defaults.error('\n ❌ %s failed: %s', chalk_1.default.bold(stack.displayName), (0, util_1.formatErrorMessage)(e));
throw new toolkit_lib_1.ToolkitError('RollbackFailed', 'Rollback failed (use --force to orphan failing resources)');
}
}
if (!anyRollbackable) {
throw new toolkit_lib_1.ToolkitError('NoRollbackableStacks', 'No stacks were in a state that could be rolled back');
}
}
async publishAssets(options) {
await this.toolkit.publishAssets(this.props.cloudExecutable, options);
}
async watch(options) {
const rootDir = path.dirname(path.resolve(user_configuration_1.PROJECT_CONFIG));
const ioHelper = (0, api_private_1.asIoHelper)(this.ioHost, 'watch');
await this.ioHost.asIoHelper().defaults.debug("root directory used for 'watch' is: %s", rootDir);
const watchSettings = this.props.configuration.settings.get(['watch']);
if (!watchSettings) {
throw new toolkit_lib_1.ToolkitError('WatchConfigMissing', "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.
// Note: We use '**' as the default pattern (not rootDir) because chokidar reports
// file paths relative to cwd, and the ignored function uses picomatch which expects
// glob patterns, not absolute paths.
const watchIncludes = this.patternsArrayForWatch(watchSettings.include, {
defaultPattern: '**',
returnDefaultIfEmpty: true,
});
await this.ioHost.asIoHelper().defaults.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, {
defaultPattern: '',
returnDefaultIfEmpty: false,
}).concat(`${outputDir}/**`, '**/.*', '**/.*/**', '**/node_modules/**');
await this.ioHost.asIoHelper().defaults.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 api_1.CloudWatchLogEventMonitor({
ioHelper,
}) : undefined;
const deployAndWatch = async () => {
latch = 'deploying';
await 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';
await this.ioHost.asIoHelper().defaults.info("Detected file changes during deployment. Invoking 'cdk deploy' again");
await this.invokeDeployFromWatch(options, cloudWatchLogMonitor);
}
latch = 'open';
await cloudWatchLogMonitor?.activate();
};
// Create ignore matcher for chokidar v4 compatibility
// Chokidar v4 removed glob pattern support, so we use picomatch to filter files
// We pass rootDir because chokidar v4 passes absolute paths to the ignored callback
const shouldIgnore = (0, api_private_1.createIgnoreMatcher)({
include: watchIncludes,
exclude: watchExcludes,
rootDir,
});
const outputsFile = options.outputsFile ? path.resolve(options.outputsFile) : undefined;
chokidar
.watch('.', {
ignored: (filePath, stats) => path.resolve(rootDir, filePath) === outputsFile ||
shouldIgnore(filePath, stats),
cwd: rootDir,
})
.on('ready', async () => {
latch = 'open';
await this.ioHost.asIoHelper().defaults.debug("'watch' received the 'ready' event. From now on, all file changes will trigger a deployment");
await this.ioHost.asIoHelper().defaults.info("Triggering initial 'cdk deploy'");
await deployAndWatch();
})
.on('all', async (event, filePath) => {
if (!isFileEvent(event)) {
return; // Ignore non-file events like 'error', 'raw', 'ready', 'all'
}
if (latch === 'pre-ready') {
await this.ioHost.asIoHelper().defaults.info(`'watch' is observing ${event === 'addDir' ? 'directory' : 'the file'} '%s' for changes`, filePath);
}
else if (latch === 'open') {
await this.ioHost.asIoHelper().defaults.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';
await this.ioHost.asIoHelper().defaults.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 orphan(options) {
await this.toolkit.orphan(this.props.cloudExecutable, {
constructPaths: options.constructPath,
roleArn: options.roleArn,
toolkitStackName: options.toolkitStackName,
});
}
async import(options) {
const assembly = await this.assembly();
const stacks = await assembly.selectStacks(options.selector);
await this.validateStacks(stacks);
// set progress from options, this includes user and app config
if (options.progress) {
this.ioHost.stackProgress = options.progress;
}
if (stacks.stackCount > 1) {
throw new toolkit_lib_1.ToolkitError('AmbiguousStackSelection', `Stack selection is ambiguous, please choose a specific stack for import [${stacks.stackArtifacts.map((x) => x.id).join(', ')}]`);
}
if (!process.stdout.isTTY && !options.resourceMappingFile && !options.resourceMappingInline) {
throw new toolkit_lib_1.ToolkitError('ResourceMappingRequired', '--resource-mapping or --resource-mapping-inline is required when input is not a terminal');
}
const stack = stacks.stackArtifacts[0];
await this.ioHost.asIoHelper().defaults.info(chalk_1.default.bold(stack.displayName));
const resourceImporter = new api_1.ResourceImporter(stack, {
deployments: this.props.deployments,
ioHelper: (0, api_private_1.asIoHelper)(this.ioHost, 'import'),
});
const { additions, hasNonAdditions, diffFormatter } = await resourceImporter.discoverImportableResources(options.force);
// If there are non-addition changes (e.g. after orphan, hardcoded refs differ from Fn::GetAtt),
// warn the user and ask for confirmation unless --force was given.
if (hasNonAdditions && !options.force) {
const ioHelper = this.ioHost.asIoHelper();
await ioHelper.defaults.info(`The following resources have pending updates that will be reconciled with a ${chalk_1.default.blueBright('cdk deploy')} after import:`);
const { formattedDiff } = diffFormatter.formatStackDiff();
await ioHelper.defaults.info(formattedDiff);
const confirmed = await ioHelper.requestResponse(api_private_1.IO.CDK_TOOLKIT_I7010.req('Perform import?', { motivation: 'Confirm import with pending drift' }));
if (!confirmed) {
throw new toolkit_lib_1.AbortError('ImportAborted', 'Import cancelled');
}
}
if (additions.length === 0) {
await this.ioHost.asIoHelper().defaults.warn('%s: no new resources compared to the currently deployed stack, skipping import.', chalk_1.default.bold(stack.displayName));
return;
}
// Prepare a mapping of physical resources to CDK constructs
let actualImport;
if (options.resourceMappingInline) {
actualImport = await resourceImporter.loadResourceIdentifiers(additions, options.resourceMappingInline);
}
else if (options.resourceMappingFile) {
actualImport = await resourceImporter.loadResourceIdentifiersFromFile(additions, options.resourceMappingFile);
}
else {
actualImport = await resourceImporter.askForResourceIdentifiers(additions);
}
if (actualImport.importResources.length === 0) {
await this.ioHost.asIoHelper().defaults.warn('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',
});
await this.ioHost.asIoHelper().defaults.info('%s: mapping file written.', outputFile);
return;
}
// 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)
? (options.notificationArns ?? []).concat(stack.notificationArns ?? [])
: undefined;
for (const notificationArn of notificationArns ?? []) {
if (!(0, util_1.validateSnsTopicArn)(notificationArn)) {
throw new toolkit_lib_1.ToolkitError('InvalidSnsTopicArn', `Notification arn ${notificationArn} is not a valid arn for an SNS topic`);
}
}
// Import the resources according to the given mapping
await this.ioHost.asIoHelper().defaults.info('%s: importing resources into stack...', chalk_1.default.bold(stack.displayName));
await resourceImporter.importResourcesFromMap(actualImport, {
roleArn: options.roleArn,
deploymentMethod: options.deploymentMethod,
usePreviousParameters: true,
rollback: options.rollback,
notificationArns,
});
// Notify user of next steps
if (actualImport.importResources.length < additions.length) {
await this.ioHost.asIoHelper().defaults.warn(`Some resources were skipped. Run another ${chalk_1.default.blueBright('cdk import')} or a ${chalk_1.default.blueBright('cdk deploy')} to bring the stack up-to-date with your CDK app definition.`);
}
else if (hasNonAdditions) {
// After orphan→import, the deployed template still has hardcoded values that differ from
// the synth'd template's Fn::GetAtt/Ref intrinsics. A deploy updates the template to match the CDK app.
if (options.force) {
await this.ioHost.asIoHelper().defaults.info(`Import complete. Run ${chalk_1.default.blueBright('cdk deploy')} to update the stack to match your CDK app.`);
}
else {
const deployNow = await this.ioHost.asIoHelper().requestResponse(api_private_1.IO.CDK_TOOLKIT_I7010.req(`Finish with a ${chalk_1.default.blueBright('cdk deploy')} now?`, { motivation: 'Update stack to match CDK app after import' }));
if (deployNow) {
await this.deploy({
// The import selector is exact (no expansion); the follow-up deploy
// historically expands to upstream dependencies like a plain deploy.
selector: { ...options.selector, expand: cloud_assembly_1.ExpandStackSelection.UPSTREAM },
toolkitStackName: options.toolkitStackName,
roleArn: options.roleArn,
deploymentMethod: options.deploymentMethod,
});
}
else {
await this.ioHost.asIoHelper().defaults.info(`Import complete. Remember to run ${chalk_1.default.blueBright('cdk deploy')} to update the stack to match your CDK app.`);
}
}
}
else {
await this.ioHost.asIoHelper().defaults.info(`Import operation complete. We recommend you run a ${chalk_1.default.blueBright('drift detection')} operation ` +
'to confirm your CDK app resource definitions are up-to-date. Read more here: ' +
chalk_1.default.underline.blueBright('https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/detect-drift-stack.html'));
}
}
// The destroy action runs through toolkit-lib.
// Suppress its new status messages to keep the output as it was before.
async destroy(options) {
const env_3 = { stack: [], error: void 0, hasError: false };
try {
// Keep the "deployed" wording when a destroy runs as part of a deploy.
const action = options.fromDeploy ? 'deploy' : 'destroy';
if ((options.concurrency || 1) > 1 && this.ioHost.stackProgress === deploy_1.StackActivityProgress.BAR) {
this.ioHost.stackProgress = deploy_1.StackActivityProgress.EVENTS;
}
// The success line was `info` in the historical `cdk destroy`, not `result`.
const _successLevel = __addDisposableResource(env_3, this.ioHost.on(api_private_1.IO.CDK_TOOLKIT_I7900, () => ({ level: 'info' })), false); // ✅ <stack>: destroyed
// toolkit-lib logs a declined confirmation (E7010) and returns gracefully.
// The CLI surfaces a decline as a non-zero, soft exit instead: throwing from
// the listener both suppresses the log and aborts the command (the top-level
// renders `AbortError` as "Deletion cancelled").
const _declineAborts = __addDisposableResource(env_3, this.ioHost.on(api_private_1.IO.CDK_TOOLKIT_E7010, () => {
throw new toolkit_lib_1.AbortError('DestroyAborted', 'Deletion cancelled');
}), false);
const _forceConfirms = __addDisposableResource(env_3, options.force ? this.ioHost.respondOnce(api_private_1.IO.CDK_TOOLKIT_I7010, true) : undefined, false);
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore - `_destroyWithAction` is private; the CLI sets the action label.
await this.toolkit._destroyWithAction(this.props.cloudExecutable, action, {
stacks: options.selector,
roleArn: options.roleArn,
concurrency: options.concurrency,
express: options.express,
});
}
catch (e_3) {
env_3.error = e_3;
env_3.hasError = true;
}
finally {
__disposeResources(env_3);
}
}
// cdk ls stdout is the stack listing only. Suppress the info status lines synthesis emits next
// to it: the synth-time line (I1000) and the dependency-expansion note (I1002).
async list(selectors, options = {}) {
const env_4 = { stack: [], error: void 0, hasError: false };
try {
// One-shot: disposes itself when the listing (I2901) is emitted; the
// `using` covers the case where `list` throws before that happens.
const _formatter = __addDisposableResource(env_4, this.ioHost.rewriteOnce(api_private_1.IO.CDK_TOOLKIT_I2901, (msg) => (0, list_stacks_1.formatStackList)(msg.data.stacks, options)), false);
await this.toolkit.list(this.props.cloudExecutable, {
stacks: selectors.length > 0 ? (0, cloud_assembly_1.selectWithUpstream)(...selectors) : undefined,
});
return 0; // exit-code
}
catch (e_4) {
env_4.error = e_4;
env_4.hasError = true;
}
finally {
__disposeResources(env_4);
}
}
/**
* 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(options) {
const stackNames = options.stackNames;
const exclusively = options.exclusively ?? false;
const quiet = options.quiet ?? false;
const autoValidate = options.autoValidate ?? false;
const json = options.json ?? false;
const assembly = await this.assembly();
const stacks = await this.selectTopLevelOrMatchingStacks(assembly, stackNames, exclusively);
const autoValidateStacks = autoValidate
? assembly.selectStacksForValidation()
: new cloud_assembly_1.StackCollection(assembly, []);
await this.validateStacks(stacks.concat(autoValidateStacks));
// if we have a single stack, print it to STDOUT
if (stacks.stackCount === 1) {
if (!quiet) {
await printSerializedObject(this.ioHost.asIoHelper(), (0, util_1.obscureTemplate)(stacks.firstStack.template), json);
}
// In CI mode, non-error messages go to stdout. When we just printed the
// template to stdout, skip the flags message to preserve the contract that
// `cdk synth` output is valid YAML. When quiet (no template printed) or
// non-CI (flags go to stderr), it's safe to show.
if (quiet || !this.ioHost.isCI) {
await displayFlagsMessage(this.ioHost.asIoHelper(), this.toolkit, this.props.cloudExecutable);
}
return undefined;
}
// not outputting template to stdout, let's explain things to the user a little bit...
await this.ioHost.asIoHelper().defaults.info(chalk_1.default.green(`Successfully synthesized to ${chalk_1.default.blue(path.resolve(stacks.assembly.directory))}`));
await this.ioHost.asIoHelper().defaults.info(`Supply a stack id (${stacks.stackArtifacts.map((s) => chalk_1.default.green(s.hierarchicalId)).join(', ')}) to display its template.`);
await displayFlagsMessage(this.ioHost.asIoHelper(), this.toolkit, this.props.cloudExecutable);
return undefined;
}
/**
* Continuously synthesize the project, re-synthesizing on every file change.
* Never deploys, and never prints templates to stdout.
*
* The files to observe are configured with the "watch" key of `cdk.json`,
* exactly like `cdk deploy --watch`.
*/
async synthWatch(options) {
const rootDir = path.dirname(path.resolve(user_configuration_1.PROJECT_CONFIG));
const watchSettings = this.props.configuration.settings.get(['watch']);
if (!watchSettings) {
throw new toolkit_lib_1.ToolkitError('WatchConfigMissing', "Cannot use '--watch' without specifying at least one directory to monitor. " +
'Make sure to add a "watch" key to your cdk.json');
}
const include = this.patternsArrayForWatch(watchSettings.include, {
defaultPattern: '**',
returnDefaultIfEmpty: true,
});
// Pass the user's excludes explicitly; toolkit-lib always appends the
// outdir, dot-file, and node_modules excludes on top of these.
const exclude = this.patternsArrayForWatch(watchSettings.exclude, {
defaultPattern: '',
returnDefaultIfEmpty: false,
});
const watcher = await this.toolkit.watchSynth(this.props.cloudExecutable.uncachedSource(), {
...options,
watchDir: rootDir,
include,
exclude,
});
return watcher.waitForEnd();
}
/**
* 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, (0, api_private_1.asIoHelper)(this.ioHost, 'bootstrap'));
// 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 () => {
await this.ioHost.asIoHelper().defaults.info(chalk_1.default.green(' ⏳ Bootstrapping environment %s...'), chalk_1.default.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.';
await this.ioHost.asIoHelper().defaults.info(chalk_1.default.green(message), chalk_1.default.blue(environment.name));
if (options.express) {
const warning = (0, api_private_1.formatExpressStabilizationWarning)(result.stabilizingResources, 'bootstrap');
if (warning) {
await this.ioHost.asIoHelper().notify(api_private_1.IO.CDK_TOOLKIT_W9902.msg(warning));
}
}
}
catch (e) {
await this.ioHost.asIoHelper().defaults.error(' ❌ Environment %s failed bootstrapping: %s', chalk_1.default.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) {
const environments = await this.defineEnvironments(userEnvironmentSpecs);
for (const environment of environments) {
await this.ioHost.asIoHelper().defaults.info(chalk_1.default.green(' ⏳ Garbage Collecting environment %s...'), chalk_1.default.blue(environment.name));
const gc = new api_1.GarbageCollector({
sdkProvider: this.props.sdkProvider,
ioHelper: (0, api_private_1.asIoHelper)(this.ioHost, 'gc'),
resolvedEnvironment: environment,
bootstrapStackName: options.bootstrapStackName,
rollbackBufferDays: options.rollbackBufferDays,
createdBufferDays: options.createdBufferDays,
action: options.action ?? 'full',
type: options.type ?? 'all',
confirm: options.confirm ?? 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_1.partition)(environmentSpecs, cxapp_1.looksLikeGlob);
if (globSpecs.length > 0 && !this.props.cloudExecutable.hasApp) {
if (userEnvironmentSpecs.length > 0) {
// User did request this glob
throw new toolkit_lib_1.ToolkitError('InvalidEnvironmentGlob', `'${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 toolkit_lib_1.ToolkitError('EnvironmentRequired', "Specify an environment name like 'aws://123456789012/us-east-1', or run in a directory with 'cdk.json'.");
}
}
const environments = [...(0, cxapp_1.environmentsFromDescriptors)(environmentSpecs)];
// If there is an '--app' argument, select the environments from the app.
if (this.props.cloudExecutable.hasApp) {
const assembly = await this.assembly();
const allStacks = await assembly.selectStacks(cloud_assembly_1.ALL_STACKS);
environments.push(...(await (0, cxapp_1.globEnvironmentsFromStacks)(allStacks, 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) {
await this.ioHost.asIoHelper().defaults.warn('This command is an experimental feature.');
const language = options.language?.toLowerCase() ?? '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 (options.filter?.length && scanType !== migrate_1.TemplateSourceOptions.SCAN) {
const sourceOption = scanType === migrate_1.TemplateSourceOptions.STACK ? '--from-stack' : '--from-path';
throw new toolkit_lib_1.ToolkitError('MigrateFilterRequiresScan', `--filter cannot be used with ${sourceOption}; remove --filter to migrate this 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,
ioHelper: this.ioHost.asIoHelper(),
});
templateToDelete = generateTemplateOutput.templateId;
}
else if (scanType == migrate_1.TemplateSourceOptions.PATH) {
const templateBody = (0, migrate_1.readFromPath)(options.fromPath);
const parsedTemplate = (0, util_1.deserializeStructure)(templateBody);
const templateId = parsedTemplate.Metadata?.AWSToolsMetrics?.IaC_Generator?.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), this.ioHost.asIoHelper());
const generatedTemplateSummary = await cfn.describeGeneratedTemplate(templateId);
generateTemplateOutput = (0, migrate_1.buildGeneratedTemplateOutput)(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 toolkit_lib_1.ToolkitError('StackTemplateNotFound', `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 toolkit_lib_1.ToolkitError('InvalidSourceOption', `Invalid source option provided: ${scanType}`);
}
const stack = (0, migrate_1.generateStack)(generateTemplateOutput.migrateJson.templateBody, options.stackName, language);
await this.ioHost.asIoHelper().defaults.info(chalk_1.default.green(' ⏳ Generating CDK app for %s...'), chalk_1.default.blue(options.stackName));
await (0, migrate_1.generateCdkApp)(this.ioHost.asIoHelper(), 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)) {
await this.ioHost.asIoHelper().defaults.warn(' ⚠️ Some resources could not be migrated completely. Please review the README.md file for more information.');
(0, migrate_1.appendWarningsToReadme)(`${path.join(options.outputPath ?? process.cwd(), options.stackName)}/README.md`, generateTemplateOutput.resources);
}
}
catch (e) {
await this.ioHost.asIoHelper().defaults.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), this.ioHost.asIoHelper());
}
if (!process.env.MIGRATE_INTEG_TEST) {
await cfn.deleteGeneratedTemplate(templateToDelete);
}
}
}
}
async refactor(options) {
if (options.revert && !options.overrideFile) {
throw new toolkit_lib_1.ToolkitError('RevertRequiresOverrideFile', 'The --revert option can only be used with the --override-file option.');
}
try {
await this.toolkit.refactor(this.props.cloudExecutable, {
dryRun: options.dryRun,
stacks: options.stacks ?? cloud_assembly_1.ALL_STACKS,
force: options.force,
additionalStackNames: options.additionalStackNames,
overrides: readOverrides(options.overrideFile, options.revert),
roleArn: options.roleArn,
});
}
catch (e) {
await this.ioHost.asIoHelper().defaults.error(e.message);
throw e;
}
return 0;
function readOverrides(filePath, revert = false) {
if (filePath == null) {
return [];
}
if (!fs.pathExistsSync(filePath)) {
throw new toolkit_lib_1.ToolkitError('MappingFileNotFound', `The mapping file ${filePath} does not exist`);
}
const groups = (0, refactor_1.parseMappingGroups)(fs.readFileSync(filePath).toString('utf-8'));
return revert
? groups.map((group) => ({
...group,
resources: Object.fromEntries(Object.entries(group.resources ?? {}).map(([src, dst]) => [dst, src])),
}))
: groups;
}
}
/**
* Select the stacks that `synth` and `diff` operate on
*
* With patterns: match them (failing if nothing matches), expanding to
* upstream dependencies unless `exclusively` is set. Without patterns: all
* top-level stacks, exactly — the historic default selection never expands
* to dependencies, regardless of `exclusively`. A stage-only app has no
* top-level stacks, which selects nothing and is not an error — but an app
* without any stacks at all still is. No single selection strategy covers
* this combination: `MAIN_ASSEMBLY` rejects stage-only apps (as
* `deploy --all` must keep doing) and `ALL_STACKS` would wrongly include
* the stacks inside stages.
*/
async selectTopLevelOrMatchingStacks(assembly, patterns, exclusively) {
if (patterns.length > 0) {
return assembly.selectStacks((0, cloud_assembly_1.mustMatch)(exclusively ? (0, cloud_assembly_1.selectExact)(...patterns) : (0, cloud_assembly_1.selectWithUpstream)(...patterns)));
}
if (assembly.cloudAssembly.stacks.length > 0) {
return assembly.selectStacks((0, cloud_assembly_1.selectAllTopLevel)(cloud_assembly_1.ExpandStackSelection.NONE));
}
// Stage-only app: nothing to select, which is not an error. An app
// without any stacks at all still is: this selection throws
// 'This app contains no stacks' in that case.
await assembly.selectStacks(cloud_assembly_1.ALL_STACKS);
return new cloud_assembly_1.StackCollection(assembly, []);
}
/**
* Validate the stacks for errors and warnings according to the CLI's current settings
*/
async validateStacks(stacks) {
const failAt = this.validateMetadataFailAt();
await stacks.reportValidationFailuresAndThrow(failAt, this.ioHost.asIoHelper());
}
validateMetadataFailAt() {
let failAt = 'error';
if (this.props.ignoreErrors) {
failAt = 'none';
}
if (this.props.strict) {
failAt = 'warn';
}
return failAt;
}
/**
* Converts the toolkit's `CloudExecutable` into `StackAssembly`.
*
* @param cacheCloudAssembly - to cache the assembly, defaults to `true`
* @returns the converted `StackAssembly`
*/
assembly(cacheCloudAssembly = true) {
return this.props.cloudExecutable.synthesize(cacheCloudAssembly);
}
patternsArrayForWatch(patterns, options) {
const patternsArray = patterns !== undefined ? (Array.isArray(patterns) ? patterns : [patterns]) : [];
return patternsArray.length > 0 ? patternsArray : options.returnDefaultIfEmpty ? [options.defaultPattern] : [];
}
async invokeDeployFromWatch(options, cloudWatchLogMonitor) {
const deployOptions = {
...options,
requireApproval: cloud_assembly_schema_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,
extraUserAgent: `cdk-watch/hotswap-${options.deploymentMethod?.method === 'hotswap' ? '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;
__decorate([
(0, io_host_1.suppressMessages)(api_private_1.IO.CDK_TOOLKIT_I1001, // Starting Synthesis (trace)
api_private_1.IO.CDK_TOOLKIT_I1000)
], CdkToolkit.prototype, "metadata", null);
__decorate([
(0, io_host_1.suppressMessages)(api_private_1.IO.CDK_TOOLKIT_I1001, // Starting Synthesis (trace)
api_private_1.IO.CDK_TOOLKIT_I1000, // ✨ Synthesis time (info)
api_private_1.IO.CDK_TOOLKIT_I7101, // Starting Destroy (trace)
api_private_1.IO.CDK_TOOLKIT_I7001, // per-stack Destroy time (trace)
api_private_1.IO.CDK_TOOLKIT_I7000)
], CdkToolkit.prototype, "destroy", null);
__decorate([
(0, io_host_1.suppressMessages)(api_private_1.IO.CDK_TOOLKIT_I1000, api_private_1.IO.CDK_TOOLKIT_I1002)
], CdkToolkit.prototype, "list", null);
/**
* Print a serialized object (YAML or JSON) to stdout.
*/
async function printSerializedObject(ioHelper, obj, json) {
await ioHelper.defaults.result((0, util_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, req, abortErrorCode, abortMessage) {
await ioHost.withCorkedLogging(async () => {
// The IoHost returns the answer rather than aborting; abort here on decline.
const confirmed = await ioHost.asIoHelper().requestResponse(req);
if (!confirmed) {
throw new toolkit_lib_1.AbortError(abortErrorCode, abortMessage);
}
});
}
/**
* Display a warning if there are flags that are different from the recommended value
*
* This happens if both of the following are true:
*
* - The user didn't configure the value
* - The default value for the flag (unconfiguredBehavesLike) is different from the recommended value
*/
async function displayFlagsMessage(ioHost, toolkit, cloudExecutable) {
const flags = await toolkit.flags(cloudExecutable);
// The "unconfiguredBehavesLike" information got added later. If none of the flags have this information,
// we don't have enough information to reliably display this information without scaring users, so don't do anything.
if (flags.every(flag => flag.unconfiguredBehavesLike === undefined)) {
return;
}
const unconfiguredFlags = operations_1.FlagOperations.filterNeedsAttention(flags);
const numUnconfigured = unconfiguredFlags.length;
if (numUnconfigured > 0) {
await ioHost.defaults.warn(`${numUnconfigured} feature flags are not configured. Run 'cdk flags --unstable=flags' to learn more.`);
}
}
/**
* This class implements the callbacks for the parallel work graph executions.
*
* All this code used to be inlined into CdkToolkit#deploy(), but it was getting
* too much to live in there.
*/
class WorkGraphDeploymentActions {
deployments;
ioHost;
stackOperations;
options;
stackOutputs = {};
assetSpans = {};
stackCounter = 1;
constructor(deployments, ioHost, stackOperations, options) {
this.deployments = deployments;
this.ioHost = ioHost;
this.stackOperations = stackOperations;
this.options = options;
}
async marker(markerNode) {
// For assets, emit IoHost messages that have been defined to start and end asset spans, which will lead to events in telemetry.
switch (markerNode.marker.type) {
case 'start-asset': {
const assetSpan = await this.obtainSpan(markerNode.marker.asset);
// Count the asset type, both on the asset-specific span and on the global COMMAND span.
if (markerNode.marker.asset.type === 'file') {
this.ioHost.telemetry?.commandSpan?.incCounter('fileAsset');
assetSpan.incCounter('fileAsset');
}
else if (markerNode.marker.asset.type === 'docker') {
this.ioHost.telemetry?.commandSpan?.incCounter('dockerAsset');
assetSpan.incCounter('dockerAsset');
}
break;
}
case 'end-asset': {
const assetSpan = await this.obtainSpan(markerNode.marker.asset);
await assetSpan.end({});
break;
}
}
}
async obtainSpan(assetEntry) {
const span = this.assetSpans[assetEntry.id.assetId];
if (span) {
return span;
}
const assetSpan = await this.ioHost.asIoHelper().span(messages_1.CLI_PRIVATE_SPAN.ASSET).begin({});
this.assetSpans[assetEntry.id.assetId] = assetSpan;
return assetSpan;
}
async buildAsset(assetNode) {
const env_5 = { stack: [], error: void 0, hasError: false };
try {
// Measure asset build time. Both on the global COMMAND span as well as on the asset-specific span.
// (parallelism may cause SUM(buildAssetST) >= totalDeployTime) on the COMMAND span, indicate with [S]ub[T]ask suffix).
const _invokeTimer = __addDisposableResource(env_5, this.ioHost.telemetry?.commandSpan?.startTimer('buildAssetST'), false);
const _assetTimer = __addDisposableResource(env_5, (await this.obtainSpan(assetNode.asset)).startTimer('buildAsset'), false);
await this.deployments.buildSingleAsset(assetNode.assetManifestArtifact, assetNode.assetManifest, assetNode.asset, {
stack: assetNode.parentStack,
roleArn: this.options.roleArn,
stackName: assetNode.parentStack.stackName,
});
}
catch (e_5) {
env_5.error = e_5;
env_5.hasError = true;
}
finally {
__disposeResources(env_5);
}
}
async publishAsset(assetNode) {
const env_6 = { stack: [], error: void 0, hasError: false };
try {
// Measure asset publish time. Both on the global COMMAND span as well as on the asset-specific span.
// (parallelism may cause SUM(publishAssetST) >= totalDeployTime) on the COMMAND span, indicate with [S]ub[T]ask suffix).
const _invokeTimer = __addDisposableResource(env_6, this.ioHost.telemetry?.commandSpan?.startTimer('publishAssetST'), false);
const _assetTimer = __addDisposableResource(env_6, (await this.obtainSpan(assetNode.asset)).startTimer('publishAsset'), false);
await this.deployments.publishSingleAsset(assetNode.assetManifest, assetNode.asset, {
stack: assetNode.parentStack,
roleArn: this.options.roleArn,
stackName: assetNode.parentStack.stackName,
forcePublish: this.options.force,
});
}
catch (e_6) {
env_6.error = e_6;
env_6.hasError = true;
}
finally {
__disposeResources(env_6);
}
}
async deployStack(stackNode) {
// Counter for totalDeployedStacks, to match 'totalDeployTime' timer on the COMMAND span.
this.ioHost.telemetry?.commandSpan?.incCounter('totalDeployedStacks');
const stack = stackNode.stack;
if (this.options.stackCount !== 1) {
await this.ioHost.asIoHelper().defaults.info(chalk_1.default.bold(stack.displayName));
}
if (!stack.environment) {
// eslint-disable-next-line @stylistic/max-len
throw new toolkit_lib_1.ToolkitError('MissingEnvironment', `Stack ${stack.displayName} does not define an environment, and AWS credentials could not be obtained from standard locations or no region was configured.`);
}
const resourceCount = Object.keys(stack.template.Resources || {}).length;
if (resourceCount === 0) {
// The generated stack has no resources
if (!(await this.deployments.stackExists({ stack }))) {
await this.ioHost.asIoHelper().defaults.warn('%s: stack has no resources, skipping deployment.', chalk_1.default.bold(stack.displayName));
}
else {
await this.ioHost.asIoHelper().defaults.warn('%s: stack has no resources, deleting existing stack.', chalk_1.default.bold(stack.displayName));
await this.stackOperations.destroy({
selector: (0, cloud_assembly_1.selectExact)(stack.hierarchicalId),
force: true,
roleArn: this.options.roleArn,
fromDeploy: true,
});
}
return;
}
// 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 = (!!this.options.notificationArns || !!stack.notificationArns)
? (this.options.notificationArns ?? []).concat(stack.notificationArns ?? [])
: undefined;
for (const notificationArn of notificationArns ?? []) {
if (!(0, util_1.validateSnsTopicArn)(notificationArn)) {
throw new toolkit_lib_1.ToolkitError('InvalidSnsTopicArn', `Notification arn ${notificationArn} is not a valid arn for an SNS topic`);
}
}
const parameterMap = buildParameterMap(this.options.parameters);
// Deploy options that are shared between change set creation and execution
const sharedDeployOptions = {
stack,
deployName: stack.stackName,
roleArn: this.options.roleArn,
toolkitStackName: this.options.toolkitStackName,
reuseAssets: this.options.reuseAssets,
tags: (this.options.tags?.length ? this.options.tags : (0, api_private_1.tagsForStack)(stack)),
forceDeployment: this.options.force,
parameters: Object.assign({}, parameterMap['*'], parameterMap[stack.stackName]),
usePreviousParameters: this.options.usePreviousParameters,
rollback: this.options.rollback,
notificationArns,
extraUserAgent: this.options.extraUserAgent,
assetParallelism: this.options.assetParallelism,
express: this.options.express,
};
// When using change-set method, always create the change set upfront.
// This gives us an accurate diff for approval and avoids creating it twice.
// For non-executing deployments (prepare-change-set), this is the final result.
const prepareResult = (0, deploy_private_1.isChangeSetDeployment)(this.options.deploymentMethod)
? await this.deployments.prepareStack({
...sharedDeployOptions,
deploymentMethod: this.options.deploymentMethod,
willExecuteChangeSet: (0, deploy_private_1.isExecutingChangeSetDeployment)(this.options.deploymentMethod),
})
: undefined;
// Also skip the approval flow when the prepared change set is a no-op —
// there is nothing for the user to approve. Outputs, stack ARN, and
// timings are still emitted via the normal no-op deploy path below.
if (this.options.requireApproval !== cloud_assembly_schema_1.RequireApproval.NEVER && !prepareResult?.noOp) {
const isDestructiveApproval = this.options.requireApproval === cloud_assembly_schema_1.RequireApproval.DESTRUCTIVE;
// Destructive changes can be in nested stacks too, so read their templates when they decide the approval
const { deployedRootTemplate, nestedStacks } = isDestructiveApproval
? await this.deployments.readCurrentTemplateWithNestedStacks(stack)
: { deployedRootTemplate: await this.deployments.readCurrentTemplate(stack), nestedStacks: undefined };
const formatter = new api_1.DiffFormatter({
templateInfo: {
oldTemplate: deployedRootTemplate,
newTemplate: stack,
changeSet: prepareResult?.changeSet,
nestedStacks,
},
});
const securityDiff = formatter.formatSecurityDiff();
// Formatting the stack diff leaves out changes that are likely mangled non-ASCII characters,
// so do that before looking for destructive changes when they decide the approval
const stackDiff = isDestructiveApproval ? formatter.formatStackDiff() : undefined;
const destructiveChanges = (0, api_1.findDestructiveChanges)(formatter.displayedDiffs, formatter.constructPaths);
if (requiresApproval(this.options.requireApproval, securityDiff.permissionChangeType, destructiveChanges.length > 0)) {
const hasSecurityChanges = securityDiff.permissionChangeType !== toolkit_lib_1.PermissionChangeType.NONE;
// Bare-fact motivation. The I5060 listener registered in `deploy()` adds
// the `--require-approval` framing for terminal users.
const motivation = isDestructiveApproval
? 'Stack includes destructive updates'
: hasSecurityChanges
? 'Stack includes security-sensitive updates'
: 'Stack includes updates';
const diffOutput = hasSecurityChanges && !isDestructiveApproval
? securityDiff.formattedDiff
: (stackDiff ?? formatter.formatStackDiff()).formattedDiff;
await this.ioHost.asIoHelper().defaults.info(diffOutput);
if (isDestructiveApproval) {
const lines = destructiveChanges.map(c => ` ${(0, api_1.formatDestructiveChange)(c)}`);
await this.ioHost.asIoHelper().defaults.warn(`Destructive changes:\n${lines.join('\n')}\n`);
}
try {
await askUserConfirmation(this.ioHost, api_private_1.IO.CDK_TOOLKIT_I5060.req(`${motivation}. Do you wish to deploy these changes?`, {
motivation,
concurrency: this.options.concurrency,
permissionChangeType: securityDiff.permissionChangeType,
templateDiffs: formatter.diffs,
destructiveChanges,
}), 'DeployAborted', 'Deployment cancelled');
}
catch (e) {
if (prepareResult?.changeSet?.ChangeSetName) {
await this.deployments.cleanupChangeSet(stack, prepareResult.changeSet.ChangeSetName);
}
throw e;
}
}
}
const stackIndex = this.stackCounter++;
await this.ioHost.asIoHelper().defaults.info(`${chalk_1.default.bold(stack.displayName)}: deploying... [${stackIndex}/${this.options.stackCount}]`);
const startDeployTime = new Date().getTime();
// There is already a startDeployTime constant, but that does not work with telemetry.
// We should integrate the two in the future
const deploySpan = await this.ioHost.asIoHelper().span(messages_1.CLI_PRIVATE_SPAN.DEPLOY).begin({});
deploySpan.incCounter('resources', resourceCount);
this.ioHost.telemetry?.commandSpan?.incCounter('totalDeployedResources', resourceCount);
let error;
let elapsedDeployTime = 0;
try {
// The prepare result is final if the change set was empty (noOp) or
// the deployment method is non-executing (prepare-change-set).
const prepareIsFinal = prepareResult && (prepareResult.noOp || (0, deploy_private_1.isNonExecutingChangeSetDeployment)(this.options.deploymentMethod));
let deployResult = prepareIsFinal ? prepareResult : undefined;
// Start with user config for rollback,
// but it might change if we encounter a failed state.
let rollback = this.options.rollback;
// We limit the loop to 2 iterations max as defensive programming.
// Should not be possible to happen.
let iteration = 0;
while (!deployResult) {
if (++iteration > 2) {
throw new toolkit_lib_1.ToolkitError('DeployLoopUnstable', '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.deployments.deployStack({
...sharedDeployOptions,
// On the first iteration, execute the prepared change set.
// On retries (after rollback), create a new change set since the old one is gone.
deploymentMethod: iteration === 1 && (0, deploy_private_1.isExecutingChangeSetDeployment)(this.options.deploymentMethod)
? (0, deploy_private_1.toExecuteChangeSetDeployment)(this.options.deploymentMethod)
: this.options.deploymentMethod,
rollback,
});
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 (this.options.force) {
await this.ioHost.asIoHelper().defaults.warn(`${motivation}. Rolling back first (--force).`);
}
else {
await askUserConfirmation(this.ioHost, api_private_1.IO.CDK_TOOLKIT_I5050.req(`${motivation}. Roll back first and then proceed with deployment`, {
motivation,
concurrency: this.options.concurrency,
}), 'RollbackAborted', 'Rollback cancelled');
}
// Perform a rollback
await this.stackOperations.rollback({
selector: (0, cloud_assembly_1.selectExact)(stack.hierarchicalId),
toolkitStackName: this.options.toolkitStackName,
force: this.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 (this.options.force) {
await this.ioHost.asIoHelper().defaults.warn(`${motivation}. Proceeding with deployment with rollback enabled (--force).`);
}
else {
await askUserConfirmation(this.ioHost, api_private_1.IO.CDK_TOOLKIT_I5050.req(`${motivation}. Perform a deployment with rollback enabled`, {
concurrency: this.options.concurrency,
motivation,
}), 'ReplacementRollbackAborted', 'Rollback cancelled');
}
// Go around through the 'while' loop again but switch rollback to true.
rollback = true;
break;
}
default:
throw new toolkit_lib_1.ToolkitError('UnexpectedDeployResult', `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';
await this.ioHost.asIoHelper().defaults.info(chalk_1.default.green('\n' + message), stack.displayName);
elapsedDeployTime = new Date().getTime() - startDeployTime;
await this.ioHost.asIoHelper().defaults.info(`\n✨ Deployment time: ${(0, util_1.formatTime)(elapsedDeployTime)}s\n`);
if (this.options.express) {
const warning = (0, api_private_1.formatExpressStabilizationWarning)(deployResult.stabilizingResources, 'deploy');
if (warning) {
await this.ioHost.asIoHelper().notify(api_private_1.IO.CDK_TOOLKIT_W5902.msg(warning));
}
}
if (Object.keys(deployResult.outputs).length > 0) {
await this.ioHost.asIoHelper().defaults.info('Outputs:');
this.stackOutputs[stack.stackName] = deployResult.outputs;
}
for (const name of Object.keys(deployResult.outputs).sort()) {
const value = deployResult.outputs[name];
await this.ioHost.asIoHelper().defaults.info(`${chalk_1.default.cyan(stack.id)}.${chalk_1.default.cyan(name)} = ${chalk_1.default.underline(chalk_1.default.cyan(value))}`);
}
await this.ioHost.asIoHelper().defaults.info('Stack ARN:');
await this.ioHost.asIoHelper().defaults.result(deployResult.stackArn);
}
catch (e) {
// It has to be exactly this string because an integration test tests for
// "bold(stackname) failed: ResourceNotReady: <error>"
const code = toolkit_lib_1.ToolkitError.isToolkitError(e) ? e.name : 'DeployStackFailed'; // Formerly 'DeployFailed'
const newMessage = `❌ ${chalk_1.default.bold(stack.stackName)} failed to deploy`;
const wrappedError = toolkit_lib_1.ToolkitError.withCause(code, newMessage, e);
error = {
name: (0, error_1.cdkCliErrorName)(wrappedError),
};
throw wrappedError;
}
finally {
await deploySpan.end({ error });
if (this.options.cloudWatchLogMonitor) {
const foundLogGroupsResult = await (0, api_1.findCloudWatchLogGroups)(this.options.sdkProvider, (0, api_private_1.asIoHelper)(this.ioHost, 'deploy'), stack);
this.options.cloudWatchLogMonitor.addLogGroups(foundLogGroupsResult.env, foundLogGroupsResult.sdk, foundLogGroupsResult.logGroupNames);
}
}
}
async writeOutputs(outputsFile) {
fs.ensureFileSync(outputsFile);
await fs.writeJson(outputsFile, this.stackOutputs, {
spaces: 2,
encoding: 'utf8',
});
}
}
/**
* Whether a diff with the given changes fails, according to `--fail-on`
*/
function diffFails(failOn, numStacksWithChanges, hasBroadeningChanges, hasDestructiveChanges) {
switch (failOn) {
case cloud_assembly_schema_1.RequireApproval.ANYCHANGE:
return numStacksWithChanges > 0;
case cloud_assembly_schema_1.RequireApproval.BROADENING:
return hasBroadeningChanges;
case cloud_assembly_schema_1.RequireApproval.DESTRUCTIVE:
return hasDestructiveChanges;
case cloud_assembly_schema_1.RequireApproval.NEVER:
return false;
}
}
/**
* Determine if manual approval is required or not. Requires approval for
* - RequireApproval.ANYCHANGE
* - RequireApproval.BROADENING and the changes are indeed broadening permissions
* - RequireApproval.DESTRUCTIVE and the changes replace, delete or orphan an existing resource
*/
function requiresApproval(requireApproval, permissionChangeType, hasDestructiveChanges) {
return requireApproval === cloud_assembly_schema_1.RequireApproval.ANYCHANGE ||
requireApproval === cloud_assembly_schema_1.RequireApproval.BROADENING && permissionChangeType === toolkit_lib_1.PermissionChangeType.BROADENING ||
requireApproval === cloud_assembly_schema_1.RequireApproval.DESTRUCTIVE && hasDestructiveChanges;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-toolkit.js","sourceRoot":"","sources":["cdk-toolkit.ts"],"names":[],"mappings":"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","sourcesContent":["import { randomUUID } from 'node:crypto';\nimport * as path from 'node:path';\nimport { format } from 'node:util';\nimport type { IManifestEntry } from '@aws-cdk/cdk-assets-lib';\nimport * as cxapi from '@aws-cdk/cloud-assembly-api';\nimport { RequireApproval } from '@aws-cdk/cloud-assembly-schema';\nimport type { ConfirmationRequest, DeploymentMethod, DestructiveChange, DiagnoseOptions, PublishAssetsOptions, StackSelector, SynthOptions as ToolkitSynthOptions, ToolkitAction, ToolkitOptions, UnstableFeature, ValidateOptions } from '@aws-cdk/toolkit-lib';\nimport { PermissionChangeType, Toolkit, ToolkitError, AbortError } from '@aws-cdk/toolkit-lib';\nimport chalk from 'chalk';\nimport * as chokidar from 'chokidar';\nimport { type EventName, EVENTS } from 'chokidar/handler.js';\nimport * as fs from 'fs-extra';\nimport { CliIoHost, suppressMessages } from './io-host';\nimport type { Configuration } from './user-configuration';\nimport { PROJECT_CONFIG } from './user-configuration';\nimport type { ActionLessRequest, IMessageSpan, IoHelper } from '../../lib/api-private';\nimport { asIoHelper, cfnApi, createIgnoreMatcher, formatExpressStabilizationWarning, IO, tagsForStack } from '../../lib/api-private';\nimport type { AssetBuildNode, AssetPublishNode, Concurrency, MarkerNode, StackNode, WorkGraph, WorkGraphActions } from '../api';\nimport {\n  CloudWatchLogEventMonitor,\n  DEFAULT_TOOLKIT_STACK_NAME,\n  DiffFormatter,\n  findCloudWatchLogGroups,\n  findDestructiveChanges,\n  formatDestructiveChange,\n  GarbageCollector,\n  removeNonImportResources,\n  ResourceImporter,\n  ResourceMigrator,\n  StackSelectionStrategy,\n  WorkGraphBuilder,\n} from '../api';\nimport type { SdkProvider } from '../api/aws-auth';\nimport type { BootstrapEnvironmentOptions } from '../api/bootstrap';\nimport { Bootstrapper } from '../api/bootstrap';\nimport type { StackAssembly } from '../api/cloud-assembly';\nimport { ALL_STACKS, ExpandStackSelection, mustMatch, selectAllTopLevel, selectExact, selectWithUpstream, StackCollection } from '../api/cloud-assembly';\nimport { isChangeSetDeployment, isExecutingChangeSetDeployment, isNonExecutingChangeSetDeployment, toExecuteChangeSetDeployment } from '../api/deploy-private';\nimport type { Deployments, SuccessfulDeployStackResult } from '../api/deployments';\nimport { mappingsByEnvironment, parseMappingGroups } from '../api/refactor';\nimport { type Tag } from '../api/tags';\nimport { StackActivityProgress } from '../commands/deploy';\nimport { formatStackList } from '../commands/list-stacks';\nimport type { FromScan, GenerateTemplateOutput } from '../commands/migrate';\nimport {\n  appendWarningsToReadme,\n  buildCfnClient,\n  buildGeneratedTemplateOutput,\n  CfnTemplateGeneratorProvider,\n  generateCdkApp,\n  generateStack,\n  generateTemplate,\n  isThereAWarning,\n  parseSourceOptions,\n  readFromPath,\n  readFromStack,\n  setEnvironment,\n  TemplateSourceOptions,\n  writeMigrateJsonFile,\n} from '../commands/migrate';\nimport type { CloudExecutable } from '../cxapp';\nimport { environmentsFromDescriptors, globEnvironmentsFromStacks, looksLikeGlob } from '../cxapp';\nimport {\n  deserializeStructure,\n  formatErrorMessage,\n  formatTime,\n  obscureTemplate,\n  partition,\n  serializeStructure,\n  validateSnsTopicArn,\n} from '../util';\nimport { canCollectTelemetry } from './telemetry/collect-telemetry';\nimport { cdkCliErrorName } from './telemetry/error';\nimport type { EventResult } from './telemetry/messages';\nimport { CLI_PRIVATE_SPAN } from './telemetry/messages';\nimport type { ErrorDetails } from './telemetry/schema';\nimport { FlagOperations } from '../commands/flags/operations';\n\n// Must use a require() otherwise esbuild complains about calling a namespace\n// eslint-disable-next-line @typescript-eslint/no-require-imports,@typescript-eslint/consistent-type-imports\nconst pLimit: typeof import('p-limit') = require('p-limit');\n\n/**\n * File events that we care about from chokidar.\n * In chokidar v4, EventName includes additional events like 'error', 'raw', 'ready', 'all'\n * that we need to filter out in the 'all' handler.\n */\nconst FILE_EVENTS = [EVENTS.ADD, EVENTS.ADD_DIR, EVENTS.CHANGE, EVENTS.UNLINK, EVENTS.UNLINK_DIR] as const;\ntype FileEvent = typeof FILE_EVENTS[number];\n\n/**\n * Type guard to check if an event is a file event we should process.\n */\nfunction isFileEvent(event: EventName): event is FileEvent {\n  return (FILE_EVENTS as readonly string[]).includes(event);\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   * Name of the toolkit stack to use/deploy\n   *\n   * @default CDKToolkit\n   */\n  toolkitStackName?: string;\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 = 'all-before-deploy',\n\n  /**\n   * Build assets just-in-time, before publishing\n   */\n  JUST_IN_TIME = 'just-in-time',\n}\n\n/**\n * Custom implementation of the public Toolkit to integrate with the legacy CdkToolkit\n *\n * This overwrites how an sdkProvider is acquired\n * in favor of the one provided directly to CdkToolkit.\n */\nclass InternalToolkit extends Toolkit {\n  private readonly _sdkProvider: SdkProvider;\n  public constructor(sdkProvider: SdkProvider, options: Omit<ToolkitOptions, 'sdkConfig'>) {\n    super(options);\n    this._sdkProvider = sdkProvider;\n  }\n\n  /**\n   * Access to the AWS SDK\n   * @internal\n   */\n  protected async sdkProvider(_action: ToolkitAction): Promise<SdkProvider> {\n    return this._sdkProvider;\n  }\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  private toolkitStackName: string;\n  private toolkit: InternalToolkit;\n\n  constructor(private readonly props: CdkToolkitProps) {\n    this.ioHost = props.ioHost ?? CliIoHost.instance();\n    this.toolkitStackName = props.toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME;\n\n    // We don't have the toolkit check unstable features. Instead, the error\n    // messages the CLI give are slightly different, and so they need to be checked\n    // separately. Instead, the Toolkit we use has all unstable features automatically\n    // enabled.\n    const iPromiseUnstablenessIsCheckedByTheCli: Record<UnstableFeature, true> = {\n      'publish-assets': true,\n      'diagnose': true,\n      'flags': true,\n      'orphan': true,\n      'refactor': true,\n      'validate': true,\n    };\n\n    this.toolkit = new InternalToolkit(props.sdkProvider, {\n      assemblyFailureAt: this.validateMetadataFailAt(),\n      color: true,\n      emojis: true,\n      ioHost: this.ioHost,\n      toolkitStackName: this.toolkitStackName,\n      unstableFeatures: Object.keys(iPromiseUnstablenessIsCheckedByTheCli) as UnstableFeature[],\n    });\n  }\n\n  @suppressMessages(\n    IO.CDK_TOOLKIT_I1001, // Starting Synthesis (trace)\n    IO.CDK_TOOLKIT_I1000, // ✨ Synthesis time (info)\n  )\n  public async metadata(stackName: string, json: boolean) {\n    using _formatter = this.ioHost.once(\n      IO.CDK_TOOLKIT_I2901,\n      (msg) => ({\n        action: 'metadata',\n        message: serializeStructure(msg.data.stacks[0]?.metadata ?? {}, json),\n      }),\n    );\n\n    await this.toolkit.list(this.props.cloudExecutable, {\n      stacks: {\n        patterns: [stackName],\n        strategy: StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE,\n        expand: ExpandStackSelection.NONE,\n      },\n    });\n  }\n\n  public async acknowledge(noticeId: string) {\n    const issueNumber = Number(noticeId);\n    if (!Number.isInteger(issueNumber)) {\n      throw new ToolkitError(\n        'InvalidAcknowledgementId',\n        `Invalid notice ID '${noticeId}': 'cdk acknowledge' only accepts numeric notice IDs (e.g. 'cdk acknowledge 12345'). ` +\n        'Scoped construct warnings such as \\'@aws-cdk/aws-ecs:minHealthyPercent\\' are acknowledged in code with ' +\n        'Annotations.of(scope).acknowledgeWarning(\\'<id>\\').',\n      );\n    }\n\n    const acks = new Set(this.props.configuration.context.get('acknowledged-issue-numbers') ?? []);\n    acks.add(issueNumber);\n    this.props.configuration.context.set('acknowledged-issue-numbers', Array.from(acks));\n    await this.props.configuration.saveContext();\n  }\n\n  public async cliTelemetryStatus(args: any) {\n    const canCollect = canCollectTelemetry(args, this.props.configuration.context);\n    if (canCollect) {\n      await this.ioHost.asIoHelper().defaults.info('CLI Telemetry is enabled. See https://docs.aws.amazon.com/cdk/v2/guide/cli-telemetry.html for ways to disable.');\n    } else {\n      await this.ioHost.asIoHelper().defaults.info('CLI Telemetry is disabled. See https://docs.aws.amazon.com/cdk/v2/guide/cli-telemetry.html for ways to enable.');\n    }\n  }\n\n  public async cliTelemetry(enable: boolean) {\n    this.props.configuration.context.set('cli-telemetry', enable);\n    await this.props.configuration.saveContext();\n    await this.ioHost.asIoHelper().defaults.info(`Telemetry ${enable ? 'enabled' : 'disabled'}`);\n  }\n\n  public async diff(options: DiffOptions): Promise<number> {\n    const assembly = await this.assembly();\n    const stacks = await this.selectTopLevelOrMatchingStacks(assembly, options.stackNames, options.exclusively);\n    await this.validateStacks(stacks);\n\n    const strict = !!options.strict;\n    const contextLines = options.contextLines || 3;\n    const quiet = options.quiet || false;\n\n    const failOn = options.failOn ?? RequireApproval.NEVER;\n    let diffs = 0;\n    let hasBroadeningChanges = false;\n    const destructiveChanges: DestructiveChange[] = [];\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          'SingleStackRequired',\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('TemplateNotFound', `There is no file at ${options.templatePath}`);\n      }\n\n      if (options.importExistingResources) {\n        throw new ToolkitError(\n          'ImportWithTemplatePath',\n          'Can only use --import-existing-resources flag when comparing against deployed stacks.',\n        );\n      }\n\n      const template = deserializeStructure(await fs.readFile(options.templatePath, { encoding: 'utf-8' }));\n      const formatter = new DiffFormatter({\n        templateInfo: {\n          oldTemplate: template,\n          newTemplate: stacks.firstStack,\n        },\n      });\n\n      if (options.securityOnly) {\n        const securityDiff = formatter.formatSecurityDiff({ quiet });\n        // Warn, count, and display the diff only if the reported changes are broadening permissions\n        if (securityDiff.permissionChangeType === PermissionChangeType.BROADENING) {\n          hasBroadeningChanges = true;\n          await this.ioHost.asIoHelper().defaults.warn('This deployment will make potentially sensitive changes according to your current security approval level.\\nPlease confirm you intend to make the following modifications:\\n');\n          await this.ioHost.asIoHelper().defaults.info(securityDiff.formattedDiff);\n          diffs += securityDiff.numStacksWithChanges;\n        }\n      } else {\n        const diff = formatter.formatStackDiff({\n          strict,\n          contextLines,\n          quiet,\n        });\n        diffs = diff.numStacksWithChanges;\n        await this.ioHost.asIoHelper().defaults.info(diff.formattedDiff);\n        if (failOn === RequireApproval.BROADENING) {\n          hasBroadeningChanges = formatter.formatSecurityDiff().permissionChangeType === PermissionChangeType.BROADENING;\n        }\n      }\n\n      if (failOn === RequireApproval.DESTRUCTIVE) {\n        destructiveChanges.push(...findDestructiveChanges(formatter.displayedDiffs, formatter.constructPaths));\n      }\n    } else {\n      const allMappings = options.includeMoves\n        ? await mappingsByEnvironment(stacks.stackArtifacts, this.props.sdkProvider, true)\n        : [];\n\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 environment = await this.props.deployments.resolveEnvironment(stack);\n\n        const migrator = new ResourceMigrator({\n          deployments: this.props.deployments,\n          ioHelper: asIoHelper(this.ioHost, 'diff'),\n        });\n        const resourcesToImport = await migrator.tryGetResources(environment);\n        if (resourcesToImport) {\n          removeNonImportResources(stack);\n        }\n\n        const changeSet = (options.method !== 'template')\n          ? (await this.tryCreateDiffChangeSet(stack, options, parameterMap, resourcesToImport, quiet))?.changeSet\n          : undefined;\n\n        const mappings = allMappings.find(m =>\n          m.environment.region === stack.environment.region && m.environment.account === stack.environment.account,\n        )?.mappings ?? {};\n\n        const formatter = new DiffFormatter({\n          templateInfo: {\n            oldTemplate: currentTemplate,\n            newTemplate: stack,\n            changeSet,\n            isImport: !!resourcesToImport,\n            nestedStacks,\n            mappings,\n            environment,\n          },\n        });\n\n        if (options.securityOnly) {\n          const securityDiff = formatter.formatSecurityDiff({ quiet });\n          // Warn, count, and display the diff only if the reported changes are broadening permissions\n          if (securityDiff.permissionChangeType === PermissionChangeType.BROADENING) {\n            hasBroadeningChanges = true;\n            await this.ioHost.asIoHelper().defaults.warn('This deployment will make potentially sensitive changes according to your current security approval level.\\nPlease confirm you intend to make the following modifications:\\n');\n            await this.ioHost.asIoHelper().defaults.info(securityDiff.formattedDiff);\n            diffs += securityDiff.numStacksWithChanges;\n          }\n        } else {\n          const diff = formatter.formatStackDiff({\n            strict,\n            contextLines,\n            quiet,\n          });\n          await this.ioHost.asIoHelper().defaults.info(diff.formattedDiff);\n          diffs += diff.numStacksWithChanges;\n          if (failOn === RequireApproval.BROADENING\n            && formatter.formatSecurityDiff().permissionChangeType === PermissionChangeType.BROADENING) {\n            hasBroadeningChanges = true;\n          }\n        }\n\n        if (failOn === RequireApproval.DESTRUCTIVE) {\n          destructiveChanges.push(...findDestructiveChanges(formatter.displayedDiffs, formatter.constructPaths));\n        }\n      }\n    }\n\n    await this.ioHost.asIoHelper().defaults.info(format('\\n✨  Number of stacks with differences: %s\\n', diffs));\n\n    if (destructiveChanges.length > 0) {\n      const lines = destructiveChanges.map(c => `  ${formatDestructiveChange(c)}`);\n      await this.ioHost.asIoHelper().defaults.error(\n        `❌  Found ${destructiveChanges.length} destructive change(s) (--fail-on=destructive):\\n${lines.join('\\n')}\\n`,\n      );\n    }\n\n    return diffFails(failOn, diffs, hasBroadeningChanges, destructiveChanges.length > 0) ? 1 : 0;\n  }\n\n  /**\n   * Try to create a diff changeset for the given stack.\n   * Returns undefined if the stack cannot be accessed and changeSetOnly is not set.\n   */\n  private async tryCreateDiffChangeSet(\n    stack: cxapi.CloudFormationStackArtifact,\n    options: DiffOptions,\n    parameterMap: { [name: string]: { [name: string]: string | undefined } },\n    resourcesToImport: Awaited<ReturnType<ResourceMigrator['tryGetResources']>>,\n    quiet: boolean,\n  ) {\n    try {\n      // we don't actually need to know if the stack exists here\n      // we just use this to flush our any permissions issues and drop the result\n      void await this.props.deployments.stackExists({\n        stack,\n        deployName: stack.stackName,\n        tryLookupRole: true,\n      });\n    } catch (e: any) {\n      if (options.method === 'change-set') {\n        throw ToolkitError.withCause('DescribeStacksFailed', `Could not access stack '${stack.stackName}'. Please check your permissions or use '--method=auto' to allow falling back to a template diff.`, e);\n      }\n      await this.ioHost.asIoHelper().defaults.debug(formatErrorMessage(e));\n      if (!quiet) {\n        await this.ioHost.asIoHelper().defaults.info(\n          `Could not access stack '${stack.stackName}', falling back to template diff. Use '--method=change-set' to fail instead. Run with -v to see the reason.\\n`,\n        );\n      }\n      return undefined;\n    }\n\n    return cfnApi.createDiffChangeSet(asIoHelper(this.ioHost, 'diff'), {\n      stack,\n      uuid: randomUUID(),\n      deployments: this.props.deployments,\n      sdkProvider: this.props.sdkProvider,\n      parameters: Object.assign({}, parameterMap['*'], parameterMap[stack.stackName]),\n      resourcesToImport,\n      importExistingResources: options.importExistingResources,\n      changeSetName: options.changeSetName,\n      failOnError: options.method === 'change-set',\n    });\n  }\n\n  public async deploy(options: DeployOptions) {\n    if (options.watch) {\n      return this.watch(options);\n    }\n\n    // set progress from options, this includes user and app config\n    if (options.progress) {\n      this.ioHost.stackProgress = options.progress;\n    }\n\n    // the ioHost uses this internally to determine if a confirmation\n    // is actually needed, so it needs the same value we determine here.\n    const requireApproval = options.requireApproval ?? RequireApproval.BROADENING;\n    this.ioHost.requireDeployApproval = requireApproval;\n\n    // toolkit-lib emits the approval request (I5060) without mentioning\n    // `--require-approval`. The CLI owns that flag, so it adds the framing here.\n    // Both deploy paths resolve through this host, so one listener covers both.\n    // Method-scoped (`using`): `deploy()` can run repeatedly (watch mode), and\n    // each run must register a rewrite for its own `requireApproval` value.\n    using _approvalFraming = this.ioHost.rewrite(IO.CDK_TOOLKIT_I5060, (msg) => {\n      const updateTypeText = requireApproval === RequireApproval.DESTRUCTIVE\n        ? 'destructive updates'\n        : msg.data.permissionChangeType !== PermissionChangeType.NONE\n          ? 'security-sensitive updates'\n          : 'updates';\n      return `Stack includes ${updateTypeText} and \"--require-approval\" is set to '${requireApproval}'.\\nDo you wish to deploy these changes?`;\n    });\n\n    // execute-change-set is a new flow that we can just delegate to toolkit-lib\n    if (options.deploymentMethod?.method === 'execute-change-set') {\n      await this.toolkit.deploy(this.props.cloudExecutable, {\n        deploymentMethod: options.deploymentMethod,\n        stacks: {\n          patterns: options.selector.patterns,\n          strategy: StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE,\n          expand: ExpandStackSelection.NONE,\n        },\n        roleArn: options.roleArn,\n        forceDeployment: options.force,\n        rollback: options.rollback,\n        reuseAssets: options.reuseAssets,\n        concurrency: options.concurrency,\n        traceLogs: options.traceLogs,\n        notificationArns: options.notificationArns,\n        tags: options.tags,\n        outputsFile: options.outputsFile,\n        assetParallelism: options.assetParallelism,\n        assetBuildConcurrency: options.assetBuildConcurrency,\n        assetBuildTime: options.assetBuildTime,\n        parameters: undefined, // parameters are only set during change set creation, so this is explicitly unset because change set already exists\n      });\n      return;\n    }\n\n    const startSynthTime = new Date().getTime();\n    const assembly = await this.assembly(options.cacheCloudAssembly);\n    const stackCollection = await assembly.selectStacks(options.selector);\n    await this.validateStacks(stackCollection);\n    const elapsedSynthTime = new Date().getTime() - startSynthTime;\n    await this.ioHost.asIoHelper().defaults.info(`\\n✨  Synthesis time: ${formatTime(elapsedSynthTime)}s\\n`);\n\n    if (stackCollection.stackCount === 0) {\n      await this.ioHost.asIoHelper().defaults.error('This app contains no stacks');\n      return;\n    }\n\n    const migrator = new ResourceMigrator({\n      deployments: this.props.deployments,\n      ioHelper: asIoHelper(this.ioHost, 'deploy'),\n    });\n    await migrator.tryMigrateResources(stackCollection, {\n      toolkitStackName: this.toolkitStackName,\n      ...options,\n    });\n\n    if (options.deploymentMethod?.method === 'hotswap') {\n      await this.ioHost.asIoHelper().defaults.warn(\n        '⚠️ The --hotswap and --hotswap-fallback flags deliberately introduce CloudFormation drift to speed up deployments',\n      );\n      await this.ioHost.asIoHelper().defaults.warn('⚠️ They should only be used for development - never use them for your production Stacks!\\n');\n    }\n\n    const stacks = stackCollection.stackArtifacts;\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    if (concurrency > 1) {\n      // the \"bar\" progress output doesn't support concurrency, fall back to \"events\"\n      if (this.ioHost.stackProgress === StackActivityProgress.BAR) {\n        this.ioHost.stackProgress = StackActivityProgress.EVENTS;\n      }\n\n      // ...but only warn if the user explicitly requested \"bar\" progress\n      if (options.progress === StackActivityProgress.BAR) {\n        await this.ioHost.asIoHelper().defaults.warn('⚠️ The --concurrency flag does not support --progress \"bar\". Switching to \"events\".');\n      }\n    }\n\n    const stacksAndTheirAssetManifests = stacks.flatMap((stack) => [\n      stack,\n      ...stack.dependencies.filter(x => cxapi.AssetManifestArtifact.isAssetManifestArtifact(x)),\n    ]);\n    const workGraph = new WorkGraphBuilder(\n      asIoHelper(this.ioHost, 'deploy'),\n      prebuildAssets,\n    ).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': (options.assetParallelism ?? true) ? options.assetBuildConcurrency ?? 1 : 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      'marker': 1,\n    };\n\n    const deploymentActions = new WorkGraphDeploymentActions(this.props.deployments, this.ioHost, this, {\n      roleArn: options.roleArn,\n      force: options.force,\n      stackCount: stackCollection.stackCount,\n      notificationArns: options.notificationArns,\n      deploymentMethod: options.deploymentMethod,\n      toolkitStackName: this.toolkitStackName,\n      reuseAssets: options.reuseAssets,\n      tags: options.tags,\n      parameters: options.parameters,\n      usePreviousParameters: options.usePreviousParameters,\n      rollback: options.rollback,\n      concurrency,\n      requireApproval,\n      assetParallelism: options.assetParallelism,\n      extraUserAgent: options.extraUserAgent,\n      cloudWatchLogMonitor: options.cloudWatchLogMonitor,\n      sdkProvider: this.props.sdkProvider,\n      express: options.express,\n    });\n\n    const startDeployTime = Date.now();\n\n    await workGraph.doParallel(graphConcurrency, deploymentActions);\n\n    if (options.outputsFile) {\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      await deploymentActions.writeOutputs(options.outputsFile);\n    }\n\n    // Add a timer on the COMMAND span for the full deployment wait time (not the same as the sum of all DEPLOY\n    // spans because of parallelism).\n    this.ioHost.telemetry?.commandSpan?.addTimer('totalDeployTime', Date.now() - startDeployTime);\n\n    await this.ioHost.asIoHelper().defaults.info(`\\n✨  Total time: ${formatTime(Date.now() - startSynthTime)}s\\n`);\n  }\n\n  /**\n   * Detect infrastructure drift for the given stack(s)\n   */\n  public async drift(options: DriftOptions): Promise<number> {\n    const driftResults = await this.toolkit.drift(this.props.cloudExecutable, {\n      stacks: options.selector,\n    });\n\n    const totalDrifts = Object.values(driftResults).reduce((total, current) => total + (current.numResourcesWithDrift ?? 0), 0);\n    return totalDrifts > 0 && options.fail ? 1 : 0;\n  }\n\n  /**\n   * Validate synthesized templates against policy rules\n   */\n  public async validate(options: CliValidateOptions): Promise<number | void> {\n    // Implicitly switch 'debug' mode to true; more stack traces = more useful.\n    this.props.cloudExecutable.switchOnDebugging();\n\n    // `watch` is a CLI-only flag; strip it before crossing into toolkit-lib so\n    // it does not leak into the library's validate action.\n    const { watch, ...validateOptions } = options;\n\n    if (watch) {\n      return this.validateWatch(validateOptions);\n    }\n\n    const result = await this.toolkit.validate(this.props.cloudExecutable, validateOptions);\n    return result.conclusion === 'failure' ? 1 : 0;\n  }\n\n  /**\n   * Continuously validate the project, re-synthesizing and re-validating on\n   * every file change. Never deploys.\n   *\n   * The files to observe are configured with the \"watch\" key of `cdk.json`,\n   * exactly like `cdk deploy --watch`.\n   */\n  private async validateWatch(options: ValidateOptions): Promise<void> {\n    const rootDir = path.dirname(path.resolve(PROJECT_CONFIG));\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        'WatchConfigMissing',\n        \"Cannot use '--watch' without specifying at least one directory to monitor. \" +\n        'Make sure to add a \"watch\" key to your cdk.json',\n      );\n    }\n\n    const include = this.patternsArrayForWatch(watchSettings.include, {\n      defaultPattern: '**',\n      returnDefaultIfEmpty: true,\n    });\n    // Pass the user's excludes explicitly; toolkit-lib always appends the\n    // outdir, dot-file, and node_modules excludes on top of these.\n    const exclude = this.patternsArrayForWatch(watchSettings.exclude, {\n      defaultPattern: '',\n      returnDefaultIfEmpty: false,\n    });\n\n    const watcher = await this.toolkit.watchValidate(this.props.cloudExecutable.uncachedSource(), {\n      ...options,\n      watchDir: rootDir,\n      include,\n      exclude,\n    });\n    return watcher.waitForEnd();\n  }\n\n  /**\n   * Diagnose errors\n   */\n  public async diagnose(options: DiagnoseOptions): Promise<number> {\n    // Implicitly switch 'debug' mode to true; more stack traces = more useful.\n    this.props.cloudExecutable.switchOnDebugging();\n\n    const results = await this.toolkit.diagnose(this.props.cloudExecutable, options);\n\n    if (results.stacks.some(s => s.result.type !== 'no-problem')) {\n      return 1;\n    }\n    return 0;\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 assembly = await this.assembly();\n    const stackCollection = await assembly.selectStacks(options.selector);\n    await this.validateStacks(stackCollection);\n    const elapsedSynthTime = new Date().getTime() - startSynthTime;\n    await this.ioHost.asIoHelper().defaults.info(`\\n✨  Synthesis time: ${formatTime(elapsedSynthTime)}s\\n`);\n\n    if (stackCollection.stackCount === 0) {\n      await this.ioHost.asIoHelper().defaults.error('No stacks selected');\n      return;\n    }\n\n    let anyRollbackable = false;\n\n    for (const stack of stackCollection.stackArtifacts) {\n      await this.ioHost.asIoHelper().defaults.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          orphanFailedResources: 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        await this.ioHost.asIoHelper().defaults.info(`\\n✨  Rollback time: ${formatTime(elapsedRollbackTime).toString()}s\\n`);\n      } catch (e: any) {\n        await this.ioHost.asIoHelper().defaults.error('\\n ❌  %s failed: %s', chalk.bold(stack.displayName), formatErrorMessage(e));\n        throw new ToolkitError('RollbackFailed', 'Rollback failed (use --force to orphan failing resources)');\n      }\n    }\n    if (!anyRollbackable) {\n      throw new ToolkitError('NoRollbackableStacks', 'No stacks were in a state that could be rolled back');\n    }\n  }\n\n  public async publishAssets(options: PublishAssetsOptions): Promise<void> {\n    await this.toolkit.publishAssets(this.props.cloudExecutable, options);\n  }\n\n  public async watch(options: WatchOptions) {\n    const rootDir = path.dirname(path.resolve(PROJECT_CONFIG));\n    const ioHelper = asIoHelper(this.ioHost, 'watch');\n    await this.ioHost.asIoHelper().defaults.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        'WatchConfigMissing',\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    // Note: We use '**' as the default pattern (not rootDir) because chokidar reports\n    // file paths relative to cwd, and the ignored function uses picomatch which expects\n    // glob patterns, not absolute paths.\n    const watchIncludes = this.patternsArrayForWatch(watchSettings.include, {\n      defaultPattern: '**',\n      returnDefaultIfEmpty: true,\n    });\n    await this.ioHost.asIoHelper().defaults.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      defaultPattern: '',\n      returnDefaultIfEmpty: false,\n    }).concat(`${outputDir}/**`, '**/.*', '**/.*/**', '**/node_modules/**');\n    await this.ioHost.asIoHelper().defaults.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({\n      ioHelper,\n    }) : undefined;\n    const deployAndWatch = async () => {\n      latch = 'deploying';\n      await 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        await this.ioHost.asIoHelper().defaults.info(\"Detected file changes during deployment. Invoking 'cdk deploy' again\");\n        await this.invokeDeployFromWatch(options, cloudWatchLogMonitor);\n      }\n      latch = 'open';\n      await cloudWatchLogMonitor?.activate();\n    };\n\n    // Create ignore matcher for chokidar v4 compatibility\n    // Chokidar v4 removed glob pattern support, so we use picomatch to filter files\n    // We pass rootDir because chokidar v4 passes absolute paths to the ignored callback\n    const shouldIgnore = createIgnoreMatcher({\n      include: watchIncludes,\n      exclude: watchExcludes,\n      rootDir,\n    });\n    const outputsFile = options.outputsFile ? path.resolve(options.outputsFile) : undefined;\n\n    chokidar\n      .watch('.', {\n        ignored: (filePath, stats) =>\n          path.resolve(rootDir, filePath) === outputsFile ||\n          shouldIgnore(filePath, stats),\n        cwd: rootDir,\n      })\n      .on('ready', async () => {\n        latch = 'open';\n        await this.ioHost.asIoHelper().defaults.debug(\"'watch' received the 'ready' event. From now on, all file changes will trigger a deployment\");\n        await this.ioHost.asIoHelper().defaults.info(\"Triggering initial 'cdk deploy'\");\n        await deployAndWatch();\n      })\n      .on('all', async (event: EventName, filePath?: string) => {\n        if (!isFileEvent(event)) {\n          return; // Ignore non-file events like 'error', 'raw', 'ready', 'all'\n        }\n        if (latch === 'pre-ready') {\n          await this.ioHost.asIoHelper().defaults.info(`'watch' is observing ${event === 'addDir' ? 'directory' : 'the file'} '%s' for changes`, filePath);\n        } else if (latch === 'open') {\n          await this.ioHost.asIoHelper().defaults.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          await this.ioHost.asIoHelper().defaults.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 orphan(options: OrphanOptions) {\n    await this.toolkit.orphan(this.props.cloudExecutable, {\n      constructPaths: options.constructPath,\n      roleArn: options.roleArn,\n      toolkitStackName: options.toolkitStackName,\n    });\n  }\n\n  public async import(options: ImportOptions) {\n    const assembly = await this.assembly();\n    const stacks = await assembly.selectStacks(options.selector);\n    await this.validateStacks(stacks);\n\n    // set progress from options, this includes user and app config\n    if (options.progress) {\n      this.ioHost.stackProgress = options.progress;\n    }\n\n    if (stacks.stackCount > 1) {\n      throw new ToolkitError(\n        'AmbiguousStackSelection',\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 && !options.resourceMappingInline) {\n      throw new ToolkitError('ResourceMappingRequired', '--resource-mapping or --resource-mapping-inline is required when input is not a terminal');\n    }\n\n    const stack = stacks.stackArtifacts[0];\n\n    await this.ioHost.asIoHelper().defaults.info(chalk.bold(stack.displayName));\n\n    const resourceImporter = new ResourceImporter(stack, {\n      deployments: this.props.deployments,\n      ioHelper: asIoHelper(this.ioHost, 'import'),\n    });\n    const { additions, hasNonAdditions, diffFormatter } = await resourceImporter.discoverImportableResources(options.force);\n\n    // If there are non-addition changes (e.g. after orphan, hardcoded refs differ from Fn::GetAtt),\n    // warn the user and ask for confirmation unless --force was given.\n    if (hasNonAdditions && !options.force) {\n      const ioHelper = this.ioHost.asIoHelper();\n      await ioHelper.defaults.info(\n        `The following resources have pending updates that will be reconciled with a ${chalk.blueBright('cdk deploy')} after import:`,\n      );\n      const { formattedDiff } = diffFormatter.formatStackDiff();\n      await ioHelper.defaults.info(formattedDiff);\n      const confirmed = await ioHelper.requestResponse(IO.CDK_TOOLKIT_I7010.req('Perform import?', { motivation: 'Confirm import with pending drift' }));\n      if (!confirmed) {\n        throw new AbortError('ImportAborted', 'Import cancelled');\n      }\n    }\n\n    if (additions.length === 0) {\n      await this.ioHost.asIoHelper().defaults.warn(\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    let actualImport: Awaited<ReturnType<typeof resourceImporter.askForResourceIdentifiers>>;\n    if (options.resourceMappingInline) {\n      actualImport = await resourceImporter.loadResourceIdentifiers(additions, options.resourceMappingInline);\n    } else if (options.resourceMappingFile) {\n      actualImport = await resourceImporter.loadResourceIdentifiersFromFile(additions, options.resourceMappingFile);\n    } else {\n      actualImport = await resourceImporter.askForResourceIdentifiers(additions);\n    }\n\n    if (actualImport.importResources.length === 0) {\n      await this.ioHost.asIoHelper().defaults.warn('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      await this.ioHost.asIoHelper().defaults.info('%s: mapping file written.', outputFile);\n      return;\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('InvalidSnsTopicArn', `Notification arn ${notificationArn} is not a valid arn for an SNS topic`);\n      }\n    }\n\n    // Import the resources according to the given mapping\n    await this.ioHost.asIoHelper().defaults.info('%s: importing resources into stack...', chalk.bold(stack.displayName));\n    await resourceImporter.importResourcesFromMap(actualImport, {\n      roleArn: options.roleArn,\n      deploymentMethod: options.deploymentMethod,\n      usePreviousParameters: true,\n      rollback: options.rollback,\n      notificationArns,\n    });\n\n    // Notify user of next steps\n    if (actualImport.importResources.length < additions.length) {\n      await this.ioHost.asIoHelper().defaults.warn(\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      // After orphan→import, the deployed template still has hardcoded values that differ from\n      // the synth'd template's Fn::GetAtt/Ref intrinsics. A deploy updates the template to match the CDK app.\n      if (options.force) {\n        await this.ioHost.asIoHelper().defaults.info(\n          `Import complete. Run ${chalk.blueBright('cdk deploy')} to update the stack to match your CDK app.`,\n        );\n      } else {\n        const deployNow = await this.ioHost.asIoHelper().requestResponse(\n          IO.CDK_TOOLKIT_I7010.req(`Finish with a ${chalk.blueBright('cdk deploy')} now?`, { motivation: 'Update stack to match CDK app after import' }),\n        );\n        if (deployNow) {\n          await this.deploy({\n            // The import selector is exact (no expansion); the follow-up deploy\n            // historically expands to upstream dependencies like a plain deploy.\n            selector: { ...options.selector, expand: ExpandStackSelection.UPSTREAM },\n            toolkitStackName: options.toolkitStackName,\n            roleArn: options.roleArn,\n            deploymentMethod: options.deploymentMethod,\n          });\n        } else {\n          await this.ioHost.asIoHelper().defaults.info(\n            `Import complete. Remember to run ${chalk.blueBright('cdk deploy')} to update the stack to match your CDK app.`,\n          );\n        }\n      }\n    } else {\n      await this.ioHost.asIoHelper().defaults.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    }\n  }\n\n  // The destroy action runs through toolkit-lib.\n  // Suppress its new status messages to keep the output as it was before.\n  @suppressMessages(\n    IO.CDK_TOOLKIT_I1001, // Starting Synthesis (trace)\n    IO.CDK_TOOLKIT_I1000, // ✨ Synthesis time (info)\n    IO.CDK_TOOLKIT_I7101, // Starting Destroy (trace)\n    IO.CDK_TOOLKIT_I7001, // per-stack Destroy time (trace)\n    IO.CDK_TOOLKIT_I7000, // ✨ Destroy time (info)\n  )\n  public async destroy(options: DestroyOptions) {\n    // Keep the \"deployed\" wording when a destroy runs as part of a deploy.\n    const action = options.fromDeploy ? 'deploy' : 'destroy';\n\n    if ((options.concurrency || 1) > 1 && this.ioHost.stackProgress === StackActivityProgress.BAR) {\n      this.ioHost.stackProgress = StackActivityProgress.EVENTS;\n    }\n\n    // The success line was `info` in the historical `cdk destroy`, not `result`.\n    using _successLevel = this.ioHost.on(IO.CDK_TOOLKIT_I7900, () => ({ level: 'info' })); // ✅ <stack>: destroyed\n\n    // toolkit-lib logs a declined confirmation (E7010) and returns gracefully.\n    // The CLI surfaces a decline as a non-zero, soft exit instead: throwing from\n    // the listener both suppresses the log and aborts the command (the top-level\n    // renders `AbortError` as \"Deletion cancelled\").\n    using _declineAborts = this.ioHost.on(IO.CDK_TOOLKIT_E7010, () => {\n      throw new AbortError('DestroyAborted', 'Deletion cancelled');\n    });\n\n    using _forceConfirms = options.force ? this.ioHost.respondOnce(IO.CDK_TOOLKIT_I7010, true) : undefined;\n\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore - `_destroyWithAction` is private; the CLI sets the action label.\n    await this.toolkit._destroyWithAction(this.props.cloudExecutable, action, {\n      stacks: options.selector,\n      roleArn: options.roleArn,\n      concurrency: options.concurrency,\n      express: options.express,\n    });\n  }\n\n  // cdk ls stdout is the stack listing only. Suppress the info status lines synthesis emits next\n  // to it: the synth-time line (I1000) and the dependency-expansion note (I1002).\n  @suppressMessages(IO.CDK_TOOLKIT_I1000, IO.CDK_TOOLKIT_I1002)\n  public async list(\n    selectors: string[],\n    options: { long?: boolean; json?: boolean; showDeps?: boolean } = {},\n  ): Promise<number> {\n    // One-shot: disposes itself when the listing (I2901) is emitted; the\n    // `using` covers the case where `list` throws before that happens.\n    using _formatter = this.ioHost.rewriteOnce(IO.CDK_TOOLKIT_I2901, (msg) => formatStackList(msg.data.stacks, options));\n\n    await this.toolkit.list(this.props.cloudExecutable, {\n      stacks: selectors.length > 0 ? selectWithUpstream(...selectors) : undefined,\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(options: SynthOptions): Promise<any> {\n    const stackNames = options.stackNames;\n    const exclusively = options.exclusively ?? false;\n    const quiet = options.quiet ?? false;\n    const autoValidate = options.autoValidate ?? false;\n    const json = options.json ?? false;\n\n    const assembly = await this.assembly();\n    const stacks = await this.selectTopLevelOrMatchingStacks(assembly, stackNames, exclusively);\n\n    const autoValidateStacks = autoValidate\n      ? assembly.selectStacksForValidation()\n      : new StackCollection(assembly, []);\n\n    await this.validateStacks(stacks.concat(autoValidateStacks));\n\n    // if we have a single stack, print it to STDOUT\n    if (stacks.stackCount === 1) {\n      if (!quiet) {\n        await printSerializedObject(this.ioHost.asIoHelper(), obscureTemplate(stacks.firstStack.template), json);\n      }\n\n      // In CI mode, non-error messages go to stdout. When we just printed the\n      // template to stdout, skip the flags message to preserve the contract that\n      // `cdk synth` output is valid YAML. When quiet (no template printed) or\n      // non-CI (flags go to stderr), it's safe to show.\n      if (quiet || !this.ioHost.isCI) {\n        await displayFlagsMessage(this.ioHost.asIoHelper(), this.toolkit, this.props.cloudExecutable);\n      }\n      return undefined;\n    }\n\n    // not outputting template to stdout, let's explain things to the user a little bit...\n    await this.ioHost.asIoHelper().defaults.info(chalk.green(`Successfully synthesized to ${chalk.blue(path.resolve(stacks.assembly.directory))}`));\n    await this.ioHost.asIoHelper().defaults.info(\n      `Supply a stack id (${stacks.stackArtifacts.map((s) => chalk.green(s.hierarchicalId)).join(', ')}) to display its template.`,\n    );\n\n    await displayFlagsMessage(this.ioHost.asIoHelper(), this.toolkit, this.props.cloudExecutable);\n    return undefined;\n  }\n\n  /**\n   * Continuously synthesize the project, re-synthesizing on every file change.\n   * Never deploys, and never prints templates to stdout.\n   *\n   * The files to observe are configured with the \"watch\" key of `cdk.json`,\n   * exactly like `cdk deploy --watch`.\n   */\n  public async synthWatch(options: ToolkitSynthOptions): Promise<void> {\n    const rootDir = path.dirname(path.resolve(PROJECT_CONFIG));\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        'WatchConfigMissing',\n        \"Cannot use '--watch' without specifying at least one directory to monitor. \" +\n        'Make sure to add a \"watch\" key to your cdk.json',\n      );\n    }\n\n    const include = this.patternsArrayForWatch(watchSettings.include, {\n      defaultPattern: '**',\n      returnDefaultIfEmpty: true,\n    });\n    // Pass the user's excludes explicitly; toolkit-lib always appends the\n    // outdir, dot-file, and node_modules excludes on top of these.\n    const exclude = this.patternsArrayForWatch(watchSettings.exclude, {\n      defaultPattern: '',\n      returnDefaultIfEmpty: false,\n    });\n\n    const watcher = await this.toolkit.watchSynth(this.props.cloudExecutable.uncachedSource(), {\n      ...options,\n      watchDir: rootDir,\n      include,\n      exclude,\n    });\n    return watcher.waitForEnd();\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, asIoHelper(this.ioHost, 'bootstrap'));\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      await this.ioHost.asIoHelper().defaults.info(chalk.green(' ⏳  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        await this.ioHost.asIoHelper().defaults.info(chalk.green(message), chalk.blue(environment.name));\n\n        if (options.express) {\n          const warning = formatExpressStabilizationWarning(result.stabilizingResources, 'bootstrap');\n          if (warning) {\n            await this.ioHost.asIoHelper().notify(IO.CDK_TOOLKIT_W9902.msg(warning));\n          }\n        }\n      } catch (e) {\n        await this.ioHost.asIoHelper().defaults.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      await this.ioHost.asIoHelper().defaults.info(chalk.green(' ⏳  Garbage Collecting environment %s...'), chalk.blue(environment.name));\n      const gc = new GarbageCollector({\n        sdkProvider: this.props.sdkProvider,\n        ioHelper: asIoHelper(this.ioHost, 'gc'),\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          'InvalidEnvironmentGlob',\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          'EnvironmentRequired',\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      const assembly = await this.assembly();\n      const allStacks = await assembly.selectStacks(ALL_STACKS);\n      environments.push(\n        ...(await globEnvironmentsFromStacks(allStacks, 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    await this.ioHost.asIoHelper().defaults.warn('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 (options.filter?.length && scanType !== TemplateSourceOptions.SCAN) {\n        const sourceOption = scanType === TemplateSourceOptions.STACK ? '--from-stack' : '--from-path';\n        throw new ToolkitError(\n          'MigrateFilterRequiresScan',\n          `--filter cannot be used with ${sourceOption}; remove --filter to migrate this source`,\n        );\n      }\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          ioHelper: this.ioHost.asIoHelper(),\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?.AWSToolsMetrics?.IaC_Generator?.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), this.ioHost.asIoHelper());\n          const generatedTemplateSummary = await cfn.describeGeneratedTemplate(templateId);\n          generateTemplateOutput = buildGeneratedTemplateOutput(\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('StackTemplateNotFound', `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('InvalidSourceOption', `Invalid source option provided: ${scanType}`);\n      }\n      const stack = generateStack(generateTemplateOutput.migrateJson.templateBody, options.stackName, language);\n      await this.ioHost.asIoHelper().defaults.info(chalk.green(' ⏳  Generating CDK app for %s...'), chalk.blue(options.stackName));\n      await generateCdkApp(this.ioHost.asIoHelper(), 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        await this.ioHost.asIoHelper().defaults.warn(\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      await this.ioHost.asIoHelper().defaults.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), this.ioHost.asIoHelper());\n        }\n        if (!process.env.MIGRATE_INTEG_TEST) {\n          await cfn.deleteGeneratedTemplate(templateToDelete);\n        }\n      }\n    }\n  }\n\n  public async refactor(options: RefactorOptions): Promise<number> {\n    if (options.revert && !options.overrideFile) {\n      throw new ToolkitError('RevertRequiresOverrideFile', 'The --revert option can only be used with the --override-file option.');\n    }\n\n    try {\n      await this.toolkit.refactor(this.props.cloudExecutable, {\n        dryRun: options.dryRun,\n        stacks: options.stacks ?? ALL_STACKS,\n        force: options.force,\n        additionalStackNames: options.additionalStackNames,\n        overrides: readOverrides(options.overrideFile, options.revert),\n        roleArn: options.roleArn,\n      });\n    } catch (e) {\n      await this.ioHost.asIoHelper().defaults.error((e as Error).message);\n      throw e;\n    }\n\n    return 0;\n\n    function readOverrides(filePath: string | undefined, revert: boolean = false) {\n      if (filePath == null) {\n        return [];\n      }\n      if (!fs.pathExistsSync(filePath)) {\n        throw new ToolkitError('MappingFileNotFound', `The mapping file ${filePath} does not exist`);\n      }\n      const groups = parseMappingGroups(fs.readFileSync(filePath).toString('utf-8'));\n\n      return revert\n        ? groups.map((group) => ({\n          ...group,\n          resources: Object.fromEntries(Object.entries(group.resources ?? {}).map(([src, dst]) => [dst, src])),\n        }))\n        : groups;\n    }\n  }\n\n  /**\n   * Select the stacks that `synth` and `diff` operate on\n   *\n   * With patterns: match them (failing if nothing matches), expanding to\n   * upstream dependencies unless `exclusively` is set. Without patterns: all\n   * top-level stacks, exactly — the historic default selection never expands\n   * to dependencies, regardless of `exclusively`. A stage-only app has no\n   * top-level stacks, which selects nothing and is not an error — but an app\n   * without any stacks at all still is. No single selection strategy covers\n   * this combination: `MAIN_ASSEMBLY` rejects stage-only apps (as\n   * `deploy --all` must keep doing) and `ALL_STACKS` would wrongly include\n   * the stacks inside stages.\n   */\n  private async selectTopLevelOrMatchingStacks(\n    assembly: StackAssembly,\n    patterns: string[],\n    exclusively?: boolean,\n  ): Promise<StackCollection> {\n    if (patterns.length > 0) {\n      return assembly.selectStacks(\n        mustMatch(exclusively ? selectExact(...patterns) : selectWithUpstream(...patterns)),\n      );\n    }\n\n    if (assembly.cloudAssembly.stacks.length > 0) {\n      return assembly.selectStacks(selectAllTopLevel(ExpandStackSelection.NONE));\n    }\n\n    // Stage-only app: nothing to select, which is not an error. An app\n    // without any stacks at all still is: this selection throws\n    // 'This app contains no stacks' in that case.\n    await assembly.selectStacks(ALL_STACKS);\n    return new StackCollection(assembly, []);\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    const failAt = this.validateMetadataFailAt();\n    await stacks.reportValidationFailuresAndThrow(failAt, this.ioHost.asIoHelper());\n  }\n\n  private validateMetadataFailAt(): 'warn' | 'error' | 'none' {\n    let failAt: 'warn' | 'error' | 'none' = 'error';\n    if (this.props.ignoreErrors) {\n      failAt = 'none';\n    }\n    if (this.props.strict) {\n      failAt = 'warn';\n    }\n\n    return failAt;\n  }\n\n  /**\n   * Converts the toolkit's `CloudExecutable` into `StackAssembly`.\n   *\n   * @param cacheCloudAssembly - to cache the assembly, defaults to `true`\n   * @returns the converted `StackAssembly`\n   */\n  public assembly(cacheCloudAssembly: boolean = true): Promise<StackAssembly> {\n    return this.props.cloudExecutable.synthesize(cacheCloudAssembly);\n  }\n\n  private patternsArrayForWatch(\n    patterns: string | string[] | undefined,\n    options: { defaultPattern: string; returnDefaultIfEmpty: boolean },\n  ): string[] {\n    const patternsArray: string[] = patterns !== undefined ? (Array.isArray(patterns) ? patterns : [patterns]) : [];\n    return patternsArray.length > 0 ? patternsArray : options.returnDefaultIfEmpty ? [options.defaultPattern] : [];\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      extraUserAgent: `cdk-watch/hotswap-${options.deploymentMethod?.method === 'hotswap' ? '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 */\nasync function printSerializedObject(ioHelper: IoHelper, obj: any, json: boolean) {\n  await ioHelper.defaults.result(serializeStructure(obj, json));\n}\n\n/**\n * Options for the synth command\n */\nexport interface SynthOptions {\n  /**\n   * Stack names to synthesize\n   */\n  readonly stackNames: string[];\n\n  /**\n   * Only select the given stacks, without expanding to their upstream dependencies\n   *\n   * @default false\n   */\n  readonly exclusively?: boolean;\n\n  /**\n   * Do not print the template to stdout\n   *\n   * @default false\n   */\n  readonly quiet?: boolean;\n\n  /**\n   * Additionally validate stacks that have the `validateOnSynth` flag set\n   *\n   * @default false\n   */\n  readonly autoValidate?: boolean;\n\n  /**\n   * Print the template as JSON instead of YAML\n   *\n   * @default false\n   */\n  readonly json?: boolean;\n}\n\n/**\n * Options for the diff command\n */\nexport interface DiffOptions {\n  /**\n   * Stack names to diff\n   */\n  readonly 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  readonly exclusively?: boolean;\n\n  /**\n   * Used a template from disk instead of from the server\n   *\n   * @default Use from the server\n   */\n  readonly templatePath?: string;\n\n  /**\n   * Strict diff mode\n   *\n   * @default false\n   */\n  readonly strict?: boolean;\n\n  /**\n   * How many lines of context to show in the diff\n   *\n   * @default 3\n   */\n  readonly contextLines?: number;\n\n  /**\n   * Which kind of change makes the diff fail with exit code 1\n   *\n   * - `any-change`: any difference\n   * - `broadening`: a change that broadens security permissions\n   * - `destructive`: a change that replaces, deletes or orphans an existing resource\n   * - `never`: the diff never fails\n   *\n   * @default RequireApproval.NEVER\n   */\n  readonly failOn?: RequireApproval;\n\n  /**\n   * Only run diff on broadened security changes\n   *\n   * @default false\n   */\n  readonly 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  readonly compareAgainstProcessedTemplate?: boolean;\n\n  /*\n   * Run diff in quiet mode without printing the diff statuses\n   *\n   * @default false\n   */\n  readonly quiet?: boolean;\n\n  /**\n   * Additional parameters for CloudFormation at diff time, used to create a change set\n   * @default {}\n   */\n  readonly parameters?: { [name: string]: string | undefined };\n\n  /**\n   * How to compute the diff.\n   * - 'change-set': always use a changeset, fail if it cannot be created\n   * - 'template': skip changeset, compare templates directly\n   * - 'auto': try changeset, fall back to template on failure\n   *\n   * @default 'auto'\n   */\n  readonly method?: 'auto' | 'change-set' | 'template';\n\n  /**\n   * Name of the CloudFormation change set to create when computing the diff\n   *\n   * Only used if the method is not 'template'.\n   *\n   * @default 'cdk-diff-change-set-<uuid>'\n   */\n  readonly changeSetName?: string;\n\n  /**\n   * Whether or not the change set imports resources that already exist.\n   *\n   * @default false\n   */\n  readonly importExistingResources?: boolean;\n\n  /**\n   * Whether to include resource moves in the diff\n   *\n   * @default false\n   */\n  readonly includeMoves?: 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   * 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\n/**\n * Options for the validate command\n */\nexport interface CliValidateOptions extends ValidateOptions {\n  /**\n   * Continuously observe the project files, and re-validate automatically when changes are detected\n   *\n   * @default false\n   */\n  readonly watch?: boolean;\n}\n\ninterface WatchOptions extends Omit<CfnDeployOptions, 'execute'> {\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   * 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   * 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   * 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   * Maximum number of asset builds to run in parallel\n   *\n   * This setting only has an effect if `assetParallelism` is set to `true`.\n   *\n   * @default 1\n   */\n  readonly assetBuildConcurrency?: number;\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 use CloudFormation express mode for the current deployment\n   */\n  readonly express?: 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 OrphanOptions {\n  readonly constructPath: string[];\n  readonly roleArn?: string;\n  readonly toolkitStackName?: string;\n}\n\nexport interface ImportOptions extends CfnDeployOptions {\n  /**\n   * ARNs of SNS topics that CloudFormation will notify with stack related events.\n   *\n   * The following semantics apply (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   *\n   * @default - No notifications\n   */\n  readonly notificationArns?: string[];\n\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   * Inline JSON string with the physical resource mapping\n   *\n   * @default - No inline mapping\n   */\n  readonly resourceMappingInline?: 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 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   * Maximum number of simultaneous destroys (dependency permitting) to execute.\n   */\n  concurrency?: number;\n\n  /**\n   * Whether to use CloudFormation express mode to delete the stack(s)\n   */\n  express?: 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}\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\nexport interface RefactorOptions {\n  /**\n   * Whether to only show the proposed refactor, without applying it\n   */\n  readonly dryRun: boolean;\n\n  /**\n   * The absolute path to a file that contains overrides to the mappings\n   * computed by the CLI. This file should contain a JSON object with\n   * the following format:\n   *\n   *     {\n   *       \"environments\": [\n   *         {\n   *           \"account\": \"123456789012\",\n   *           \"region\": \"us-east-1\",\n   *           \"resources\": {\n   *             \"Foo.OldName\": \"Bar.NewName\",\n   *           }\n   *         },\n   *       ]\n   *     }\n   *\n   * where mappings are grouped by environment. The `resources` object contains\n   * a mapping where each key is the source location and the value is the\n   * destination location. Locations must be in the format `StackName.LogicalId`.\n   * The source must refer to a location where there is a resource currently\n   * deployed, while the destination must refer to a location that is not already\n   * occupied by any resource.\n   */\n  overrideFile?: string;\n\n  /**\n   * Modifies the behavior of the `overrideFile` option by swapping source and\n   * destination locations. This is useful when you want to undo a refactor\n   * that was previously applied.\n   */\n  revert?: boolean;\n\n  /**\n   * Whether to do the refactor without prompting the user for confirmation.\n   */\n  force?: boolean;\n\n  /**\n   * Criteria for selecting stacks to compare with the deployed stacks in the\n   * target environment.\n   */\n  stacks?: StackSelector;\n\n  /**\n   * A list of names of additional deployed stacks to be included in the comparison.\n   */\n  additionalStackNames?: string[];\n\n  /**\n   * Role to assume in the target environment before performing the refactor.\n   */\n  roleArn?: string;\n}\n\n/**\n * Options for the drift command\n */\nexport interface DriftOptions {\n  /**\n   * Criteria for selecting stacks to detect drift on\n   */\n  readonly selector: StackSelector;\n\n  /**\n   * Whether to fail with exit code 1 if drift is detected\n   *\n   * @default false\n   */\n  readonly fail?: 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  req: ActionLessRequest<ConfirmationRequest, boolean>,\n  abortErrorCode: string,\n  abortMessage: string,\n) {\n  await ioHost.withCorkedLogging(async () => {\n    // The IoHost returns the answer rather than aborting; abort here on decline.\n    const confirmed = await ioHost.asIoHelper().requestResponse(req);\n    if (!confirmed) {\n      throw new AbortError(abortErrorCode, abortMessage);\n    }\n  });\n}\n\n/**\n * Display a warning if there are flags that are different from the recommended value\n *\n * This happens if both of the following are true:\n *\n * - The user didn't configure the value\n * - The default value for the flag (unconfiguredBehavesLike) is different from the recommended value\n */\nexport async function displayFlagsMessage(ioHost: IoHelper, toolkit: InternalToolkit, cloudExecutable: CloudExecutable): Promise<void> {\n  const flags = await toolkit.flags(cloudExecutable);\n\n  // The \"unconfiguredBehavesLike\" information got added later. If none of the flags have this information,\n  // we don't have enough information to reliably display this information without scaring users, so don't do anything.\n  if (flags.every(flag => flag.unconfiguredBehavesLike === undefined)) {\n    return;\n  }\n\n  const unconfiguredFlags = FlagOperations.filterNeedsAttention(flags);\n  const numUnconfigured = unconfiguredFlags.length;\n\n  if (numUnconfigured > 0) {\n    await ioHost.defaults.warn(`${numUnconfigured} feature flags are not configured. Run 'cdk flags --unstable=flags' to learn more.`);\n  }\n}\n\ninterface WorkGraphDeploymentActionsOptions {\n  readonly roleArn?: string;\n  readonly force?: boolean;\n  readonly stackCount?: number;\n  readonly notificationArns?: string[];\n  readonly deploymentMethod?: DeploymentMethod;\n  readonly toolkitStackName?: string;\n  readonly reuseAssets?: string[];\n  readonly tags?: Tag[];\n  readonly parameters?: { [name: string]: string | undefined };\n  readonly usePreviousParameters?: boolean;\n  readonly rollback?: boolean;\n  readonly extraUserAgent?: string;\n  readonly assetParallelism?: boolean;\n  readonly requireApproval: RequireApproval;\n  readonly concurrency: number;\n  readonly cloudWatchLogMonitor?: CloudWatchLogEventMonitor;\n  readonly sdkProvider: SdkProvider;\n  readonly express?: boolean;\n}\n\n/**\n * This class implements the callbacks for the parallel work graph executions.\n *\n * All this code used to be inlined into CdkToolkit#deploy(), but it was getting\n * too much to live in there.\n */\nclass WorkGraphDeploymentActions implements WorkGraphActions {\n  private readonly stackOutputs: { [key: string]: any } = {};\n  private readonly assetSpans: Record<string, IMessageSpan<EventResult>> = {};\n  private stackCounter = 1;\n\n  constructor(\n    private readonly deployments: Deployments,\n    private readonly ioHost: CliIoHost,\n    private readonly stackOperations: Pick<CdkToolkit, 'destroy' | 'rollback'>,\n    private readonly options: WorkGraphDeploymentActionsOptions,\n  ) {\n  }\n\n  public async marker(markerNode: MarkerNode) {\n    // For assets, emit IoHost messages that have been defined to start and end asset spans, which will lead to events in telemetry.\n    switch (markerNode.marker.type) {\n      case 'start-asset': {\n        const assetSpan = await this.obtainSpan(markerNode.marker.asset);\n\n        // Count the asset type, both on the asset-specific span and on the global COMMAND span.\n        if (markerNode.marker.asset.type === 'file') {\n          this.ioHost.telemetry?.commandSpan?.incCounter('fileAsset');\n          assetSpan.incCounter('fileAsset');\n        } else if (markerNode.marker.asset.type === 'docker') {\n          this.ioHost.telemetry?.commandSpan?.incCounter('dockerAsset');\n          assetSpan.incCounter('dockerAsset');\n        }\n\n        break;\n      }\n      case 'end-asset': {\n        const assetSpan = await this.obtainSpan(markerNode.marker.asset);\n        await assetSpan.end({});\n        break;\n      }\n    }\n  }\n\n  private async obtainSpan(assetEntry: IManifestEntry): Promise<IMessageSpan<EventResult>> {\n    const span = this.assetSpans[assetEntry.id.assetId];\n    if (span) {\n      return span;\n    }\n    const assetSpan = await this.ioHost.asIoHelper().span(CLI_PRIVATE_SPAN.ASSET).begin({});\n    this.assetSpans[assetEntry.id.assetId] = assetSpan;\n    return assetSpan;\n  }\n\n  public async buildAsset(assetNode: AssetBuildNode) {\n    // Measure asset build time. Both on the global COMMAND span as well as on the asset-specific span.\n    // (parallelism may cause SUM(buildAssetST) >= totalDeployTime) on the COMMAND span, indicate with [S]ub[T]ask suffix).\n    using _invokeTimer = this.ioHost.telemetry?.commandSpan?.startTimer('buildAssetST');\n    using _assetTimer = (await this.obtainSpan(assetNode.asset)).startTimer('buildAsset');\n\n    await this.deployments.buildSingleAsset(\n      assetNode.assetManifestArtifact,\n      assetNode.assetManifest,\n      assetNode.asset,\n      {\n        stack: assetNode.parentStack,\n        roleArn: this.options.roleArn,\n        stackName: assetNode.parentStack.stackName,\n      },\n    );\n  }\n\n  public async publishAsset(assetNode: AssetPublishNode) {\n    // Measure asset publish time. Both on the global COMMAND span as well as on the asset-specific span.\n    // (parallelism may cause SUM(publishAssetST) >= totalDeployTime) on the COMMAND span, indicate with [S]ub[T]ask suffix).\n    using _invokeTimer = this.ioHost.telemetry?.commandSpan?.startTimer('publishAssetST');\n    using _assetTimer = (await this.obtainSpan(assetNode.asset)).startTimer('publishAsset');\n\n    await this.deployments.publishSingleAsset(assetNode.assetManifest, assetNode.asset, {\n      stack: assetNode.parentStack,\n      roleArn: this.options.roleArn,\n      stackName: assetNode.parentStack.stackName,\n      forcePublish: this.options.force,\n    });\n  }\n\n  public async deployStack(stackNode: StackNode) {\n    // Counter for totalDeployedStacks, to match 'totalDeployTime' timer on the COMMAND span.\n    this.ioHost.telemetry?.commandSpan?.incCounter('totalDeployedStacks');\n\n    const stack = stackNode.stack;\n    if (this.options.stackCount !== 1) {\n      await this.ioHost.asIoHelper().defaults.info(chalk.bold(stack.displayName));\n    }\n\n    if (!stack.environment) {\n      // eslint-disable-next-line @stylistic/max-len\n      throw new ToolkitError(\n        'MissingEnvironment',\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    const resourceCount = Object.keys(stack.template.Resources || {}).length;\n    if (resourceCount === 0) {\n      // The generated stack has no resources\n      if (!(await this.deployments.stackExists({ stack }))) {\n        await this.ioHost.asIoHelper().defaults.warn('%s: stack has no resources, skipping deployment.', chalk.bold(stack.displayName));\n      } else {\n        await this.ioHost.asIoHelper().defaults.warn('%s: stack has no resources, deleting existing stack.', chalk.bold(stack.displayName));\n        await this.stackOperations.destroy({\n          selector: selectExact(stack.hierarchicalId),\n          force: true,\n          roleArn: this.options.roleArn,\n          fromDeploy: true,\n        });\n      }\n      return;\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 = (!!this.options.notificationArns || !!stack.notificationArns)\n      ? (this.options.notificationArns ?? []).concat(stack.notificationArns ?? [])\n      : undefined;\n\n    for (const notificationArn of notificationArns ?? []) {\n      if (!validateSnsTopicArn(notificationArn)) {\n        throw new ToolkitError('InvalidSnsTopicArn', `Notification arn ${notificationArn} is not a valid arn for an SNS topic`);\n      }\n    }\n\n    const parameterMap = buildParameterMap(this.options.parameters);\n\n    // Deploy options that are shared between change set creation and execution\n    const sharedDeployOptions = {\n      stack,\n      deployName: stack.stackName,\n      roleArn: this.options.roleArn,\n      toolkitStackName: this.options.toolkitStackName,\n      reuseAssets: this.options.reuseAssets,\n      tags: (this.options.tags?.length ? this.options.tags : tagsForStack(stack)),\n      forceDeployment: this.options.force,\n      parameters: Object.assign({}, parameterMap['*'], parameterMap[stack.stackName]),\n      usePreviousParameters: this.options.usePreviousParameters,\n      rollback: this.options.rollback,\n      notificationArns,\n      extraUserAgent: this.options.extraUserAgent,\n      assetParallelism: this.options.assetParallelism,\n      express: this.options.express,\n    };\n\n    // When using change-set method, always create the change set upfront.\n    // This gives us an accurate diff for approval and avoids creating it twice.\n    // For non-executing deployments (prepare-change-set), this is the final result.\n    const prepareResult = isChangeSetDeployment(this.options.deploymentMethod)\n      ? await this.deployments.prepareStack({\n        ...sharedDeployOptions,\n        deploymentMethod: this.options.deploymentMethod,\n        willExecuteChangeSet: isExecutingChangeSetDeployment(this.options.deploymentMethod),\n      })\n      : undefined;\n\n    // Also skip the approval flow when the prepared change set is a no-op —\n    // there is nothing for the user to approve. Outputs, stack ARN, and\n    // timings are still emitted via the normal no-op deploy path below.\n    if (this.options.requireApproval !== RequireApproval.NEVER && !prepareResult?.noOp) {\n      const isDestructiveApproval = this.options.requireApproval === RequireApproval.DESTRUCTIVE;\n      // Destructive changes can be in nested stacks too, so read their templates when they decide the approval\n      const { deployedRootTemplate, nestedStacks } = isDestructiveApproval\n        ? await this.deployments.readCurrentTemplateWithNestedStacks(stack)\n        : { deployedRootTemplate: await this.deployments.readCurrentTemplate(stack), nestedStacks: undefined };\n      const formatter = new DiffFormatter({\n        templateInfo: {\n          oldTemplate: deployedRootTemplate,\n          newTemplate: stack,\n          changeSet: prepareResult?.changeSet,\n          nestedStacks,\n        },\n      });\n      const securityDiff = formatter.formatSecurityDiff();\n      // Formatting the stack diff leaves out changes that are likely mangled non-ASCII characters,\n      // so do that before looking for destructive changes when they decide the approval\n      const stackDiff = isDestructiveApproval ? formatter.formatStackDiff() : undefined;\n      const destructiveChanges = findDestructiveChanges(formatter.displayedDiffs, formatter.constructPaths);\n      if (requiresApproval(this.options.requireApproval, securityDiff.permissionChangeType, destructiveChanges.length > 0)) {\n        const hasSecurityChanges = securityDiff.permissionChangeType !== PermissionChangeType.NONE;\n        // Bare-fact motivation. The I5060 listener registered in `deploy()` adds\n        // the `--require-approval` framing for terminal users.\n        const motivation = isDestructiveApproval\n          ? 'Stack includes destructive updates'\n          : hasSecurityChanges\n            ? 'Stack includes security-sensitive updates'\n            : 'Stack includes updates';\n        const diffOutput = hasSecurityChanges && !isDestructiveApproval\n          ? securityDiff.formattedDiff\n          : (stackDiff ?? formatter.formatStackDiff()).formattedDiff;\n        await this.ioHost.asIoHelper().defaults.info(diffOutput);\n        if (isDestructiveApproval) {\n          const lines = destructiveChanges.map(c => `  ${formatDestructiveChange(c)}`);\n          await this.ioHost.asIoHelper().defaults.warn(`Destructive changes:\\n${lines.join('\\n')}\\n`);\n        }\n\n        try {\n          await askUserConfirmation(\n            this.ioHost,\n            IO.CDK_TOOLKIT_I5060.req(`${motivation}. Do you wish to deploy these changes?`, {\n              motivation,\n              concurrency: this.options.concurrency,\n              permissionChangeType: securityDiff.permissionChangeType,\n              templateDiffs: formatter.diffs,\n              destructiveChanges,\n            }),\n            'DeployAborted',\n            'Deployment cancelled',\n          );\n        } catch (e) {\n          if (prepareResult?.changeSet?.ChangeSetName) {\n            await this.deployments.cleanupChangeSet(stack, prepareResult.changeSet.ChangeSetName);\n          }\n          throw e;\n        }\n      }\n    }\n\n    const stackIndex = this.stackCounter++;\n    await this.ioHost.asIoHelper().defaults.info(`${chalk.bold(stack.displayName)}: deploying... [${stackIndex}/${this.options.stackCount}]`);\n    const startDeployTime = new Date().getTime();\n\n    // There is already a startDeployTime constant, but that does not work with telemetry.\n    // We should integrate the two in the future\n    const deploySpan = await this.ioHost.asIoHelper().span(CLI_PRIVATE_SPAN.DEPLOY).begin({});\n    deploySpan.incCounter('resources', resourceCount);\n    this.ioHost.telemetry?.commandSpan?.incCounter('totalDeployedResources', resourceCount);\n    let error: ErrorDetails | undefined;\n    let elapsedDeployTime = 0;\n    try {\n      // The prepare result is final if the change set was empty (noOp) or\n      // the deployment method is non-executing (prepare-change-set).\n      const prepareIsFinal = prepareResult && (prepareResult.noOp || isNonExecutingChangeSetDeployment(this.options.deploymentMethod));\n      let deployResult: SuccessfulDeployStackResult | undefined = prepareIsFinal ? prepareResult : undefined;\n\n      // Start with user config for rollback,\n      // but it might change if we encounter a failed state.\n      let rollback = this.options.rollback;\n\n      // We limit the loop to 2 iterations max as defensive programming.\n      // Should not be possible to happen.\n      let iteration = 0;\n      while (!deployResult) {\n        if (++iteration > 2) {\n          throw new ToolkitError('DeployLoopUnstable', '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.deployments.deployStack({\n          ...sharedDeployOptions,\n          // On the first iteration, execute the prepared change set.\n          // On retries (after rollback), create a new change set since the old one is gone.\n          deploymentMethod: iteration === 1 && isExecutingChangeSetDeployment(this.options.deploymentMethod)\n            ? toExecuteChangeSetDeployment(this.options.deploymentMethod)\n            : this.options.deploymentMethod,\n          rollback,\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 (this.options.force) {\n              await this.ioHost.asIoHelper().defaults.warn(`${motivation}. Rolling back first (--force).`);\n            } else {\n              await askUserConfirmation(\n                this.ioHost,\n                IO.CDK_TOOLKIT_I5050.req(`${motivation}. Roll back first and then proceed with deployment`, {\n                  motivation,\n                  concurrency: this.options.concurrency,\n                }),\n                'RollbackAborted',\n                'Rollback cancelled',\n              );\n            }\n\n            // Perform a rollback\n            await this.stackOperations.rollback({\n              selector: selectExact(stack.hierarchicalId),\n              toolkitStackName: this.options.toolkitStackName,\n              force: this.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 (this.options.force) {\n              await this.ioHost.asIoHelper().defaults.warn(`${motivation}. Proceeding with deployment with rollback enabled (--force).`);\n            } else {\n              await askUserConfirmation(\n                this.ioHost,\n                IO.CDK_TOOLKIT_I5050.req(`${motivation}. Perform a deployment with rollback enabled`, {\n                  concurrency: this.options.concurrency,\n                  motivation,\n                }),\n                'ReplacementRollbackAborted',\n                'Rollback cancelled',\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('UnexpectedDeployResult', `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      await this.ioHost.asIoHelper().defaults.info(chalk.green('\\n' + message), stack.displayName);\n      elapsedDeployTime = new Date().getTime() - startDeployTime;\n      await this.ioHost.asIoHelper().defaults.info(`\\n✨  Deployment time: ${formatTime(elapsedDeployTime)}s\\n`);\n\n      if (this.options.express) {\n        const warning = formatExpressStabilizationWarning(deployResult.stabilizingResources, 'deploy');\n        if (warning) {\n          await this.ioHost.asIoHelper().notify(IO.CDK_TOOLKIT_W5902.msg(warning));\n        }\n      }\n\n      if (Object.keys(deployResult.outputs).length > 0) {\n        await this.ioHost.asIoHelper().defaults.info('Outputs:');\n\n        this.stackOutputs[stack.stackName] = deployResult.outputs;\n      }\n\n      for (const name of Object.keys(deployResult.outputs).sort()) {\n        const value = deployResult.outputs[name];\n        await this.ioHost.asIoHelper().defaults.info(`${chalk.cyan(stack.id)}.${chalk.cyan(name)} = ${chalk.underline(chalk.cyan(value))}`);\n      }\n\n      await this.ioHost.asIoHelper().defaults.info('Stack ARN:');\n\n      await this.ioHost.asIoHelper().defaults.result(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      const code = ToolkitError.isToolkitError(e) ? e.name : 'DeployStackFailed'; // Formerly 'DeployFailed'\n      const newMessage = `❌  ${chalk.bold(stack.stackName)} failed to deploy`;\n      const wrappedError = ToolkitError.withCause(code, newMessage, e);\n\n      error = {\n        name: cdkCliErrorName(wrappedError),\n      };\n\n      throw wrappedError;\n    } finally {\n      await deploySpan.end({ error });\n\n      if (this.options.cloudWatchLogMonitor) {\n        const foundLogGroupsResult = await findCloudWatchLogGroups(this.options.sdkProvider, asIoHelper(this.ioHost, 'deploy'), stack);\n        this.options.cloudWatchLogMonitor.addLogGroups(\n          foundLogGroupsResult.env,\n          foundLogGroupsResult.sdk,\n          foundLogGroupsResult.logGroupNames,\n        );\n      }\n    }\n  }\n\n  public async writeOutputs(outputsFile: string) {\n    fs.ensureFileSync(outputsFile);\n    await fs.writeJson(outputsFile, this.stackOutputs, {\n      spaces: 2,\n      encoding: 'utf8',\n    });\n  }\n}\n\n/**\n * Whether a diff with the given changes fails, according to `--fail-on`\n */\nfunction diffFails(failOn: RequireApproval, numStacksWithChanges: number, hasBroadeningChanges: boolean, hasDestructiveChanges: boolean): boolean {\n  switch (failOn) {\n    case RequireApproval.ANYCHANGE:\n      return numStacksWithChanges > 0;\n    case RequireApproval.BROADENING:\n      return hasBroadeningChanges;\n    case RequireApproval.DESTRUCTIVE:\n      return hasDestructiveChanges;\n    case RequireApproval.NEVER:\n      return false;\n  }\n}\n\n/**\n * Determine if manual approval is required or not. Requires approval for\n * - RequireApproval.ANYCHANGE\n * - RequireApproval.BROADENING and the changes are indeed broadening permissions\n * - RequireApproval.DESTRUCTIVE and the changes replace, delete or orphan an existing resource\n */\nfunction requiresApproval(requireApproval: RequireApproval, permissionChangeType: PermissionChangeType, hasDestructiveChanges: boolean) {\n  return requireApproval === RequireApproval.ANYCHANGE ||\n    requireApproval === RequireApproval.BROADENING && permissionChangeType === PermissionChangeType.BROADENING ||\n    requireApproval === RequireApproval.DESTRUCTIVE && hasDestructiveChanges;\n}\n\n"]}