aws-cdk 2.1021.0 → 2.1023.0

package/lib/cli/util/yargs-helpers.d.ts

@@ -1,4 +1,4 @@
-export { isCI } from '../io-host';
+export { isCI } from '../util/ci';
 /**
  * yargs middleware to negate an option if a negative alias is provided
  * E.g. `-R` will imply `--rollback=false`

package/lib/cli/util/yargs-helpers.js

@@ -6,10 +6,10 @@ exports.cliVersion = cliVersion;
 exports.browserForPlatform = browserForPlatform;
 exports.shouldDisplayNotices = shouldDisplayNotices;
 const ci_systems_1 = require("../ci-systems");
-const io_host_1 = require("../io-host");
+const ci_1 = require("../util/ci");
 const version_1 = require("../version");
-var io_host_2 = require("../io-host");
-Object.defineProperty(exports, "isCI", { enumerable: true, get: function () { return io_host_2.isCI; } });
+var ci_2 = require("../util/ci");
+Object.defineProperty(exports, "isCI", { enumerable: true, get: function () { return ci_2.isCI; } });
 /**
  * yargs middleware to negate an option if a negative alias is provided
  * E.g. `-R` will imply `--rollback=false`
@@ -59,6 +59,6 @@ function browserForPlatform() {
  * systems, even though technically we maybe could.
  */
 function shouldDisplayNotices() {
-    return !(0, io_host_1.isCI)() || Boolean((0, ci_systems_1.ciSystemIsStdErrSafe)());
+    return !(0, ci_1.isCI)() || Boolean((0, ci_systems_1.ciSystemIsStdErrSafe)());
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieWFyZ3MtaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInlhcmdzLWhlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBY0EsZ0RBWUM7QUFNRCxnQ0FFQztBQU1ELGdEQVNDO0FBV0Qsb0RBRUM7QUE5REQsOENBQXFEO0FBQ3JELG1DQUFrQztBQUNsQyx3Q0FBOEM7QUFFOUMsaUNBQWtDO0FBQXpCLDBGQUFBLElBQUksT0FBQTtBQUViOzs7Ozs7O0dBT0c7QUFDSCxTQUFnQixrQkFBa0IsQ0FDaEMsYUFBZ0IsRUFDaEIsY0FBaUI7SUFFakIsT0FBTyxDQUFDLElBQU8sRUFBRSxFQUFFO1FBQ2pCLDBCQUEwQjtRQUMxQiw4QkFBOEI7UUFDOUIsSUFBSSxhQUFhLElBQUksSUFBSSxJQUFJLElBQUksQ0FBQyxhQUFhLENBQUMsRUFBRSxDQUFDO1lBQ2hELElBQVksQ0FBQyxjQUFjLENBQUMsR0FBRyxLQUFLLENBQUM7UUFDeEMsQ0FBQztRQUNELE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQyxDQUFDO0FBQ0osQ0FBQztBQUVEOzs7R0FHRztBQUNILFNBQWdCLFVBQVU7SUFDeEIsT0FBTyxJQUFBLDBCQUFnQixHQUFFLENBQUM7QUFDNUIsQ0FBQztBQUVEOzs7R0FHRztBQUNILFNBQWdCLGtCQUFrQjtJQUNoQyxRQUFRLE9BQU8sQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUN6QixLQUFLLFFBQVE7WUFDWCxPQUFPLFNBQVMsQ0FBQztRQUNuQixLQUFLLE9BQU87WUFDVixPQUFPLFVBQVUsQ0FBQztRQUNwQjtZQUNFLE9BQU8sYUFBYSxDQUFDO0lBQ3pCLENBQUM7QUFDSCxDQUFDO0FBRUQ7Ozs7Ozs7O0dBUUc7QUFDSCxTQUFnQixvQkFBb0I7SUFDbEMsT0FBTyxDQUFDLElBQUEsU0FBSSxHQUFFLElBQUksT0FBTyxDQUFDLElBQUEsaUNBQW9CLEdBQUUsQ0FBQyxDQUFDO0FBQ3BELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjaVN5c3RlbUlzU3RkRXJyU2FmZSB9IGZyb20gJy4uL2NpLXN5c3RlbXMnO1xuaW1wb3J0IHsgaXNDSSB9IGZyb20gJy4uL3V0aWwvY2knO1xuaW1wb3J0IHsgdmVyc2lvbldpdGhCdWlsZCB9IGZyb20gJy4uL3ZlcnNpb24nO1xuXG5leHBvcnQgeyBpc0NJIH0gZnJvbSAnLi4vdXRpbC9jaSc7XG5cbi8qKlxuICogeWFyZ3MgbWlkZGxld2FyZSB0byBuZWdhdGUgYW4gb3B0aW9uIGlmIGEgbmVnYXRpdmUgYWxpYXMgaXMgcHJvdmlkZWRcbiAqIEUuZy4gYC1SYCB3aWxsIGltcGx5IGAtLXJvbGxiYWNrPWZhbHNlYFxuICpcbiAqIEBwYXJhbSBvcHRpb25Ub05lZ2F0ZSAtIFRoZSBuYW1lIG9mIHRoZSBvcHRpb24gdG8gbmVnYXRlLCBlLmcuIGByb2xsYmFja2BcbiAqIEBwYXJhbSBuZWdhdGl2ZUFsaWFzIC0gVGhlIGFsaWFzIHRoYXQgc2hvdWxkIG5lZ2F0ZSB0aGUgb3B0aW9uLCBlLmcuIGBSYFxuICogQHJldHVybnMgYSBtaWRkbGV3YXJlIGZ1bmN0aW9uIHRoYXQgY2FuIGJlIHBhc3NlZCB0byB5YXJnc1xuICovXG5leHBvcnQgZnVuY3Rpb24geWFyZ3NOZWdhdGl2ZUFsaWFzPFQgZXh0ZW5kcyB7IFt4IGluIFMgfCBMXTogYm9vbGVhbiB8IHVuZGVmaW5lZCB9LCBTIGV4dGVuZHMgc3RyaW5nLCBMIGV4dGVuZHMgc3RyaW5nPihcbiAgbmVnYXRpdmVBbGlhczogUyxcbiAgb3B0aW9uVG9OZWdhdGU6IEwsXG4pOiAoYXJndjogVCkgPT4gVCB7XG4gIHJldHVybiAoYXJndjogVCkgPT4ge1xuICAgIC8vIGlmIFIgaW4gYXJndiAmJiBhcmd2W1JdXG4gICAgLy8gdGhlbiBhcmd2W3JvbGxiYWNrXSA9IGZhbHNlXG4gICAgaWYgKG5lZ2F0aXZlQWxpYXMgaW4gYXJndiAmJiBhcmd2W25lZ2F0aXZlQWxpYXNdKSB7XG4gICAgICAoYXJndiBhcyBhbnkpW29wdGlvblRvTmVnYXRlXSA9IGZhbHNlO1xuICAgIH1cbiAgICByZXR1cm4gYXJndjtcbiAgfTtcbn1cblxuLyoqXG4gKiBSZXR1cm5zIHRoZSBjdXJyZW50IHZlcnNpb24gb2YgdGhlIENMSVxuICogQHJldHVybnMgdGhlIGN1cnJlbnQgdmVyc2lvbiBvZiB0aGUgQ0xJXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjbGlWZXJzaW9uKCk6IHN0cmluZyB7XG4gIHJldHVybiB2ZXJzaW9uV2l0aEJ1aWxkKCk7XG59XG5cbi8qKlxuICogUmV0dXJucyB0aGUgZGVmYXVsdCBicm93c2VyIGNvbW1hbmQgZm9yIHRoZSBjdXJyZW50IHBsYXRmb3JtXG4gKiBAcmV0dXJucyB0aGUgZGVmYXVsdCBicm93c2VyIGNvbW1hbmQgZm9yIHRoZSBjdXJyZW50IHBsYXRmb3JtXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBicm93c2VyRm9yUGxhdGZvcm0oKTogc3RyaW5nIHtcbiAgc3dpdGNoIChwcm9jZXNzLnBsYXRmb3JtKSB7XG4gICAgY2FzZSAnZGFyd2luJzpcbiAgICAgIHJldHVybiAnb3BlbiAldSc7XG4gICAgY2FzZSAnd2luMzInOlxuICAgICAgcmV0dXJuICdzdGFydCAldSc7XG4gICAgZGVmYXVsdDpcbiAgICAgIHJldHVybiAneGRnLW9wZW4gJXUnO1xuICB9XG59XG5cbi8qKlxuICogVGhlIGRlZmF1bHQgdmFsdWUgZm9yIGRpc3BsYXlpbmcgKGFuZCByZWZyZXNoaW5nKSBub3RpY2VzIG9uIGFsbCBjb21tYW5kcy5cbiAqXG4gKiBJZiB0aGUgdXNlciBkaWRuJ3Qgc3VwcGx5IGVpdGhlciBgLS1ub3RpY2VzYCBvciBgLS1uby1ub3RpY2VzYCwgd2UgZG9cbiAqIGF1dG9kZXRlY3Rpb24uIFRoZSBhdXRvZGV0ZWN0aW9uIGN1cnJlbnRseSBpczogZG8gd3JpdGUgbm90aWNlcyBpZiB3ZSBhcmVcbiAqIG5vdCBvbiBDSSwgb3IgYXJlIG9uIGEgQ0kgc3lzdGVtIHdoZXJlIHdlIGtub3cgdGhhdCB3cml0aW5nIHRvIHN0ZGVyciBpc1xuICogc2FmZS4gV2UgZmFpbCBcImNsb3NlZFwiOyB0aGF0IGlzLCB3ZSBkZWNpZGUgdG8gTk9UIHByaW50IGZvciB1bmtub3duIENJXG4gKiBzeXN0ZW1zLCBldmVuIHRob3VnaCB0ZWNobmljYWxseSB3ZSBtYXliZSBjb3VsZC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNob3VsZERpc3BsYXlOb3RpY2VzKCk6IGJvb2xlYW4ge1xuICByZXR1cm4gIWlzQ0koKSB8fCBCb29sZWFuKGNpU3lzdGVtSXNTdGRFcnJTYWZlKCkpO1xufVxuIl19

package/lib/cli/version.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.versionWithBuild = versionWithBuild;
 exports.isDeveloperBuildVersion = isDeveloperBuildVersion;
 exports.versionNumber = versionNumber;
-/* c8 ignore start */
 const path = require("path");
 const root_dir_1 = require("./root-dir");
 function versionWithBuild() {
@@ -20,4 +19,4 @@ function commit() {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     return require(path.join((0, root_dir_1.cliRootDir)(), 'build-info.json')).commit;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFJQSw0Q0FFQztBQUVELDBEQUVDO0FBRUQsc0NBR0M7QUFmRCxxQkFBcUI7QUFDckIsNkJBQTZCO0FBQzdCLHlDQUF3QztBQUV4QyxTQUFnQixnQkFBZ0I7SUFDOUIsT0FBTyxHQUFHLGFBQWEsRUFBRSxXQUFXLE1BQU0sRUFBRSxHQUFHLENBQUM7QUFDbEQsQ0FBQztBQUVELFNBQWdCLHVCQUF1QjtJQUNyQyxPQUFPLGFBQWEsRUFBRSxLQUFLLE9BQU8sQ0FBQztBQUNyQyxDQUFDO0FBRUQsU0FBZ0IsYUFBYTtJQUMzQixpRUFBaUU7SUFDakUsT0FBTyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFBLHFCQUFVLEdBQUUsRUFBRSxjQUFjLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsY0FBYyxFQUFFLEVBQUUsQ0FBQyxDQUFDO0FBQzlGLENBQUM7QUFFRCxTQUFTLE1BQU07SUFDYixpRUFBaUU7SUFDakUsT0FBTyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFBLHFCQUFVLEdBQUUsRUFBRSxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDO0FBQ3BFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBjOCBpZ25vcmUgc3RhcnQgKi9cbmltcG9ydCAqIGFzIHBhdGggZnJvbSAncGF0aCc7XG5pbXBvcnQgeyBjbGlSb290RGlyIH0gZnJvbSAnLi9yb290LWRpcic7XG5cbmV4cG9ydCBmdW5jdGlvbiB2ZXJzaW9uV2l0aEJ1aWxkKCkge1xuICByZXR1cm4gYCR7dmVyc2lvbk51bWJlcigpfSAoYnVpbGQgJHtjb21taXQoKX0pYDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGlzRGV2ZWxvcGVyQnVpbGRWZXJzaW9uKCk6IGJvb2xlYW4ge1xuICByZXR1cm4gdmVyc2lvbk51bWJlcigpID09PSAnMC4wLjAnO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gdmVyc2lvbk51bWJlcigpOiBzdHJpbmcge1xuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXJlcXVpcmUtaW1wb3J0c1xuICByZXR1cm4gcmVxdWlyZShwYXRoLmpvaW4oY2xpUm9vdERpcigpLCAncGFja2FnZS5qc29uJykpLnZlcnNpb24ucmVwbGFjZSgvXFwrWzAtOWEtZl0rJC8sICcnKTtcbn1cblxuZnVuY3Rpb24gY29tbWl0KCk6IHN0cmluZyB7XG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tcmVxdWlyZS1pbXBvcnRzXG4gIHJldHVybiByZXF1aXJlKHBhdGguam9pbihjbGlSb290RGlyKCksICdidWlsZC1pbmZvLmpzb24nKSkuY29tbWl0O1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFHQSw0Q0FFQztBQUVELDBEQUVDO0FBRUQsc0NBR0M7QUFkRCw2QkFBNkI7QUFDN0IseUNBQXdDO0FBRXhDLFNBQWdCLGdCQUFnQjtJQUM5QixPQUFPLEdBQUcsYUFBYSxFQUFFLFdBQVcsTUFBTSxFQUFFLEdBQUcsQ0FBQztBQUNsRCxDQUFDO0FBRUQsU0FBZ0IsdUJBQXVCO0lBQ3JDLE9BQU8sYUFBYSxFQUFFLEtBQUssT0FBTyxDQUFDO0FBQ3JDLENBQUM7QUFFRCxTQUFnQixhQUFhO0lBQzNCLGlFQUFpRTtJQUNqRSxPQUFPLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUEscUJBQVUsR0FBRSxFQUFFLGNBQWMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxjQUFjLEVBQUUsRUFBRSxDQUFDLENBQUM7QUFDOUYsQ0FBQztBQUVELFNBQVMsTUFBTTtJQUNiLGlFQUFpRTtJQUNqRSxPQUFPLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUEscUJBQVUsR0FBRSxFQUFFLGlCQUFpQixDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUM7QUFDcEUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIHBhdGggZnJvbSAncGF0aCc7XG5pbXBvcnQgeyBjbGlSb290RGlyIH0gZnJvbSAnLi9yb290LWRpcic7XG5cbmV4cG9ydCBmdW5jdGlvbiB2ZXJzaW9uV2l0aEJ1aWxkKCkge1xuICByZXR1cm4gYCR7dmVyc2lvbk51bWJlcigpfSAoYnVpbGQgJHtjb21taXQoKX0pYDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGlzRGV2ZWxvcGVyQnVpbGRWZXJzaW9uKCk6IGJvb2xlYW4ge1xuICByZXR1cm4gdmVyc2lvbk51bWJlcigpID09PSAnMC4wLjAnO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gdmVyc2lvbk51bWJlcigpOiBzdHJpbmcge1xuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXJlcXVpcmUtaW1wb3J0c1xuICByZXR1cm4gcmVxdWlyZShwYXRoLmpvaW4oY2xpUm9vdERpcigpLCAncGFja2FnZS5qc29uJykpLnZlcnNpb24ucmVwbGFjZSgvXFwrWzAtOWEtZl0rJC8sICcnKTtcbn1cblxuZnVuY3Rpb24gY29tbWl0KCk6IHN0cmluZyB7XG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tcmVxdWlyZS1pbXBvcnRzXG4gIHJldHVybiByZXF1aXJlKHBhdGguam9pbihjbGlSb290RGlyKCksICdidWlsZC1pbmZvLmpzb24nKSkuY29tbWl0O1xufVxuIl19

package/lib/commands/flag-operations.d.ts

@@ -0,0 +1,5 @@
+import type { FeatureFlag, Toolkit } from '@aws-cdk/toolkit-lib';
+import type { IoHelper } from '../api-private';
+import type { FlagsOptions } from '../cli/user-input';
+export declare function handleFlags(flagData: FeatureFlag[], ioHelper: IoHelper, options: FlagsOptions, toolkit: Toolkit): Promise<void>;
+export declare function displayFlags(flagsData: FeatureFlag[], ioHelper: IoHelper, flagName?: string, all?: boolean): Promise<void>;

package/lib/commands/flag-operations.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleFlags = handleFlags;
+exports.displayFlags = displayFlags;
+const path = require("path");
+const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
+const chalk = require("chalk");
+const fs = require("fs-extra");
+const api_1 = require("../api");
+async function handleFlags(flagData, ioHelper, options, toolkit) {
+    if (options.FLAGNAME && options.all) {
+        await ioHelper.defaults.error('Error: Cannot use both --all and a specific flag name. Please use either --all to show all flags or specify a single flag name.');
+        return;
+    }
+    if (options.set && options.all) {
+        await ioHelper.defaults.error('Error: --set is currently only compatible with a flag name. Please specify which flag you want to set.');
+        return;
+    }
+    if (options.set && !options.FLAGNAME) {
+        await ioHelper.defaults.error('Error: --set requires a flag name. Please specify which flag you want to set.');
+        return;
+    }
+    if (options.set && !options.value) {
+        await ioHelper.defaults.error('Error: --set requires a value. Please specify the value you want to set for the flag.');
+        return;
+    }
+    if (options.FLAGNAME && !options.set && !options.value) {
+        await displayFlags(flagData, ioHelper, String(options.FLAGNAME));
+        return;
+    }
+    if (options.all && !options.set) {
+        await displayFlags(flagData, ioHelper, undefined, true);
+        return;
+    }
+    if (options.set && options.FLAGNAME || options.value && options.FLAGNAME) {
+        await prototypeChanges(flagData, ioHelper, String(options.FLAGNAME), options.value, toolkit);
+        return;
+    }
+    if (!options.FLAGNAME && !options.all && !options.set) {
+        await displayFlags(flagData, ioHelper, undefined, false);
+    }
+}
+async function displayFlags(flagsData, ioHelper, flagName, all) {
+    if (flagName && flagName.length > 0) {
+        const flag = flagsData.find(f => f.name === flagName);
+        if (!flag) {
+            await ioHelper.defaults.error('Flag not found.');
+            return;
+        }
+        await ioHelper.defaults.info(`Description: ${flag.explanation}`);
+        await ioHelper.defaults.info(`Recommended value: ${flag.recommendedValue}`);
+        await ioHelper.defaults.info(`User value: ${flag.userValue}`);
+        return;
+    }
+    const headers = ['Feature Flag Name', 'Recommended Value', 'User Value'];
+    const rows = [];
+    const getFlagPriority = (flag) => {
+        if (flag.userValue === undefined) {
+            return 3;
+        }
+        else if (String(flag.userValue) === String(flag.recommendedValue)) {
+            return 1;
+        }
+        else {
+            return 2;
+        }
+    };
+    let flagsToDisplay;
+    if (all) {
+        flagsToDisplay = flagsData;
+    }
+    else {
+        flagsToDisplay = flagsData.filter(flag => flag.userValue === undefined || String(flag.userValue) !== String(flag.recommendedValue));
+    }
+    const sortedFlags = [...flagsToDisplay].sort((a, b) => {
+        const priorityA = getFlagPriority(a);
+        const priorityB = getFlagPriority(b);
+        if (priorityA !== priorityB) {
+            return priorityA - priorityB;
+        }
+        if (a.module !== b.module) {
+            return a.module.localeCompare(b.module);
+        }
+        return a.name.localeCompare(b.name);
+    });
+    let currentModule = '';
+    sortedFlags.forEach((flag) => {
+        if (flag.module !== currentModule) {
+            rows.push([chalk.bold(`Module: ${flag.module}`), '', '']);
+            currentModule = flag.module;
+        }
+        rows.push([
+            flag.name,
+            String(flag.recommendedValue),
+            flag.userValue === undefined ? '<unset>' : String(flag.userValue),
+        ]);
+    });
+    const formattedTable = formatTable(headers, rows);
+    await ioHelper.defaults.info(formattedTable);
+}
+async function prototypeChanges(flagData, ioHelper, flagName, value, toolkit) {
+    const flag = flagData.find(f => f.name === flagName);
+    if (!flag) {
+        await ioHelper.defaults.error('Flag not found.');
+        return;
+    }
+    if (typeof flag.recommendedValue !== 'boolean' && flag.recommendedValue !== 'true' && flag.recommendedValue !== 'false') {
+        await ioHelper.defaults.error(`Flag '${flagName}' is not a boolean flag. Only boolean flags are currently supported.`);
+        return;
+    }
+    const baseContext = new toolkit_lib_1.CdkAppMultiContext(process.cwd());
+    const baseContextValues = await baseContext.read();
+    const memoryContext = new toolkit_lib_1.MemoryContext(baseContextValues);
+    const boolValue = value.toLowerCase() === 'true';
+    if (baseContextValues[flagName] == boolValue) {
+        await ioHelper.defaults.error('Flag is already set to the specified value. No changes needed.');
+        return;
+    }
+    const cdkJson = await JSON.parse(await fs.readFile(path.join(process.cwd(), 'cdk.json'), 'utf-8'));
+    const app = cdkJson.app;
+    const source = await toolkit.fromCdkApp(app, {
+        contextStore: baseContext,
+        outdir: path.join(process.cwd(), 'original'),
+    });
+    const cx = await toolkit.synth(source);
+    const assembly = cx.cloudAssembly;
+    const updateObj = {};
+    updateObj[flagName] = boolValue;
+    await memoryContext.update(updateObj);
+    const modifiedSource = await toolkit.fromCdkApp(app, {
+        contextStore: memoryContext,
+        outdir: path.join(process.cwd(), 'temp'),
+    });
+    const modifiedCx = await toolkit.synth(modifiedSource);
+    const allStacks = assembly.stacksRecursively;
+    for (const stack of allStacks) {
+        const templatePath = stack.templateFullPath;
+        await toolkit.diff(modifiedCx, {
+            method: toolkit_lib_1.DiffMethod.LocalFile(templatePath),
+            stacks: {
+                strategy: api_1.StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE,
+                patterns: [stack.hierarchicalId],
+            },
+        });
+    }
+    const userAccepted = await promptUser(ioHelper, flagName, flag.userValue, value?.toLowerCase() === 'true');
+    if (userAccepted) {
+        await modifyValues(flagName, value, ioHelper);
+        await ioHelper.defaults.info('Flag value updated successfully.');
+    }
+    else {
+        await ioHelper.defaults.info('Operation cancelled');
+    }
+    const originalDir = path.join(process.cwd(), 'original');
+    const tempDir = path.join(process.cwd(), 'temp');
+    await fs.remove(originalDir);
+    await fs.remove(tempDir);
+}
+async function promptUser(ioHelper, flagName, currentValue, newValue) {
+    return ioHelper.requestResponse({
+        time: new Date(),
+        level: 'info',
+        code: 'CDK_TOOLKIT_I9300',
+        message: 'Do you want to accept these changes?',
+        data: {
+            flagName,
+            currentValue,
+            newValue,
+            responseDescription: 'Enter "y" to apply changes or "n" to cancel',
+        },
+        defaultResponse: false,
+    });
+}
+async function modifyValues(flagName, value, ioHelper) {
+    const cdkJsonPath = path.join(process.cwd(), 'cdk.json');
+    const cdkJsonContent = await fs.readFile(cdkJsonPath, 'utf-8');
+    const cdkJson = JSON.parse(cdkJsonContent);
+    const boolValue = value.toLowerCase() === 'true';
+    cdkJson.context[flagName] = boolValue;
+    await ioHelper.defaults.info(`Setting flag '${flagName}' to: ${boolValue}`);
+    await fs.writeFile(cdkJsonPath, JSON.stringify(cdkJson, null, 2), 'utf-8');
+}
+function formatTable(headers, rows) {
+    const columnWidths = [
+        Math.max(headers[0].length, ...rows.map(row => row[0].length)),
+        Math.max(headers[1].length, ...rows.map(row => row[1].length)),
+        Math.max(headers[2].length, ...rows.map(row => row[2].length)),
+    ];
+    const createSeparator = () => {
+        return '+' + columnWidths.map(width => '-'.repeat(width + 2)).join('+') + '+';
+    };
+    const formatRow = (values) => {
+        return '|' + values.map((value, i) => ` ${value.padEnd(columnWidths[i])} `).join('|') + '|';
+    };
+    const separator = createSeparator();
+    let table = separator + '\n';
+    table += formatRow(headers) + '\n';
+    table += separator + '\n';
+    rows.forEach(row => {
+        if (row[1] === '' && row[2] === '') {
+            table += ` ${row[0].padEnd(columnWidths[0])} \n`;
+        }
+        else {
+            table += formatRow(row) + '\n';
+        }
+    });
+    table += separator;
+    return table;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flag-operations.js","sourceRoot":"","sources":["flag-operations.ts"],"names":[],"mappings":";;AASA,kCAuCC;AAED,oCAgEC;AAlHD,6BAA6B;AAE7B,sDAAqF;AACrF,+BAA+B;AAC/B,+BAA+B;AAC/B,gCAAgD;AAIzC,KAAK,UAAU,WAAW,CAAC,QAAuB,EAAE,QAAkB,EAAE,OAAqB,EAAE,OAAgB;IACpH,IAAI,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;QACpC,MAAM,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,iIAAiI,CAAC,CAAC;QACjK,OAAO;IACT,CAAC;IAED,IAAI,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;QAC/B,MAAM,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,wGAAwG,CAAC,CAAC;QACxI,OAAO;IACT,CAAC;IAED,IAAI,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;QACrC,MAAM,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,+EAA+E,CAAC,CAAC;QAC/G,OAAO;IACT,CAAC;IAED,IAAI,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QAClC,MAAM,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,uFAAuF,CAAC,CAAC;QACvH,OAAO;IACT,CAAC;IAED,IAAI,OAAO,CAAC,QAAQ,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QACvD,MAAM,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;QACjE,OAAO;IACT,CAAC;IAED,IAAI,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC;QAChC,MAAM,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;QACxD,OAAO;IACT,CAAC;IAED,IAAI,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;QACzE,MAAM,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAC7F,OAAO;IACT,CAAC;IAED,IAAI,CAAC,OAAO,CAAC,QAAQ,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC;QACtD,MAAM,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IAC3D,CAAC;AACH,CAAC;AAEM,KAAK,UAAU,YAAY,CAAC,SAAwB,EAAE,QAAkB,EAAE,QAAiB,EAAE,GAAa;IAC/G,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACpC,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;QACtD,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,MAAM,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;YACjD,OAAO;QACT,CAAC;QAED,MAAM,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAgB,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;QACjE,MAAM,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,sBAAsB,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;QAC5E,MAAM,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,eAAe,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;QAC9D,OAAO;IACT,CAAC;IAED,MAAM,OAAO,GAAG,CAAC,mBAAmB,EAAE,mBAAmB,EAAE,YAAY,CAAC,CAAC;IACzE,MAAM,IAAI,GAAe,EAAE,CAAC;IAE5B,MAAM,eAAe,GAAG,CAAC,IAAiB,EAAU,EAAE;QACpD,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;YACjC,OAAO,CAAC,CAAC;QACX,CAAC;aAAM,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC;YACpE,OAAO,CAAC,CAAC;QACX,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,CAAC;QACX,CAAC;IACH,CAAC,CAAC;IAEF,IAAI,cAA6B,CAAC;IAClC,IAAI,GAAG,EAAE,CAAC;QACR,cAAc,GAAG,SAAS,CAAC;IAC7B,CAAC;SAAM,CAAC;QACN,cAAc,GAAG,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CACvC,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CACzF,CAAC;IACJ,CAAC;IAED,MAAM,WAAW,GAAG,CAAC,GAAG,cAAc,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACpD,MAAM,SAAS,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;QACrC,MAAM,SAAS,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;QAErC,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,OAAO,SAAS,GAAG,SAAS,CAAC;QAC/B,CAAC;QACD,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;YAC1B,OAAO,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QAC1C,CAAC;QACD,OAAO,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,IAAI,aAAa,GAAG,EAAE,CAAC;IACvB,WAAW,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QAC3B,IAAI,IAAI,CAAC,MAAM,KAAK,aAAa,EAAE,CAAC;YAClC,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;YAC1D,aAAa,GAAG,IAAI,CAAC,MAAM,CAAC;QAC9B,CAAC;QACD,IAAI,CAAC,IAAI,CAAC;YACR,IAAI,CAAC,IAAI;YACT,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC;YAC7B,IAAI,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC;SAClE,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAClD,MAAM,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;AAC/C,CAAC;AAED,KAAK,UAAU,gBAAgB,CAC7B,QAAuB,EACvB,QAAkB,EAClB,QAAgB,EAChB,KAAyB,EACzB,OAAgB;IAEhB,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;IACrD,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;QACjD,OAAO;IACT,CAAC;IAED,IAAI,OAAO,IAAI,CAAC,gBAAgB,KAAK,SAAS,IAAI,IAAI,CAAC,gBAAgB,KAAK,MAAM,IAAI,IAAI,CAAC,gBAAgB,KAAK,OAAO,EAAE,CAAC;QACxH,MAAM,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,QAAQ,sEAAsE,CAAC,CAAC;QACvH,OAAO;IACT,CAAC;IAED,MAAM,WAAW,GAAG,IAAI,gCAAkB,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;IAC1D,MAAM,iBAAiB,GAAG,MAAM,WAAW,CAAC,IAAI,EAAE,CAAC;IACnD,MAAM,aAAa,GAAG,IAAI,2BAAa,CAAC,iBAAiB,CAAC,CAAC;IAE3D,MAAM,SAAS,GAAG,KAAM,CAAC,WAAW,EAAE,KAAK,MAAM,CAAC;IAElD,IAAI,iBAAiB,CAAC,QAAQ,CAAC,IAAI,SAAS,EAAE,CAAC;QAC7C,MAAM,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,gEAAgE,CAAC,CAAC;QAChG,OAAO;IACT,CAAC;IACD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,UAAU,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;IACnG,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IAExB,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,GAAG,EAAE;QAC3C,YAAY,EAAE,WAAW;QACzB,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,UAAU,CAAC;KAC7C,CAAC,CAAC;IAEH,MAAM,EAAE,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACvC,MAAM,QAAQ,GAAG,EAAE,CAAC,aAAa,CAAC;IAElC,MAAM,SAAS,GAA4B,EAAE,CAAC;IAC9C,SAAS,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC;IAChC,MAAM,aAAa,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IAEtC,MAAM,cAAc,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,GAAG,EAAE;QACnD,YAAY,EAAE,aAAa;QAC3B,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC;KACzC,CAAC,CAAC;IAEH,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;IACvD,MAAM,SAAS,GAAG,QAAQ,CAAC,iBAAiB,CAAC;IAE7C,KAAK,MAAM,KAAK,IAAI,SAAS,EAAE,CAAC;QAC9B,MAAM,YAAY,GAAG,KAAK,CAAC,gBAAgB,CAAC;QAC5C,MAAM,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE;YAC7B,MAAM,EAAE,wBAAU,CAAC,SAAS,CAAC,YAAY,CAAC;YAC1C,MAAM,EAAE;gBACN,QAAQ,EAAE,4BAAsB,CAAC,yBAAyB;gBAC1D,QAAQ,EAAE,CAAC,KAAK,CAAC,cAAc,CAAC;aACjC;SACF,CAAC,CAAC;IACL,CAAC;IAED,MAAM,YAAY,GAAG,MAAM,UAAU,CACnC,QAAQ,EACR,QAAQ,EACR,IAAI,CAAC,SAAS,EACd,KAAK,EAAE,WAAW,EAAE,KAAK,MAAM,CAChC,CAAC;IAEF,IAAI,YAAY,EAAE,CAAC;QACjB,MAAM,YAAY,CAAC,QAAQ,EAAE,KAAM,EAAE,QAAQ,CAAC,CAAC;QAC/C,MAAM,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,kCAAkC,CAAC,CAAC;IACnE,CAAC;SAAM,CAAC;QACN,MAAM,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;IACtD,CAAC;IAED,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,UAAU,CAAC,CAAC;IACzD,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC,CAAC;IAEjD,MAAM,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAC7B,MAAM,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AAC3B,CAAC;AAED,KAAK,UAAU,UAAU,CACvB,QAAkB,EAClB,QAAgB,EAChB,YAAqB,EACrB,QAAiB;IAEjB,OAAO,QAAQ,CAAC,eAAe,CAAC;QAC9B,IAAI,EAAE,IAAI,IAAI,EAAE;QAChB,KAAK,EAAE,MAAM;QACb,IAAI,EAAE,mBAAmB;QACzB,OAAO,EAAE,sCAAsC;QAC/C,IAAI,EAAE;YACJ,QAAQ;YACR,YAAY;YACZ,QAAQ;YACR,mBAAmB,EAAE,6CAA6C;SACnE;QACD,eAAe,EAAE,KAAK;KACvB,CAAC,CAAC;AACL,CAAC;AAED,KAAK,UAAU,YAAY,CAAC,QAAgB,EAAE,KAAa,EAAE,QAAkB;IAC7E,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,UAAU,CAAC,CAAC;IACzD,MAAM,cAAc,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IAC/D,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;IAE3C,MAAM,SAAS,GAAG,KAAM,CAAC,WAAW,EAAE,KAAK,MAAM,CAAC;IAClD,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC;IAEtC,MAAM,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,iBAAiB,QAAQ,SAAS,SAAS,EAAE,CAAC,CAAC;IAC5E,MAAM,EAAE,CAAC,SAAS,CAAC,WAAW,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;AAC7E,CAAC;AAED,SAAS,WAAW,CAAC,OAAiB,EAAE,IAAgB;IACtD,MAAM,YAAY,GAAG;QACnB,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QAC9D,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QAC9D,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;KAC/D,CAAC;IAEF,MAAM,eAAe,GAAG,GAAG,EAAE;QAC3B,OAAO,GAAG,GAAG,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;IAChF,CAAC,CAAC;IAEF,MAAM,SAAS,GAAG,CAAC,MAAgB,EAAE,EAAE;QACrC,OAAO,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;IAC9F,CAAC,CAAC;IAEF,MAAM,SAAS,GAAG,eAAe,EAAE,CAAC;IACpC,IAAI,KAAK,GAAG,SAAS,GAAG,IAAI,CAAC;IAC7B,KAAK,IAAI,SAAS,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;IACnC,KAAK,IAAI,SAAS,GAAG,IAAI,CAAC;IAE1B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;QACjB,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC;YACnC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QACnD,CAAC;aAAM,CAAC;YACN,KAAK,IAAI,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;QACjC,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,KAAK,IAAI,SAAS,CAAC;IACnB,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["import * as path from 'path';\nimport type { FeatureFlag, Toolkit } from '@aws-cdk/toolkit-lib';\nimport { CdkAppMultiContext, MemoryContext, DiffMethod } from '@aws-cdk/toolkit-lib';\nimport * as chalk from 'chalk';\nimport * as fs from 'fs-extra';\nimport { StackSelectionStrategy } from '../api';\nimport type { IoHelper } from '../api-private';\nimport type { FlagsOptions } from '../cli/user-input';\n\nexport async function handleFlags(flagData: FeatureFlag[], ioHelper: IoHelper, options: FlagsOptions, toolkit: Toolkit) {\n  if (options.FLAGNAME && options.all) {\n    await ioHelper.defaults.error('Error: Cannot use both --all and a specific flag name. Please use either --all to show all flags or specify a single flag name.');\n    return;\n  }\n\n  if (options.set && options.all) {\n    await ioHelper.defaults.error('Error: --set is currently only compatible with a flag name. Please specify which flag you want to set.');\n    return;\n  }\n\n  if (options.set && !options.FLAGNAME) {\n    await ioHelper.defaults.error('Error: --set requires a flag name. Please specify which flag you want to set.');\n    return;\n  }\n\n  if (options.set && !options.value) {\n    await ioHelper.defaults.error('Error: --set requires a value. Please specify the value you want to set for the flag.');\n    return;\n  }\n\n  if (options.FLAGNAME && !options.set && !options.value) {\n    await displayFlags(flagData, ioHelper, String(options.FLAGNAME));\n    return;\n  }\n\n  if (options.all && !options.set) {\n    await displayFlags(flagData, ioHelper, undefined, true);\n    return;\n  }\n\n  if (options.set && options.FLAGNAME || options.value && options.FLAGNAME) {\n    await prototypeChanges(flagData, ioHelper, String(options.FLAGNAME), options.value, toolkit);\n    return;\n  }\n\n  if (!options.FLAGNAME && !options.all && !options.set) {\n    await displayFlags(flagData, ioHelper, undefined, false);\n  }\n}\n\nexport async function displayFlags(flagsData: FeatureFlag[], ioHelper: IoHelper, flagName?: string, all?: boolean): Promise<void> {\n  if (flagName && flagName.length > 0) {\n    const flag = flagsData.find(f => f.name === flagName);\n    if (!flag) {\n      await ioHelper.defaults.error('Flag not found.');\n      return;\n    }\n\n    await ioHelper.defaults.info(`Description: ${flag.explanation}`);\n    await ioHelper.defaults.info(`Recommended value: ${flag.recommendedValue}`);\n    await ioHelper.defaults.info(`User value: ${flag.userValue}`);\n    return;\n  }\n\n  const headers = ['Feature Flag Name', 'Recommended Value', 'User Value'];\n  const rows: string[][] = [];\n\n  const getFlagPriority = (flag: FeatureFlag): number => {\n    if (flag.userValue === undefined) {\n      return 3;\n    } else if (String(flag.userValue) === String(flag.recommendedValue)) {\n      return 1;\n    } else {\n      return 2;\n    }\n  };\n\n  let flagsToDisplay: FeatureFlag[];\n  if (all) {\n    flagsToDisplay = flagsData;\n  } else {\n    flagsToDisplay = flagsData.filter(flag =>\n      flag.userValue === undefined || String(flag.userValue) !== String(flag.recommendedValue),\n    );\n  }\n\n  const sortedFlags = [...flagsToDisplay].sort((a, b) => {\n    const priorityA = getFlagPriority(a);\n    const priorityB = getFlagPriority(b);\n\n    if (priorityA !== priorityB) {\n      return priorityA - priorityB;\n    }\n    if (a.module !== b.module) {\n      return a.module.localeCompare(b.module);\n    }\n    return a.name.localeCompare(b.name);\n  });\n\n  let currentModule = '';\n  sortedFlags.forEach((flag) => {\n    if (flag.module !== currentModule) {\n      rows.push([chalk.bold(`Module: ${flag.module}`), '', '']);\n      currentModule = flag.module;\n    }\n    rows.push([\n      flag.name,\n      String(flag.recommendedValue),\n      flag.userValue === undefined ? '<unset>' : String(flag.userValue),\n    ]);\n  });\n\n  const formattedTable = formatTable(headers, rows);\n  await ioHelper.defaults.info(formattedTable);\n}\n\nasync function prototypeChanges(\n  flagData: FeatureFlag[],\n  ioHelper: IoHelper,\n  flagName: string,\n  value: string | undefined,\n  toolkit: Toolkit,\n) {\n  const flag = flagData.find(f => f.name === flagName);\n  if (!flag) {\n    await ioHelper.defaults.error('Flag not found.');\n    return;\n  }\n\n  if (typeof flag.recommendedValue !== 'boolean' && flag.recommendedValue !== 'true' && flag.recommendedValue !== 'false') {\n    await ioHelper.defaults.error(`Flag '${flagName}' is not a boolean flag. Only boolean flags are currently supported.`);\n    return;\n  }\n\n  const baseContext = new CdkAppMultiContext(process.cwd());\n  const baseContextValues = await baseContext.read();\n  const memoryContext = new MemoryContext(baseContextValues);\n\n  const boolValue = value!.toLowerCase() === 'true';\n\n  if (baseContextValues[flagName] == boolValue) {\n    await ioHelper.defaults.error('Flag is already set to the specified value. No changes needed.');\n    return;\n  }\n  const cdkJson = await JSON.parse(await fs.readFile(path.join(process.cwd(), 'cdk.json'), 'utf-8'));\n  const app = cdkJson.app;\n\n  const source = await toolkit.fromCdkApp(app, {\n    contextStore: baseContext,\n    outdir: path.join(process.cwd(), 'original'),\n  });\n\n  const cx = await toolkit.synth(source);\n  const assembly = cx.cloudAssembly;\n\n  const updateObj: Record<string, boolean> = {};\n  updateObj[flagName] = boolValue;\n  await memoryContext.update(updateObj);\n\n  const modifiedSource = await toolkit.fromCdkApp(app, {\n    contextStore: memoryContext,\n    outdir: path.join(process.cwd(), 'temp'),\n  });\n\n  const modifiedCx = await toolkit.synth(modifiedSource);\n  const allStacks = assembly.stacksRecursively;\n\n  for (const stack of allStacks) {\n    const templatePath = stack.templateFullPath;\n    await toolkit.diff(modifiedCx, {\n      method: DiffMethod.LocalFile(templatePath),\n      stacks: {\n        strategy: StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE,\n        patterns: [stack.hierarchicalId],\n      },\n    });\n  }\n\n  const userAccepted = await promptUser(\n    ioHelper,\n    flagName,\n    flag.userValue,\n    value?.toLowerCase() === 'true',\n  );\n\n  if (userAccepted) {\n    await modifyValues(flagName, value!, ioHelper);\n    await ioHelper.defaults.info('Flag value updated successfully.');\n  } else {\n    await ioHelper.defaults.info('Operation cancelled');\n  }\n\n  const originalDir = path.join(process.cwd(), 'original');\n  const tempDir = path.join(process.cwd(), 'temp');\n\n  await fs.remove(originalDir);\n  await fs.remove(tempDir);\n}\n\nasync function promptUser(\n  ioHelper: IoHelper,\n  flagName: string,\n  currentValue: unknown,\n  newValue: boolean,\n): Promise<boolean> {\n  return ioHelper.requestResponse({\n    time: new Date(),\n    level: 'info',\n    code: 'CDK_TOOLKIT_I9300',\n    message: 'Do you want to accept these changes?',\n    data: {\n      flagName,\n      currentValue,\n      newValue,\n      responseDescription: 'Enter \"y\" to apply changes or \"n\" to cancel',\n    },\n    defaultResponse: false,\n  });\n}\n\nasync function modifyValues(flagName: string, value: string, ioHelper: IoHelper): Promise<void> {\n  const cdkJsonPath = path.join(process.cwd(), 'cdk.json');\n  const cdkJsonContent = await fs.readFile(cdkJsonPath, 'utf-8');\n  const cdkJson = JSON.parse(cdkJsonContent);\n\n  const boolValue = value!.toLowerCase() === 'true';\n  cdkJson.context[flagName] = boolValue;\n\n  await ioHelper.defaults.info(`Setting flag '${flagName}' to: ${boolValue}`);\n  await fs.writeFile(cdkJsonPath, JSON.stringify(cdkJson, null, 2), 'utf-8');\n}\n\nfunction formatTable(headers: string[], rows: string[][]): string {\n  const columnWidths = [\n    Math.max(headers[0].length, ...rows.map(row => row[0].length)),\n    Math.max(headers[1].length, ...rows.map(row => row[1].length)),\n    Math.max(headers[2].length, ...rows.map(row => row[2].length)),\n  ];\n\n  const createSeparator = () => {\n    return '+' + columnWidths.map(width => '-'.repeat(width + 2)).join('+') + '+';\n  };\n\n  const formatRow = (values: string[]) => {\n    return '|' + values.map((value, i) => ` ${value.padEnd(columnWidths[i])} `).join('|') + '|';\n  };\n\n  const separator = createSeparator();\n  let table = separator + '\\n';\n  table += formatRow(headers) + '\\n';\n  table += separator + '\\n';\n\n  rows.forEach(row => {\n    if (row[1] === '' && row[2] === '') {\n      table += ` ${row[0].padEnd(columnWidths[0])} \\n`;\n    } else {\n      table += formatRow(row) + '\\n';\n    }\n  });\n\n  table += separator;\n  return table;\n}\n"]}

package/lib/cxapp/cloud-executable.js

@@ -5,6 +5,8 @@ const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
 const cloud_assembly_1 = require("./cloud-assembly");
 const api_private_1 = require("../../lib/api-private");
 const singleton_plugin_host_1 = require("../cli/singleton-plugin-host");
+const error_1 = require("../cli/telemetry/error");
+const messages_1 = require("../cli/telemetry/messages");
 const contextproviders = require("../context-providers");
 /**
  * Represent the Cloud Executable and the synthesis we can do on it
@@ -46,34 +48,47 @@ class CloudExecutable {
         // but it missing. We'll then look up the context and run the executable again, and
         // again, until it doesn't complain anymore or we've stopped making progress).
         let previouslyMissingKeys;
-        while (true) {
-            const assembly = await this.props.synthesizer(this.props.sdkProvider, this.props.configuration);
-            if (assembly.manifest.missing && assembly.manifest.missing.length > 0) {
-                const missingKeys = missingContextKeys(assembly.manifest.missing);
-                if (!this.canLookup) {
-                    throw new toolkit_lib_1.ToolkitError('Context lookups have been disabled. '
-                        + 'Make sure all necessary context is already in \'cdk.context.json\' by running \'cdk synth\' on a machine with sufficient AWS credentials and committing the result. '
-                        + `Missing context keys: '${Array.from(missingKeys).join(', ')}'`);
-                }
-                let tryLookup = true;
-                if (previouslyMissingKeys && setsEqual(missingKeys, previouslyMissingKeys)) {
-                    await this.props.ioHelper.defaults.debug('Not making progress trying to resolve environmental context. Giving up.');
-                    tryLookup = false;
-                }
-                previouslyMissingKeys = missingKeys;
-                if (tryLookup) {
-                    await this.props.ioHelper.defaults.debug('Some context information is missing. Fetching...');
-                    const updates = await contextproviders.provideContextValues(assembly.manifest.missing, this.props.sdkProvider, singleton_plugin_host_1.GLOBAL_PLUGIN_HOST, this.props.ioHelper);
-                    for (const [key, value] of Object.entries(updates)) {
-                        this.props.configuration.context.set(key, value);
+        const synthSpan = await this.props.ioHelper.span(messages_1.CLI_PRIVATE_SPAN.SYNTH_ASSEMBLY).begin({});
+        let error;
+        try {
+            while (true) {
+                const assembly = await this.props.synthesizer(this.props.sdkProvider, this.props.configuration);
+                if (assembly.manifest.missing && assembly.manifest.missing.length > 0) {
+                    const missingKeys = missingContextKeys(assembly.manifest.missing);
+                    if (!this.canLookup) {
+                        throw new toolkit_lib_1.ToolkitError('Context lookups have been disabled. '
+                            + 'Make sure all necessary context is already in \'cdk.context.json\' by running \'cdk synth\' on a machine with sufficient AWS credentials and committing the result. '
+                            + `Missing context keys: '${Array.from(missingKeys).join(', ')}'`);
+                    }
+                    let tryLookup = true;
+                    if (previouslyMissingKeys && setsEqual(missingKeys, previouslyMissingKeys)) {
+                        await this.props.ioHelper.defaults.debug('Not making progress trying to resolve environmental context. Giving up.');
+                        tryLookup = false;
+                    }
+                    previouslyMissingKeys = missingKeys;
+                    if (tryLookup) {
+                        await this.props.ioHelper.defaults.debug('Some context information is missing. Fetching...');
+                        const updates = await contextproviders.provideContextValues(assembly.manifest.missing, this.props.sdkProvider, singleton_plugin_host_1.GLOBAL_PLUGIN_HOST, this.props.ioHelper);
+                        for (const [key, value] of Object.entries(updates)) {
+                            this.props.configuration.context.set(key, value);
+                        }
+                        // Cache the new context to disk
+                        await this.props.configuration.saveContext();
+                        // Execute again
+                        continue;
                     }
-                    // Cache the new context to disk
-                    await this.props.configuration.saveContext();
-                    // Execute again
-                    continue;
                 }
+                return new cloud_assembly_1.CloudAssembly(assembly, this.props.ioHelper);
             }
-            return new cloud_assembly_1.CloudAssembly(assembly, this.props.ioHelper);
+        }
+        catch (e) {
+            error = {
+                name: (0, error_1.cdkCliErrorName)(e.name),
+            };
+            throw e;
+        }
+        finally {
+            await synthSpan.end({ error });
         }
     }
     get canLookup() {
@@ -98,4 +113,4 @@ function setsEqual(a, b) {
     }
     return true;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloud-executable.js","sourceRoot":"","sources":["cloud-executable.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as cxapi from '@aws-cdk/cx-api';\nimport { ToolkitError } from '@aws-cdk/toolkit-lib';\nimport { CloudAssembly } from './cloud-assembly';\nimport type { ICloudAssemblySource, IReadableCloudAssembly } from '../../lib/api';\nimport type { IoHelper } from '../../lib/api-private';\nimport { BorrowedAssembly } from '../../lib/api-private';\nimport type { SdkProvider } from '../api/aws-auth';\nimport { GLOBAL_PLUGIN_HOST } from '../cli/singleton-plugin-host';\nimport type { Configuration } from '../cli/user-configuration';\nimport * as contextproviders from '../context-providers';\n\n/**\n * @returns output directory\n */\nexport type Synthesizer = (aws: SdkProvider, config: Configuration) => Promise<cxapi.CloudAssembly>;\n\nexport interface CloudExecutableProps {\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   * Messaging helper\n   */\n  ioHelper: IoHelper;\n\n  /**\n   * Callback invoked to synthesize the actual stacks\n   */\n  synthesizer: Synthesizer;\n}\n\n/**\n * Represent the Cloud Executable and the synthesis we can do on it\n */\nexport class CloudExecutable implements ICloudAssemblySource {\n  private _cloudAssembly?: CloudAssembly;\n\n  constructor(private readonly props: CloudExecutableProps) {\n  }\n\n  public async produce(): Promise<IReadableCloudAssembly> {\n    const synthesisResult = await this.synthesize(true);\n\n    // We must return an `IReadableCloudAssembly` here, but this Cloud Assembly is only used in the context\n    // of the CLI and `cli.ts` currently manages its own locking in the \"synthesizer\" callback function.\n    //\n    // All the lock-related functions are therefore no-ops.\n    return new BorrowedAssembly(synthesisResult.assembly);\n  }\n\n  /**\n   * Return whether there is an app command from the configuration\n   */\n  public get hasApp() {\n    return !!this.props.configuration.settings.get(['app']);\n  }\n\n  /**\n   * Synthesize a set of stacks.\n   *\n   * @param cacheCloudAssembly - whether to cache the Cloud Assembly after it has been first synthesized.\n   *   This is 'true' by default, and only set to 'false' for 'cdk watch',\n   *   which needs to re-synthesize the Assembly each time it detects a change to the project files\n   */\n  public async synthesize(cacheCloudAssembly: boolean = true): Promise<CloudAssembly> {\n    if (!this._cloudAssembly || !cacheCloudAssembly) {\n      this._cloudAssembly = await this.doSynthesize();\n    }\n    return this._cloudAssembly;\n  }\n\n  private async doSynthesize(): Promise<CloudAssembly> {\n    // We may need to run the cloud executable multiple times in order to satisfy all missing context\n    // (When the executable runs, it will tell us about context it wants to use\n    // but it missing. We'll then look up the context and run the executable again, and\n    // again, until it doesn't complain anymore or we've stopped making progress).\n    let previouslyMissingKeys: Set<string> | undefined;\n    while (true) {\n      const assembly = await this.props.synthesizer(this.props.sdkProvider, this.props.configuration);\n\n      if (assembly.manifest.missing && assembly.manifest.missing.length > 0) {\n        const missingKeys = missingContextKeys(assembly.manifest.missing);\n\n        if (!this.canLookup) {\n          throw new ToolkitError(\n            'Context lookups have been disabled. '\n            + 'Make sure all necessary context is already in \\'cdk.context.json\\' by running \\'cdk synth\\' on a machine with sufficient AWS credentials and committing the result. '\n            + `Missing context keys: '${Array.from(missingKeys).join(', ')}'`);\n        }\n\n        let tryLookup = true;\n        if (previouslyMissingKeys && setsEqual(missingKeys, previouslyMissingKeys)) {\n          await this.props.ioHelper.defaults.debug('Not making progress trying to resolve environmental context. Giving up.');\n          tryLookup = false;\n        }\n\n        previouslyMissingKeys = missingKeys;\n\n        if (tryLookup) {\n          await this.props.ioHelper.defaults.debug('Some context information is missing. Fetching...');\n\n          const updates = await contextproviders.provideContextValues(\n            assembly.manifest.missing,\n            this.props.sdkProvider,\n            GLOBAL_PLUGIN_HOST,\n            this.props.ioHelper,\n          );\n\n          for (const [key, value] of Object.entries(updates)) {\n            this.props.configuration.context.set(key, value);\n          }\n\n          // Cache the new context to disk\n          await this.props.configuration.saveContext();\n\n          // Execute again\n          continue;\n        }\n      }\n\n      return new CloudAssembly(assembly, this.props.ioHelper);\n    }\n  }\n\n  private get canLookup() {\n    return !!(this.props.configuration.settings.get(['lookups']) ?? true);\n  }\n}\n\n/**\n * Return all keys of missing context items\n */\nfunction missingContextKeys(missing?: cxapi.MissingContext[]): Set<string> {\n  return new Set((missing || []).map(m => m.key));\n}\n\nfunction setsEqual<A>(a: Set<A>, b: Set<A>) {\n  if (a.size !== b.size) {\n    return false;\n  }\n  for (const x of a) {\n    if (!b.has(x)) {\n      return false;\n    }\n  }\n  return true;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloud-executable.js","sourceRoot":"","sources":["cloud-executable.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as cxapi from '@aws-cdk/cx-api';\nimport { ToolkitError } from '@aws-cdk/toolkit-lib';\nimport { CloudAssembly } from './cloud-assembly';\nimport type { ICloudAssemblySource, IReadableCloudAssembly } from '../../lib/api';\nimport type { IoHelper } from '../../lib/api-private';\nimport { BorrowedAssembly } from '../../lib/api-private';\nimport type { SdkProvider } from '../api/aws-auth';\nimport { GLOBAL_PLUGIN_HOST } from '../cli/singleton-plugin-host';\nimport { cdkCliErrorName } from '../cli/telemetry/error';\nimport { CLI_PRIVATE_SPAN } from '../cli/telemetry/messages';\nimport type { ErrorDetails } from '../cli/telemetry/schema';\nimport type { Configuration } from '../cli/user-configuration';\nimport * as contextproviders from '../context-providers';\n\n/**\n * @returns output directory\n */\nexport type Synthesizer = (aws: SdkProvider, config: Configuration) => Promise<cxapi.CloudAssembly>;\n\nexport interface CloudExecutableProps {\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   * Messaging helper\n   */\n  ioHelper: IoHelper;\n\n  /**\n   * Callback invoked to synthesize the actual stacks\n   */\n  synthesizer: Synthesizer;\n}\n\n/**\n * Represent the Cloud Executable and the synthesis we can do on it\n */\nexport class CloudExecutable implements ICloudAssemblySource {\n  private _cloudAssembly?: CloudAssembly;\n\n  constructor(private readonly props: CloudExecutableProps) {\n  }\n\n  public async produce(): Promise<IReadableCloudAssembly> {\n    const synthesisResult = await this.synthesize(true);\n\n    // We must return an `IReadableCloudAssembly` here, but this Cloud Assembly is only used in the context\n    // of the CLI and `cli.ts` currently manages its own locking in the \"synthesizer\" callback function.\n    //\n    // All the lock-related functions are therefore no-ops.\n    return new BorrowedAssembly(synthesisResult.assembly);\n  }\n\n  /**\n   * Return whether there is an app command from the configuration\n   */\n  public get hasApp() {\n    return !!this.props.configuration.settings.get(['app']);\n  }\n\n  /**\n   * Synthesize a set of stacks.\n   *\n   * @param cacheCloudAssembly - whether to cache the Cloud Assembly after it has been first synthesized.\n   *   This is 'true' by default, and only set to 'false' for 'cdk watch',\n   *   which needs to re-synthesize the Assembly each time it detects a change to the project files\n   */\n  public async synthesize(cacheCloudAssembly: boolean = true): Promise<CloudAssembly> {\n    if (!this._cloudAssembly || !cacheCloudAssembly) {\n      this._cloudAssembly = await this.doSynthesize();\n    }\n    return this._cloudAssembly;\n  }\n\n  private async doSynthesize(): Promise<CloudAssembly> {\n    // We may need to run the cloud executable multiple times in order to satisfy all missing context\n    // (When the executable runs, it will tell us about context it wants to use\n    // but it missing. We'll then look up the context and run the executable again, and\n    // again, until it doesn't complain anymore or we've stopped making progress).\n    let previouslyMissingKeys: Set<string> | undefined;\n    const synthSpan = await this.props.ioHelper.span(CLI_PRIVATE_SPAN.SYNTH_ASSEMBLY).begin({});\n    let error: ErrorDetails | undefined;\n    try {\n      while (true) {\n        const assembly = await this.props.synthesizer(this.props.sdkProvider, this.props.configuration);\n\n        if (assembly.manifest.missing && assembly.manifest.missing.length > 0) {\n          const missingKeys = missingContextKeys(assembly.manifest.missing);\n\n          if (!this.canLookup) {\n            throw new ToolkitError(\n              'Context lookups have been disabled. '\n              + 'Make sure all necessary context is already in \\'cdk.context.json\\' by running \\'cdk synth\\' on a machine with sufficient AWS credentials and committing the result. '\n              + `Missing context keys: '${Array.from(missingKeys).join(', ')}'`);\n          }\n\n          let tryLookup = true;\n          if (previouslyMissingKeys && setsEqual(missingKeys, previouslyMissingKeys)) {\n            await this.props.ioHelper.defaults.debug('Not making progress trying to resolve environmental context. Giving up.');\n            tryLookup = false;\n          }\n\n          previouslyMissingKeys = missingKeys;\n\n          if (tryLookup) {\n            await this.props.ioHelper.defaults.debug('Some context information is missing. Fetching...');\n\n            const updates = await contextproviders.provideContextValues(\n              assembly.manifest.missing,\n              this.props.sdkProvider,\n              GLOBAL_PLUGIN_HOST,\n              this.props.ioHelper,\n            );\n\n            for (const [key, value] of Object.entries(updates)) {\n              this.props.configuration.context.set(key, value);\n            }\n\n            // Cache the new context to disk\n            await this.props.configuration.saveContext();\n\n            // Execute again\n            continue;\n          }\n        }\n        return new CloudAssembly(assembly, this.props.ioHelper);\n      }\n    } catch (e: any) {\n      error = {\n        name: cdkCliErrorName(e.name),\n      };\n      throw e;\n    } finally {\n      await synthSpan.end({ error });\n    }\n  }\n\n  private get canLookup() {\n    return !!(this.props.configuration.settings.get(['lookups']) ?? true);\n  }\n}\n\n/**\n * Return all keys of missing context items\n */\nfunction missingContextKeys(missing?: cxapi.MissingContext[]): Set<string> {\n  return new Set((missing || []).map(m => m.key));\n}\n\nfunction setsEqual<A>(a: Set<A>, b: Set<A>) {\n  if (a.size !== b.size) {\n    return false;\n  }\n  for (const x of a) {\n    if (!b.has(x)) {\n      return false;\n    }\n  }\n  return true;\n}\n"]}