@depup/aws-cdk 2.1117.0-depup.0

package/lib/cli/cli.js

@@ -0,0 +1,746 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exec = exec;
+exports.cli = cli;
+/* eslint-disable @typescript-eslint/no-shadow */ // yargs
+const cxapi = require("@aws-cdk/cx-api");
+const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
+const chalk = require("chalk");
+const util_1 = require("../util");
+const cdk_toolkit_1 = require("./cdk-toolkit");
+const ci_systems_1 = require("./ci-systems");
+const display_version_1 = require("./display-version");
+const io_host_1 = require("./io-host");
+const parse_command_line_arguments_1 = require("./parse-command-line-arguments");
+const platform_warnings_1 = require("./platform-warnings");
+const pretty_print_error_1 = require("./pretty-print-error");
+const proxy_agent_1 = require("./proxy-agent");
+const singleton_plugin_host_1 = require("./singleton-plugin-host");
+const error_1 = require("./telemetry/error");
+const user_configuration_1 = require("./user-configuration");
+const trap_errors_1 = require("./util/trap-errors");
+const version_1 = require("./version");
+const api_private_1 = require("../../lib/api-private");
+const api_1 = require("../api");
+const aws_auth_1 = require("../api/aws-auth");
+const bootstrap_1 = require("../api/bootstrap");
+const deployments_1 = require("../api/deployments");
+const hotswap_1 = require("../api/hotswap");
+const context_1 = require("../commands/context");
+const docs_1 = require("../commands/docs");
+const doctor_1 = require("../commands/doctor");
+const flags_1 = require("../commands/flags/flags");
+const init_1 = require("../commands/init");
+const language_1 = require("../commands/language");
+const migrate_1 = require("../commands/migrate");
+const cxapp_1 = require("../cxapp");
+const ci_1 = require("./util/ci");
+const guess_agent_1 = require("./util/guess-agent");
+async function exec(args, synthesizer) {
+    const argv = await (0, parse_command_line_arguments_1.parseCommandLineArguments)(args);
+    argv.language = (0, language_1.getLanguageFromAlias)(argv.language) ?? argv.language;
+    // Handle color output settings
+    // Priority: --no-color > --color > TTY detection
+    if (argv.noColor) {
+        process.env.FORCE_COLOR = '0';
+    }
+    else if (argv.color) {
+        process.env.FORCE_COLOR = '3';
+    }
+    else if (!process.stdout.isTTY) {
+        // Default behavior: disable colors for non-TTY
+        process.env.FORCE_COLOR = '0';
+    }
+    const cmd = argv._[0];
+    // if one -v, log at a DEBUG level
+    // if 2 -v, log at a TRACE level
+    let ioMessageLevel = 'info';
+    if (argv.verbose) {
+        switch (argv.verbose) {
+            case 1:
+                ioMessageLevel = 'debug';
+                break;
+            case 2:
+            default:
+                ioMessageLevel = 'trace';
+                break;
+        }
+    }
+    const ioHost = io_host_1.CliIoHost.instance({
+        logLevel: ioMessageLevel,
+        isTTY: process.stdout.isTTY,
+        isCI: Boolean(argv.ci),
+        currentAction: cmd,
+        stackProgress: argv.progress,
+        autoRespond: argv.yes,
+    }, true);
+    const ioHelper = (0, api_private_1.asIoHelper)(ioHost, ioHost.currentAction);
+    // Debug should always imply tracing
+    (0, aws_auth_1.setSdkTracing)(argv.debug || argv.verbose > 2);
+    try {
+        await (0, platform_warnings_1.checkForPlatformWarnings)(ioHelper);
+    }
+    catch (e) {
+        await ioHost.defaults.debug(`Error while checking for platform warnings: ${e}`);
+    }
+    await ioHost.defaults.debug('CDK Toolkit CLI version:', (0, version_1.versionWithBuild)());
+    await ioHost.defaults.debug('Command line arguments:', argv);
+    const configuration = await user_configuration_1.Configuration.fromArgsAndFiles(ioHelper, {
+        commandLineArguments: {
+            ...argv,
+            _: argv._, // TypeScript at its best
+        },
+    });
+    // Always create and use ProxyAgent to support configuration via env vars
+    const proxyAgent = await new proxy_agent_1.ProxyAgentProvider(ioHelper).create({
+        proxyAddress: configuration.settings.get(['proxy']),
+        caBundlePath: configuration.settings.get(['caBundlePath']),
+    });
+    try {
+        await ioHost.startTelemetry(argv, configuration.context);
+    }
+    catch (e) {
+        await ioHost.asIoHelper().defaults.trace(`Telemetry instantiation failed: ${e.message}`);
+    }
+    ioHost.telemetry?.attachLanguage(await (0, util_1.guessLanguage)(process.cwd()));
+    ioHost.telemetry?.attachAgent((0, guess_agent_1.guessAgent)());
+    /**
+     * The default value for displaying (and refreshing) notices on all commands.
+     *
+     * If the user didn't supply either `--notices` or `--no-notices`, we do
+     * autodetection. The autodetection currently is: do write notices if we are
+     * not on CI, or are on a CI system where we know that writing to stderr is
+     * safe. We fail "closed"; that is, we decide to NOT print for unknown CI
+     * systems, even though technically we maybe could.
+     */
+    const isSafeToWriteNotices = !(0, ci_1.isCI)() || Boolean((0, ci_systems_1.ciSystemIsStdErrSafe)());
+    // Determine if notices should be displayed based on CLI args and configuration
+    let shouldDisplayNotices;
+    if (argv.notices !== undefined) {
+        // CLI argument takes precedence
+        shouldDisplayNotices = argv.notices;
+    }
+    else {
+        // Fall back to configuration file setting, then autodetection
+        const configNotices = configuration.settings.get(['notices']);
+        if (configNotices !== undefined) {
+            // Consider string "false" to be falsy in this context
+            shouldDisplayNotices = configNotices !== 'false' && Boolean(configNotices);
+        }
+        else {
+            // Default autodetection behavior
+            shouldDisplayNotices = isSafeToWriteNotices;
+        }
+    }
+    // Notices either go to stderr, or nowhere
+    ioHost.noticesDestination = shouldDisplayNotices ? 'stderr' : 'drop';
+    const notices = api_1.Notices.create({
+        ioHost,
+        context: configuration.context,
+        output: configuration.settings.get(['outdir']),
+        language: await (0, util_1.guessLanguage)(process.cwd()),
+        httpOptions: { agent: proxyAgent },
+        cliVersion: (0, version_1.versionNumber)(),
+    });
+    const refreshNotices = (async () => {
+        // the cdk notices command has it's own refresh
+        if (shouldDisplayNotices && cmd !== 'notices') {
+            await (0, trap_errors_1.trapErrors)(ioHelper, 'Could not refresh notices', () => notices.refresh());
+        }
+    })();
+    const sdkProvider = await aws_auth_1.SdkProvider.withAwsCliCompatibleDefaults({
+        ioHelper,
+        requestHandler: (0, aws_auth_1.sdkRequestHandler)(proxyAgent),
+        logger: new aws_auth_1.IoHostSdkLogger((0, api_private_1.asIoHelper)(ioHost, ioHost.currentAction)),
+        pluginHost: singleton_plugin_host_1.GLOBAL_PLUGIN_HOST,
+    }, configuration.settings.get(['profile']));
+    try {
+        await ioHost.telemetry?.attachRegion(sdkProvider.defaultRegion);
+    }
+    catch (e) {
+        await ioHost.asIoHelper().defaults.trace(`Telemetry attach region failed: ${e.message}`);
+    }
+    let outDirLock;
+    const cloudExecutable = new cxapp_1.CloudExecutable({
+        configuration,
+        sdkProvider,
+        synthesizer: synthesizer ??
+            (async (aws, config) => {
+                // Invoke 'execProgram', and copy the lock for the directory in the global
+                // variable here. It will be released when the CLI exits. Locks are not re-entrant
+                // so release it if we have to synthesize more than once (because of context lookups).
+                await outDirLock?.release();
+                const { assembly, lock } = await (0, cxapp_1.execProgram)(aws, ioHost.asIoHelper(), config);
+                outDirLock = lock;
+                const tree = await (0, api_1.loadTree)(assembly, ioHelper.defaults.trace.bind(ioHelper.defaults));
+                if (tree) {
+                    const v = (0, api_1.findConstructLibraryVersion)(tree);
+                    if (v) {
+                        ioHost.telemetry?.attachCdkLibVersion(v);
+                    }
+                }
+                return assembly;
+            }),
+        ioHelper: ioHost.asIoHelper(),
+    });
+    /** Function to load plug-ins, using configurations additively. */
+    async function loadPlugins(...settings) {
+        for (const source of settings) {
+            const plugins = source.get(['plugin']) || [];
+            for (const plugin of plugins) {
+                await singleton_plugin_host_1.GLOBAL_PLUGIN_HOST.load(plugin, ioHost);
+            }
+        }
+    }
+    await loadPlugins(configuration.settings);
+    if ((typeof cmd) !== 'string') {
+        throw new toolkit_lib_1.ToolkitError('InvalidArgType', `First argument should be a string. Got: ${cmd} (${typeof cmd})`);
+    }
+    try {
+        return await main(cmd, argv);
+    }
+    finally {
+        // If we locked the 'cdk.out' directory, release it here.
+        await outDirLock?.release();
+        // Do PSAs here
+        await (0, display_version_1.displayVersionMessage)(ioHelper);
+        await refreshNotices;
+        if (cmd === 'notices') {
+            // do not trap errors here
+            // this is the notices command itself, any error should be loud
+            await notices.refresh({ force: true });
+            await notices.display({
+                includeAcknowledged: !argv.unacknowledged,
+                showTotal: argv.unacknowledged,
+            });
+        }
+        else if (shouldDisplayNotices && cmd !== 'version') {
+            await (0, trap_errors_1.trapErrors)(ioHelper, 'Could not display notices', () => notices.display());
+        }
+    }
+    async function main(command, args) {
+        ioHost.currentAction = command;
+        const toolkitStackName = api_1.ToolkitInfo.determineName(configuration.settings.get(['toolkitStackName']));
+        await ioHost.defaults.debug(`Toolkit stack: ${chalk.bold(toolkitStackName)}`);
+        const cloudFormation = new deployments_1.Deployments({
+            sdkProvider,
+            toolkitStackName,
+            ioHelper: (0, api_private_1.asIoHelper)(ioHost, ioHost.currentAction),
+        });
+        if (args.all && args.STACKS) {
+            throw new toolkit_lib_1.ToolkitError('StacksOrAllRequired', 'You must either specify a list of Stacks or the `--all` argument');
+        }
+        args.STACKS = args.STACKS ?? (args.STACK ? [args.STACK] : []);
+        args.ENVIRONMENTS = args.ENVIRONMENTS ?? [];
+        const selector = {
+            allTopLevel: args.all,
+            patterns: args.STACKS,
+        };
+        const cli = new cdk_toolkit_1.CdkToolkit({
+            ioHost,
+            cloudExecutable,
+            toolkitStackName,
+            deployments: cloudFormation,
+            verbose: argv.trace || argv.verbose > 0,
+            ignoreErrors: argv['ignore-errors'],
+            strict: argv.strict,
+            configuration,
+            sdkProvider,
+        });
+        switch (command) {
+            case 'context':
+                ioHost.currentAction = 'context';
+                return (0, context_1.contextHandler)({
+                    ioHelper,
+                    context: configuration.context,
+                    clear: argv.clear,
+                    json: argv.json,
+                    force: argv.force,
+                    reset: argv.reset,
+                });
+            case 'docs':
+            case 'doc':
+                ioHost.currentAction = 'docs';
+                return (0, docs_1.docs)({
+                    ioHelper,
+                    browser: configuration.settings.get(['browser']),
+                });
+            case 'doctor':
+                ioHost.currentAction = 'doctor';
+                return (0, doctor_1.doctor)({
+                    ioHelper,
+                });
+            case 'ls':
+            case 'list':
+                ioHost.currentAction = 'list';
+                return cli.list(args.STACKS, {
+                    long: args.long,
+                    json: argv.json,
+                    showDeps: args.showDependencies,
+                });
+            case 'diff':
+                ioHost.currentAction = 'diff';
+                const enableDiffNoFail = isFeatureEnabled(configuration, cxapi.ENABLE_DIFF_NO_FAIL_CONTEXT);
+                return cli.diff({
+                    stackNames: args.STACKS,
+                    exclusively: args.exclusively,
+                    templatePath: args.template,
+                    strict: args.strict,
+                    contextLines: args.contextLines,
+                    securityOnly: args.securityOnly,
+                    fail: args.fail != null ? args.fail : !enableDiffNoFail,
+                    compareAgainstProcessedTemplate: args.processed,
+                    quiet: args.quiet,
+                    method: determineDiffMethod(args),
+                    toolkitStackName: toolkitStackName,
+                    importExistingResources: args.importExistingResources,
+                    includeMoves: args['include-moves'],
+                });
+            case 'drift':
+                ioHost.currentAction = 'drift';
+                return cli.drift({
+                    selector,
+                    fail: args.fail,
+                });
+            case 'refactor':
+                if (!configuration.settings.get(['unstable']).includes('refactor')) {
+                    throw new toolkit_lib_1.ToolkitError('UnstableRefactor', 'Unstable feature use: \'refactor\' is unstable. It must be opted in via \'--unstable\', e.g. \'cdk refactor --unstable=refactor\'');
+                }
+                ioHost.currentAction = 'refactor';
+                return cli.refactor({
+                    dryRun: args.dryRun,
+                    overrideFile: args.overrideFile,
+                    revert: args.revert,
+                    stacks: selector,
+                    additionalStackNames: arrayFromYargs(args.additionalStackName ?? []),
+                    force: args.force ?? false,
+                    roleArn: args.roleArn,
+                });
+            case 'bootstrap':
+                ioHost.currentAction = 'bootstrap';
+                const source = await determineBootstrapVersion(ioHost, args);
+                if (args.showTemplate) {
+                    const bootstrapper = new bootstrap_1.Bootstrapper(source, (0, api_private_1.asIoHelper)(ioHost, ioHost.currentAction));
+                    return bootstrapper.showTemplate(args.json);
+                }
+                return cli.bootstrap(args.ENVIRONMENTS, {
+                    source,
+                    roleArn: args.roleArn,
+                    forceDeployment: argv.force,
+                    toolkitStackName: toolkitStackName,
+                    execute: args.execute,
+                    tags: configuration.settings.get(['tags']),
+                    terminationProtection: args.terminationProtection,
+                    usePreviousParameters: args['previous-parameters'],
+                    parameters: {
+                        bucketName: configuration.settings.get(['toolkitBucket', 'bucketName']),
+                        kmsKeyId: configuration.settings.get(['toolkitBucket', 'kmsKeyId']),
+                        createCustomerMasterKey: args.bootstrapCustomerKey,
+                        qualifier: args.qualifier ?? configuration.context.get('@aws-cdk/core:bootstrapQualifier'),
+                        publicAccessBlockConfiguration: args.publicAccessBlockConfiguration,
+                        examplePermissionsBoundary: argv.examplePermissionsBoundary,
+                        customPermissionsBoundary: argv.customPermissionsBoundary,
+                        trustedAccounts: arrayFromYargs(args.trust),
+                        trustedAccountsForLookup: arrayFromYargs(args.trustForLookup),
+                        untrustedAccounts: arrayFromYargs(args.untrust),
+                        cloudFormationExecutionPolicies: arrayFromYargs(args.cloudformationExecutionPolicies),
+                        denyExternalId: args.denyExternalId,
+                    },
+                });
+            case 'deploy':
+                ioHost.currentAction = 'deploy';
+                const parameterMap = {};
+                for (const parameter of args.parameters) {
+                    if (typeof parameter === 'string') {
+                        const keyValue = parameter.split('=');
+                        parameterMap[keyValue[0]] = keyValue.slice(1).join('=');
+                    }
+                }
+                if (args.execute !== undefined && args.method !== undefined) {
+                    throw new toolkit_lib_1.ToolkitError('ConflictingExecuteAndMethod', 'Can not supply both --[no-]execute and --method at the same time');
+                }
+                return cli.deploy({
+                    selector,
+                    exclusively: args.exclusively,
+                    toolkitStackName,
+                    roleArn: args.roleArn,
+                    notificationArns: args.notificationArns,
+                    requireApproval: configuration.settings.get(['requireApproval']),
+                    reuseAssets: args['build-exclude'],
+                    tags: configuration.settings.get(['tags']),
+                    deploymentMethod: determineDeploymentMethod(args, configuration),
+                    force: args.force,
+                    parameters: parameterMap,
+                    usePreviousParameters: args['previous-parameters'],
+                    outputsFile: configuration.settings.get(['outputsFile']),
+                    progress: configuration.settings.get(['progress']),
+                    ci: args.ci,
+                    rollback: configuration.settings.get(['rollback']),
+                    watch: args.watch,
+                    traceLogs: args.logs,
+                    concurrency: args.concurrency,
+                    assetParallelism: configuration.settings.get(['assetParallelism']),
+                    assetBuildConcurrency: configuration.settings.get(['assetBuildConcurrency']),
+                    assetBuildTime: configuration.settings.get(['assetPrebuild'])
+                        ? cdk_toolkit_1.AssetBuildTime.ALL_BEFORE_DEPLOY
+                        : cdk_toolkit_1.AssetBuildTime.JUST_IN_TIME,
+                    ignoreNoStacks: args.ignoreNoStacks,
+                });
+            case 'rollback':
+                ioHost.currentAction = 'rollback';
+                return cli.rollback({
+                    selector,
+                    toolkitStackName,
+                    roleArn: args.roleArn,
+                    force: args.force,
+                    validateBootstrapStackVersion: args['validate-bootstrap-version'],
+                    orphanLogicalIds: args.orphan,
+                });
+            case 'publish-assets':
+                ioHost.currentAction = 'publish-assets';
+                if (!configuration.settings.get(['unstable']).includes('publish-assets')) {
+                    throw new toolkit_lib_1.ToolkitError('UnstablePublishAssets', 'Unstable feature use: \'publish-assets\' is unstable. It must be opted in via \'--unstable\', e.g. \'cdk publish-assets --unstable=publish-assets\'');
+                }
+                return cli.publishAssets({
+                    stacks: convertStackSelector(selector, args.exclusively),
+                    force: args.force,
+                    concurrency: args.concurrency,
+                });
+            case 'import':
+                ioHost.currentAction = 'import';
+                return cli.import({
+                    selector,
+                    toolkitStackName,
+                    roleArn: args.roleArn,
+                    deploymentMethod: {
+                        method: 'change-set',
+                        execute: args.execute,
+                        changeSetName: args.changeSetName,
+                    },
+                    progress: configuration.settings.get(['progress']),
+                    rollback: configuration.settings.get(['rollback']),
+                    recordResourceMapping: args['record-resource-mapping'],
+                    resourceMappingFile: args['resource-mapping'],
+                    force: args.force,
+                });
+            case 'watch':
+                ioHost.currentAction = 'watch';
+                await cli.watch({
+                    selector,
+                    exclusively: args.exclusively,
+                    toolkitStackName,
+                    roleArn: args.roleArn,
+                    reuseAssets: args['build-exclude'],
+                    deploymentMethod: determineDeploymentMethod(args, configuration, true),
+                    force: args.force,
+                    progress: configuration.settings.get(['progress']),
+                    rollback: configuration.settings.get(['rollback']),
+                    traceLogs: args.logs,
+                    concurrency: args.concurrency,
+                });
+                return;
+            case 'destroy':
+                ioHost.currentAction = 'destroy';
+                return cli.destroy({
+                    selector,
+                    exclusively: args.exclusively,
+                    force: args.force,
+                    roleArn: args.roleArn,
+                    concurrency: args.concurrency,
+                });
+            case 'gc':
+                ioHost.currentAction = 'gc';
+                if (!configuration.settings.get(['unstable']).includes('gc')) {
+                    throw new toolkit_lib_1.ToolkitError('UnstableGc', 'Unstable feature use: \'gc\' is unstable. It must be opted in via \'--unstable\', e.g. \'cdk gc --unstable=gc\'');
+                }
+                if (args.bootstrapStackName) {
+                    await ioHost.defaults.warn('--bootstrap-stack-name is deprecated and will be removed when gc is GA. Use --toolkit-stack-name.');
+                }
+                // roleArn is defined for when cloudformation is invoked
+                // This conflicts with direct sdk calls existing in the gc command to s3 and ecr
+                if (args.roleArn) {
+                    await ioHost.defaults.warn('The --role-arn option is not supported for the gc command and will be ignored.');
+                }
+                return cli.garbageCollect(args.ENVIRONMENTS, {
+                    action: args.action,
+                    type: args.type,
+                    rollbackBufferDays: args['rollback-buffer-days'],
+                    createdBufferDays: args['created-buffer-days'],
+                    bootstrapStackName: args.toolkitStackName ?? args.bootstrapStackName,
+                    confirm: args.confirm,
+                });
+            case 'flags':
+                ioHost.currentAction = 'flags';
+                if (!configuration.settings.get(['unstable']).includes('flags')) {
+                    throw new toolkit_lib_1.ToolkitError('UnstableFlags', 'Unstable feature use: \'flags\' is unstable. It must be opted in via \'--unstable\', e.g. \'cdk flags --unstable=flags\'');
+                }
+                const toolkit = new toolkit_lib_1.Toolkit({
+                    ioHost,
+                    toolkitStackName,
+                    unstableFeatures: configuration.settings.get(['unstable']),
+                });
+                const flagsData = await toolkit.flags(cloudExecutable);
+                const handler = new flags_1.FlagCommandHandler(flagsData, ioHelper, args, toolkit, configuration.context.all);
+                return handler.processFlagsCommand();
+            case 'synthesize':
+            case 'synth':
+                ioHost.currentAction = 'synth';
+                const quiet = configuration.settings.get(['quiet']) ?? args.quiet;
+                if (args.exclusively) {
+                    return cli.synth(args.STACKS, args.exclusively, quiet, args.validation, argv.json);
+                }
+                else {
+                    return cli.synth(args.STACKS, true, quiet, args.validation, argv.json);
+                }
+            case 'notices':
+                ioHost.currentAction = 'notices';
+                // If the user explicitly asks for notices, they are now the primary output
+                // of the command and they should go to stdout.
+                ioHost.noticesDestination = 'stdout';
+                // This is a valid command, but we're postponing its execution because displaying
+                // notices automatically happens after every command.
+                return;
+            case 'metadata':
+                ioHost.currentAction = 'metadata';
+                return cli.metadata(args.STACK, argv.json);
+            case 'acknowledge':
+            case 'ack':
+                ioHost.currentAction = 'notices';
+                return cli.acknowledge(args.ID);
+            case 'cli-telemetry':
+                ioHost.currentAction = 'cli-telemetry';
+                if (args.enable === undefined && args.disable === undefined && args.status === undefined) {
+                    throw new toolkit_lib_1.ToolkitError('TelemetryArgRequired', 'Must specify \'--enable\', \'--disable\', or \'--status\'');
+                }
+                if (args.status) {
+                    return cli.cliTelemetryStatus(args);
+                }
+                else {
+                    const enable = args.enable ?? !args.disable;
+                    return cli.cliTelemetry(enable);
+                }
+            case 'init':
+                ioHost.currentAction = 'init';
+                const language = configuration.settings.get(['language']);
+                if (args.list) {
+                    return (0, init_1.printAvailableTemplates)(ioHelper, language);
+                }
+                else {
+                    // Gate custom template support with unstable flag
+                    if (args['from-path'] && !configuration.settings.get(['unstable']).includes('init')) {
+                        throw new toolkit_lib_1.ToolkitError('UnstableInit', 'Unstable feature use: \'init\' with custom templates is unstable. It must be opted in via \'--unstable\', e.g. \'cdk init --from-path=./my-template --unstable=init\'');
+                    }
+                    return (0, init_1.cliInit)({
+                        ioHelper,
+                        type: args.TEMPLATE,
+                        language,
+                        canUseNetwork: undefined,
+                        generateOnly: args.generateOnly,
+                        libVersion: args.libVersion,
+                        fromPath: args['from-path'],
+                        templatePath: args['template-path'],
+                        packageManager: args['package-manager'],
+                        projectName: args.name,
+                    });
+                }
+            case 'migrate':
+                ioHost.currentAction = 'migrate';
+                return cli.migrate({
+                    stackName: args['stack-name'],
+                    fromPath: args['from-path'],
+                    fromStack: args['from-stack'],
+                    language: args.language,
+                    outputPath: args['output-path'],
+                    fromScan: (0, migrate_1.getMigrateScanType)(args['from-scan']),
+                    filter: args.filter,
+                    account: args.account,
+                    region: args.region,
+                    compress: args.compress,
+                });
+            case 'version':
+                ioHost.currentAction = 'version';
+                return ioHost.defaults.result((0, version_1.versionWithBuild)());
+            default:
+                throw new toolkit_lib_1.ToolkitError('UnknownCommand', 'Unknown command: ' + command);
+        }
+    }
+}
+/**
+ * Determine which version of bootstrapping
+ */
+async function determineBootstrapVersion(ioHost, args) {
+    let source;
+    if (args.template) {
+        await ioHost.defaults.info(`Using bootstrapping template from ${args.template}`);
+        source = { source: 'custom', templateFile: args.template };
+    }
+    else if (process.env.CDK_LEGACY_BOOTSTRAP) {
+        await ioHost.defaults.info('CDK_LEGACY_BOOTSTRAP set, using legacy-style bootstrapping');
+        source = { source: 'legacy' };
+    }
+    else {
+        // in V2, the "new" bootstrapping is the default
+        source = { source: 'default' };
+    }
+    return source;
+}
+function isFeatureEnabled(configuration, featureFlag) {
+    return configuration.context.get(featureFlag) ?? cxapi.futureFlagDefault(featureFlag);
+}
+/**
+ * Convert a StackSelector and exclusively flag to toolkit-lib's StackSelector format
+ */
+function convertStackSelector(selector, exclusively) {
+    return {
+        patterns: selector.patterns,
+        strategy: selector.patterns.length > 0 ? toolkit_lib_1.StackSelectionStrategy.PATTERN_MATCH : toolkit_lib_1.StackSelectionStrategy.ALL_STACKS,
+        expand: exclusively ? toolkit_lib_1.ExpandStackSelection.NONE : toolkit_lib_1.ExpandStackSelection.UPSTREAM,
+    };
+}
+/**
+ * Translate a Yargs input array to something that makes more sense in a programming language
+ * model (telling the difference between absence and an empty array)
+ *
+ * - An empty array is the default case, meaning the user didn't pass any arguments. We return
+ *   undefined.
+ * - If the user passed a single empty string, they did something like `--array=`, which we'll
+ *   take to mean they passed an empty array.
+ */
+function arrayFromYargs(xs) {
+    if (xs.length === 0) {
+        return undefined;
+    }
+    return xs.filter((x) => x !== '');
+}
+/**
+ * Resolve the diff method from CLI args.
+ * --method takes precedence, then deprecated --change-set, then --template implies template.
+ */
+function determineDiffMethod(args) {
+    if (args.method && args.method !== 'auto') {
+        return args.method;
+    }
+    // Deprecated --no-change-set maps to template
+    if (args['change-set'] === false) {
+        return 'template';
+    }
+    // --template implies template
+    if (args.template) {
+        return 'template';
+    }
+    return 'auto';
+}
+function determineDeploymentMethod(args, configuration, watch) {
+    let deploymentMethod;
+    switch (args.method) {
+        case 'direct':
+            if (args.changeSetName) {
+                throw new toolkit_lib_1.ToolkitError('ChangeSetNameWithDirect', '--change-set-name cannot be used with method=direct');
+            }
+            if (args.importExistingResources) {
+                throw new toolkit_lib_1.ToolkitError('ImportWithDirect', '--import-existing-resources cannot be enabled with method=direct');
+            }
+            if (args.revertDrift) {
+                throw new toolkit_lib_1.ToolkitError('RevertDriftWithDirect', '--revert-drift cannot be used with method=direct');
+            }
+            deploymentMethod = { method: 'direct' };
+            break;
+        case 'change-set':
+            deploymentMethod = {
+                method: 'change-set',
+                execute: true,
+                changeSetName: args.changeSetName,
+                importExistingResources: args.importExistingResources,
+                revertDrift: args.revertDrift,
+            };
+            break;
+        case 'prepare-change-set':
+            deploymentMethod = {
+                method: 'change-set',
+                execute: false,
+                changeSetName: args.changeSetName,
+                importExistingResources: args.importExistingResources,
+                revertDrift: args.revertDrift,
+            };
+            break;
+        case undefined:
+        default:
+            deploymentMethod = {
+                method: 'change-set',
+                execute: watch ? true : args.execute ?? true,
+                changeSetName: args.changeSetName,
+                importExistingResources: args.importExistingResources,
+                revertDrift: args.revertDrift,
+            };
+            break;
+    }
+    const hotswapMode = determineHotswapMode(args.hotswap, args.hotswapFallback, watch);
+    const hotswapProperties = configuration.settings.get(['hotswap']) || {};
+    switch (hotswapMode) {
+        case hotswap_1.HotswapMode.FALL_BACK:
+            return {
+                method: 'hotswap',
+                properties: hotswapProperties,
+                fallback: deploymentMethod,
+            };
+        case hotswap_1.HotswapMode.HOTSWAP_ONLY:
+            return {
+                method: 'hotswap',
+                properties: hotswapProperties,
+            };
+        default:
+        case hotswap_1.HotswapMode.FULL_DEPLOYMENT:
+            return deploymentMethod;
+    }
+}
+function determineHotswapMode(hotswap, hotswapFallback, watch) {
+    if (hotswap && hotswapFallback) {
+        throw new toolkit_lib_1.ToolkitError('ConflictingHotswapArgs', 'Can not supply both --hotswap and --hotswap-fallback at the same time');
+    }
+    else if (!hotswap && !hotswapFallback) {
+        if (hotswap === undefined && hotswapFallback === undefined) {
+            return watch ? hotswap_1.HotswapMode.HOTSWAP_ONLY : hotswap_1.HotswapMode.FULL_DEPLOYMENT;
+        }
+        else if (hotswap === false || hotswapFallback === false) {
+            return hotswap_1.HotswapMode.FULL_DEPLOYMENT;
+        }
+    }
+    let hotswapMode;
+    if (hotswap) {
+        hotswapMode = hotswap_1.HotswapMode.HOTSWAP_ONLY;
+        /* if (hotswapFallback)*/
+    }
+    else {
+        hotswapMode = hotswap_1.HotswapMode.FALL_BACK;
+    }
+    return hotswapMode;
+}
+/* c8 ignore start */ // we never call this in unit tests
+function cli(args = process.argv.slice(2)) {
+    let error;
+    exec(args)
+        .then(async (value) => {
+        if (typeof value === 'number') {
+            process.exitCode = value;
+        }
+    })
+        .catch(async (err) => {
+        // Log the stack trace if we're on a developer workstation. Otherwise this will be into a minified
+        // file and the printed code line and stack trace are huge and useless.
+        (0, pretty_print_error_1.prettyPrintError)(err, (0, version_1.isDeveloperBuildVersion)());
+        error = {
+            name: (0, error_1.cdkCliErrorName)(err),
+        };
+        process.exitCode = 1;
+    })
+        .finally(async () => {
+        try {
+            await io_host_1.CliIoHost.get()?.telemetry?.end(error);
+        }
+        catch (e) {
+            await io_host_1.CliIoHost.get()?.asIoHelper().defaults.trace(`Ending Telemetry failed: ${e.message}`);
+        }
+    });
+}
+/* c8 ignore stop */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["cli.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-shadow */ // yargs\nimport * as cxapi from '@aws-cdk/cx-api';\nimport type { ChangeSetDeployment, DeploymentMethod, DirectDeployment } from '@aws-cdk/toolkit-lib';\nimport { ExpandStackSelection, StackSelectionStrategy, ToolkitError, Toolkit } from '@aws-cdk/toolkit-lib';\nimport * as chalk from 'chalk';\nimport { guessLanguage } from '../util';\nimport { CdkToolkit, AssetBuildTime } from './cdk-toolkit';\nimport { ciSystemIsStdErrSafe } from './ci-systems';\nimport { displayVersionMessage } from './display-version';\nimport type { IoMessageLevel } from './io-host';\nimport { CliIoHost } from './io-host';\nimport { parseCommandLineArguments } from './parse-command-line-arguments';\nimport { checkForPlatformWarnings } from './platform-warnings';\nimport { prettyPrintError } from './pretty-print-error';\nimport { ProxyAgentProvider } from './proxy-agent';\nimport { GLOBAL_PLUGIN_HOST } from './singleton-plugin-host';\nimport { cdkCliErrorName } from './telemetry/error';\nimport type { ErrorDetails } from './telemetry/schema';\nimport type { Command } from './user-configuration';\nimport { Configuration } from './user-configuration';\nimport { trapErrors } from './util/trap-errors';\nimport { isDeveloperBuildVersion, versionWithBuild, versionNumber } from './version';\nimport { asIoHelper } from '../../lib/api-private';\nimport type { IReadLock } from '../api';\nimport { ToolkitInfo, Notices, loadTree, findConstructLibraryVersion } from '../api';\nimport { SdkProvider, IoHostSdkLogger, setSdkTracing, sdkRequestHandler } from '../api/aws-auth';\nimport type { BootstrapSource } from '../api/bootstrap';\nimport { Bootstrapper } from '../api/bootstrap';\nimport { Deployments } from '../api/deployments';\nimport { HotswapMode } from '../api/hotswap';\nimport type { Settings } from '../api/settings';\nimport { contextHandler as context } from '../commands/context';\nimport { docs } from '../commands/docs';\nimport { doctor } from '../commands/doctor';\nimport { FlagCommandHandler } from '../commands/flags/flags';\nimport { cliInit, printAvailableTemplates } from '../commands/init';\nimport { getLanguageFromAlias } from '../commands/language';\nimport { getMigrateScanType } from '../commands/migrate';\nimport { execProgram, CloudExecutable } from '../cxapp';\nimport type { StackSelector, Synthesizer } from '../cxapp';\nimport { isCI } from './util/ci';\nimport { guessAgent } from './util/guess-agent';\n\nexport async function exec(args: string[], synthesizer?: Synthesizer): Promise<number | void> {\n  const argv = await parseCommandLineArguments(args);\n  argv.language = getLanguageFromAlias(argv.language) ?? argv.language;\n\n  // Handle color output settings\n  // Priority: --no-color > --color > TTY detection\n  if (argv.noColor) {\n    process.env.FORCE_COLOR = '0';\n  } else if (argv.color) {\n    process.env.FORCE_COLOR = '3';\n  } else if (!process.stdout.isTTY) {\n    // Default behavior: disable colors for non-TTY\n    process.env.FORCE_COLOR = '0';\n  }\n\n  const cmd = argv._[0];\n\n  // if one -v, log at a DEBUG level\n  // if 2 -v, log at a TRACE level\n  let ioMessageLevel: IoMessageLevel = 'info';\n  if (argv.verbose) {\n    switch (argv.verbose) {\n      case 1:\n        ioMessageLevel = 'debug';\n        break;\n      case 2:\n      default:\n        ioMessageLevel = 'trace';\n        break;\n    }\n  }\n\n  const ioHost = CliIoHost.instance({\n    logLevel: ioMessageLevel,\n    isTTY: process.stdout.isTTY,\n    isCI: Boolean(argv.ci),\n    currentAction: cmd,\n    stackProgress: argv.progress,\n    autoRespond: argv.yes,\n  }, true);\n  const ioHelper = asIoHelper(ioHost, ioHost.currentAction as any);\n\n  // Debug should always imply tracing\n  setSdkTracing(argv.debug || argv.verbose > 2);\n\n  try {\n    await checkForPlatformWarnings(ioHelper);\n  } catch (e) {\n    await ioHost.defaults.debug(`Error while checking for platform warnings: ${e}`);\n  }\n\n  await ioHost.defaults.debug('CDK Toolkit CLI version:', versionWithBuild());\n  await ioHost.defaults.debug('Command line arguments:', argv);\n\n  const configuration = await Configuration.fromArgsAndFiles(ioHelper,\n    {\n      commandLineArguments: {\n        ...argv,\n        _: argv._ as [Command, ...string[]], // TypeScript at its best\n      },\n    });\n\n  // Always create and use ProxyAgent to support configuration via env vars\n  const proxyAgent = await new ProxyAgentProvider(ioHelper).create({\n    proxyAddress: configuration.settings.get(['proxy']),\n    caBundlePath: configuration.settings.get(['caBundlePath']),\n  });\n\n  try {\n    await ioHost.startTelemetry(argv, configuration.context);\n  } catch (e: any) {\n    await ioHost.asIoHelper().defaults.trace(`Telemetry instantiation failed: ${e.message}`);\n  }\n\n  ioHost.telemetry?.attachLanguage(await guessLanguage(process.cwd()));\n  ioHost.telemetry?.attachAgent(guessAgent());\n\n  /**\n   * The default value for displaying (and refreshing) notices on all commands.\n   *\n   * If the user didn't supply either `--notices` or `--no-notices`, we do\n   * autodetection. The autodetection currently is: do write notices if we are\n   * not on CI, or are on a CI system where we know that writing to stderr is\n   * safe. We fail \"closed\"; that is, we decide to NOT print for unknown CI\n   * systems, even though technically we maybe could.\n   */\n  const isSafeToWriteNotices = !isCI() || Boolean(ciSystemIsStdErrSafe());\n\n  // Determine if notices should be displayed based on CLI args and configuration\n  let shouldDisplayNotices: boolean;\n  if (argv.notices !== undefined) {\n    // CLI argument takes precedence\n    shouldDisplayNotices = argv.notices;\n  } else {\n    // Fall back to configuration file setting, then autodetection\n    const configNotices = configuration.settings.get(['notices']);\n    if (configNotices !== undefined) {\n      // Consider string \"false\" to be falsy in this context\n      shouldDisplayNotices = configNotices !== 'false' && Boolean(configNotices);\n    } else {\n      // Default autodetection behavior\n      shouldDisplayNotices = isSafeToWriteNotices;\n    }\n  }\n\n  // Notices either go to stderr, or nowhere\n  ioHost.noticesDestination = shouldDisplayNotices ? 'stderr' : 'drop';\n  const notices = Notices.create({\n    ioHost,\n    context: configuration.context,\n    output: configuration.settings.get(['outdir']),\n    language: await guessLanguage(process.cwd()),\n    httpOptions: { agent: proxyAgent },\n    cliVersion: versionNumber(),\n  });\n  const refreshNotices = (async () => {\n    // the cdk notices command has it's own refresh\n    if (shouldDisplayNotices && cmd !== 'notices') {\n      await trapErrors(ioHelper, 'Could not refresh notices', () => notices.refresh());\n    }\n  })();\n\n  const sdkProvider = await SdkProvider.withAwsCliCompatibleDefaults({\n    ioHelper,\n    requestHandler: sdkRequestHandler(proxyAgent),\n    logger: new IoHostSdkLogger(asIoHelper(ioHost, ioHost.currentAction as any)),\n    pluginHost: GLOBAL_PLUGIN_HOST,\n  }, configuration.settings.get(['profile']));\n\n  try {\n    await ioHost.telemetry?.attachRegion(sdkProvider.defaultRegion);\n  } catch (e: any) {\n    await ioHost.asIoHelper().defaults.trace(`Telemetry attach region failed: ${e.message}`);\n  }\n\n  let outDirLock: IReadLock | undefined;\n  const cloudExecutable = new CloudExecutable({\n    configuration,\n    sdkProvider,\n    synthesizer:\n      synthesizer ??\n      (async (aws, config) => {\n        // Invoke 'execProgram', and copy the lock for the directory in the global\n        // variable here. It will be released when the CLI exits. Locks are not re-entrant\n        // so release it if we have to synthesize more than once (because of context lookups).\n        await outDirLock?.release();\n        const { assembly, lock } = await execProgram(aws, ioHost.asIoHelper(), config);\n        outDirLock = lock;\n\n        const tree = await loadTree(assembly, ioHelper.defaults.trace.bind(ioHelper.defaults));\n        if (tree) {\n          const v = findConstructLibraryVersion(tree);\n          if (v) {\n            ioHost.telemetry?.attachCdkLibVersion(v);\n          }\n        }\n\n        return assembly;\n      }),\n    ioHelper: ioHost.asIoHelper(),\n  });\n\n  /** Function to load plug-ins, using configurations additively. */\n  async function loadPlugins(...settings: Settings[]) {\n    for (const source of settings) {\n      const plugins: string[] = source.get(['plugin']) || [];\n      for (const plugin of plugins) {\n        await GLOBAL_PLUGIN_HOST.load(plugin, ioHost);\n      }\n    }\n  }\n\n  await loadPlugins(configuration.settings);\n\n  if ((typeof cmd) !== 'string') {\n    throw new ToolkitError('InvalidArgType', `First argument should be a string. Got: ${cmd} (${typeof cmd})`);\n  }\n\n  try {\n    return await main(cmd, argv);\n  } finally {\n    // If we locked the 'cdk.out' directory, release it here.\n    await outDirLock?.release();\n\n    // Do PSAs here\n    await displayVersionMessage(ioHelper);\n\n    await refreshNotices;\n    if (cmd === 'notices') {\n      // do not trap errors here\n      // this is the notices command itself, any error should be loud\n      await notices.refresh({ force: true });\n      await notices.display({\n        includeAcknowledged: !argv.unacknowledged,\n        showTotal: argv.unacknowledged,\n      });\n    } else if (shouldDisplayNotices && cmd !== 'version') {\n      await trapErrors(ioHelper, 'Could not display notices', () => notices.display());\n    }\n  }\n\n  async function main(command: string, args: any): Promise<number | void> {\n    ioHost.currentAction = command as any;\n    const toolkitStackName: string = ToolkitInfo.determineName(configuration.settings.get(['toolkitStackName']));\n    await ioHost.defaults.debug(`Toolkit stack: ${chalk.bold(toolkitStackName)}`);\n\n    const cloudFormation = new Deployments({\n      sdkProvider,\n      toolkitStackName,\n      ioHelper: asIoHelper(ioHost, ioHost.currentAction as any),\n    });\n\n    if (args.all && args.STACKS) {\n      throw new ToolkitError('StacksOrAllRequired', 'You must either specify a list of Stacks or the `--all` argument');\n    }\n\n    args.STACKS = args.STACKS ?? (args.STACK ? [args.STACK] : []);\n    args.ENVIRONMENTS = args.ENVIRONMENTS ?? [];\n\n    const selector: StackSelector = {\n      allTopLevel: args.all,\n      patterns: args.STACKS,\n    };\n\n    const cli = new CdkToolkit({\n      ioHost,\n      cloudExecutable,\n      toolkitStackName,\n      deployments: cloudFormation,\n      verbose: argv.trace || argv.verbose > 0,\n      ignoreErrors: argv['ignore-errors'],\n      strict: argv.strict,\n      configuration,\n      sdkProvider,\n    });\n\n    switch (command) {\n      case 'context':\n        ioHost.currentAction = 'context';\n        return context({\n          ioHelper,\n          context: configuration.context,\n          clear: argv.clear,\n          json: argv.json,\n          force: argv.force,\n          reset: argv.reset,\n        });\n\n      case 'docs':\n      case 'doc':\n        ioHost.currentAction = 'docs';\n        return docs({\n          ioHelper,\n          browser: configuration.settings.get(['browser']),\n        });\n\n      case 'doctor':\n        ioHost.currentAction = 'doctor';\n        return doctor({\n          ioHelper,\n        });\n\n      case 'ls':\n      case 'list':\n        ioHost.currentAction = 'list';\n        return cli.list(args.STACKS, {\n          long: args.long,\n          json: argv.json,\n          showDeps: args.showDependencies,\n        });\n\n      case 'diff':\n        ioHost.currentAction = 'diff';\n        const enableDiffNoFail = isFeatureEnabled(configuration, cxapi.ENABLE_DIFF_NO_FAIL_CONTEXT);\n        return cli.diff({\n          stackNames: args.STACKS,\n          exclusively: args.exclusively,\n          templatePath: args.template,\n          strict: args.strict,\n          contextLines: args.contextLines,\n          securityOnly: args.securityOnly,\n          fail: args.fail != null ? args.fail : !enableDiffNoFail,\n          compareAgainstProcessedTemplate: args.processed,\n          quiet: args.quiet,\n          method: determineDiffMethod(args),\n          toolkitStackName: toolkitStackName,\n          importExistingResources: args.importExistingResources,\n          includeMoves: args['include-moves'],\n        });\n\n      case 'drift':\n        ioHost.currentAction = 'drift';\n        return cli.drift({\n          selector,\n          fail: args.fail,\n        });\n\n      case 'refactor':\n        if (!configuration.settings.get(['unstable']).includes('refactor')) {\n          throw new ToolkitError('UnstableRefactor', 'Unstable feature use: \\'refactor\\' is unstable. It must be opted in via \\'--unstable\\', e.g. \\'cdk refactor --unstable=refactor\\'');\n        }\n\n        ioHost.currentAction = 'refactor';\n        return cli.refactor({\n          dryRun: args.dryRun,\n          overrideFile: args.overrideFile,\n          revert: args.revert,\n          stacks: selector,\n          additionalStackNames: arrayFromYargs(args.additionalStackName ?? []),\n          force: args.force ?? false,\n          roleArn: args.roleArn,\n        });\n\n      case 'bootstrap':\n        ioHost.currentAction = 'bootstrap';\n        const source: BootstrapSource = await determineBootstrapVersion(ioHost, args);\n\n        if (args.showTemplate) {\n          const bootstrapper = new Bootstrapper(source, asIoHelper(ioHost, ioHost.currentAction));\n          return bootstrapper.showTemplate(args.json);\n        }\n\n        return cli.bootstrap(args.ENVIRONMENTS, {\n          source,\n          roleArn: args.roleArn,\n          forceDeployment: argv.force,\n          toolkitStackName: toolkitStackName,\n          execute: args.execute,\n          tags: configuration.settings.get(['tags']),\n          terminationProtection: args.terminationProtection,\n          usePreviousParameters: args['previous-parameters'],\n          parameters: {\n            bucketName: configuration.settings.get(['toolkitBucket', 'bucketName']),\n            kmsKeyId: configuration.settings.get(['toolkitBucket', 'kmsKeyId']),\n            createCustomerMasterKey: args.bootstrapCustomerKey,\n            qualifier: args.qualifier ?? configuration.context.get('@aws-cdk/core:bootstrapQualifier'),\n            publicAccessBlockConfiguration: args.publicAccessBlockConfiguration,\n            examplePermissionsBoundary: argv.examplePermissionsBoundary,\n            customPermissionsBoundary: argv.customPermissionsBoundary,\n            trustedAccounts: arrayFromYargs(args.trust),\n            trustedAccountsForLookup: arrayFromYargs(args.trustForLookup),\n            untrustedAccounts: arrayFromYargs(args.untrust),\n            cloudFormationExecutionPolicies: arrayFromYargs(args.cloudformationExecutionPolicies),\n            denyExternalId: args.denyExternalId,\n          },\n        });\n\n      case 'deploy':\n        ioHost.currentAction = 'deploy';\n        const parameterMap: { [name: string]: string | undefined } = {};\n        for (const parameter of args.parameters) {\n          if (typeof parameter === 'string') {\n            const keyValue = (parameter as string).split('=');\n            parameterMap[keyValue[0]] = keyValue.slice(1).join('=');\n          }\n        }\n\n        if (args.execute !== undefined && args.method !== undefined) {\n          throw new ToolkitError('ConflictingExecuteAndMethod', 'Can not supply both --[no-]execute and --method at the same time');\n        }\n\n        return cli.deploy({\n          selector,\n          exclusively: args.exclusively,\n          toolkitStackName,\n          roleArn: args.roleArn,\n          notificationArns: args.notificationArns,\n          requireApproval: configuration.settings.get(['requireApproval']),\n          reuseAssets: args['build-exclude'],\n          tags: configuration.settings.get(['tags']),\n          deploymentMethod: determineDeploymentMethod(args, configuration),\n          force: args.force,\n          parameters: parameterMap,\n          usePreviousParameters: args['previous-parameters'],\n          outputsFile: configuration.settings.get(['outputsFile']),\n          progress: configuration.settings.get(['progress']),\n          ci: args.ci,\n          rollback: configuration.settings.get(['rollback']),\n          watch: args.watch,\n          traceLogs: args.logs,\n          concurrency: args.concurrency,\n          assetParallelism: configuration.settings.get(['assetParallelism']),\n          assetBuildConcurrency: configuration.settings.get(['assetBuildConcurrency']),\n          assetBuildTime: configuration.settings.get(['assetPrebuild'])\n            ? AssetBuildTime.ALL_BEFORE_DEPLOY\n            : AssetBuildTime.JUST_IN_TIME,\n          ignoreNoStacks: args.ignoreNoStacks,\n        });\n\n      case 'rollback':\n        ioHost.currentAction = 'rollback';\n        return cli.rollback({\n          selector,\n          toolkitStackName,\n          roleArn: args.roleArn,\n          force: args.force,\n          validateBootstrapStackVersion: args['validate-bootstrap-version'],\n          orphanLogicalIds: args.orphan,\n        });\n\n      case 'publish-assets':\n        ioHost.currentAction = 'publish-assets';\n        if (!configuration.settings.get(['unstable']).includes('publish-assets')) {\n          throw new ToolkitError('UnstablePublishAssets', 'Unstable feature use: \\'publish-assets\\' is unstable. It must be opted in via \\'--unstable\\', e.g. \\'cdk publish-assets --unstable=publish-assets\\'');\n        }\n        return cli.publishAssets({\n          stacks: convertStackSelector(selector, args.exclusively),\n          force: args.force,\n          concurrency: args.concurrency,\n        });\n\n      case 'import':\n        ioHost.currentAction = 'import';\n        return cli.import({\n          selector,\n          toolkitStackName,\n          roleArn: args.roleArn,\n          deploymentMethod: {\n            method: 'change-set',\n            execute: args.execute,\n            changeSetName: args.changeSetName,\n          },\n          progress: configuration.settings.get(['progress']),\n          rollback: configuration.settings.get(['rollback']),\n          recordResourceMapping: args['record-resource-mapping'],\n          resourceMappingFile: args['resource-mapping'],\n          force: args.force,\n        });\n\n      case 'watch':\n        ioHost.currentAction = 'watch';\n        await cli.watch({\n          selector,\n          exclusively: args.exclusively,\n          toolkitStackName,\n          roleArn: args.roleArn,\n          reuseAssets: args['build-exclude'],\n          deploymentMethod: determineDeploymentMethod(args, configuration, true),\n          force: args.force,\n          progress: configuration.settings.get(['progress']),\n          rollback: configuration.settings.get(['rollback']),\n          traceLogs: args.logs,\n          concurrency: args.concurrency,\n        });\n        return;\n\n      case 'destroy':\n        ioHost.currentAction = 'destroy';\n        return cli.destroy({\n          selector,\n          exclusively: args.exclusively,\n          force: args.force,\n          roleArn: args.roleArn,\n          concurrency: args.concurrency,\n        });\n\n      case 'gc':\n        ioHost.currentAction = 'gc';\n        if (!configuration.settings.get(['unstable']).includes('gc')) {\n          throw new ToolkitError('UnstableGc', 'Unstable feature use: \\'gc\\' is unstable. It must be opted in via \\'--unstable\\', e.g. \\'cdk gc --unstable=gc\\'');\n        }\n        if (args.bootstrapStackName) {\n          await ioHost.defaults.warn('--bootstrap-stack-name is deprecated and will be removed when gc is GA. Use --toolkit-stack-name.');\n        }\n        // roleArn is defined for when cloudformation is invoked\n        // This conflicts with direct sdk calls existing in the gc command to s3 and ecr\n        if (args.roleArn) {\n          await ioHost.defaults.warn('The --role-arn option is not supported for the gc command and will be ignored.');\n        }\n        return cli.garbageCollect(args.ENVIRONMENTS, {\n          action: args.action,\n          type: args.type,\n          rollbackBufferDays: args['rollback-buffer-days'],\n          createdBufferDays: args['created-buffer-days'],\n          bootstrapStackName: args.toolkitStackName ?? args.bootstrapStackName,\n          confirm: args.confirm,\n        });\n\n      case 'flags':\n        ioHost.currentAction = 'flags';\n\n        if (!configuration.settings.get(['unstable']).includes('flags')) {\n          throw new ToolkitError('UnstableFlags', 'Unstable feature use: \\'flags\\' is unstable. It must be opted in via \\'--unstable\\', e.g. \\'cdk flags --unstable=flags\\'');\n        }\n        const toolkit = new Toolkit({\n          ioHost,\n          toolkitStackName,\n          unstableFeatures: configuration.settings.get(['unstable']),\n        });\n        const flagsData = await toolkit.flags(cloudExecutable);\n        const handler = new FlagCommandHandler(flagsData, ioHelper, args, toolkit, configuration.context.all);\n        return handler.processFlagsCommand();\n\n      case 'synthesize':\n      case 'synth':\n        ioHost.currentAction = 'synth';\n        const quiet = configuration.settings.get(['quiet']) ?? args.quiet;\n        if (args.exclusively) {\n          return cli.synth(args.STACKS, args.exclusively, quiet, args.validation, argv.json);\n        } else {\n          return cli.synth(args.STACKS, true, quiet, args.validation, argv.json);\n        }\n\n      case 'notices':\n        ioHost.currentAction = 'notices';\n        // If the user explicitly asks for notices, they are now the primary output\n        // of the command and they should go to stdout.\n        ioHost.noticesDestination = 'stdout';\n\n        // This is a valid command, but we're postponing its execution because displaying\n        // notices automatically happens after every command.\n        return;\n\n      case 'metadata':\n        ioHost.currentAction = 'metadata';\n        return cli.metadata(args.STACK, argv.json);\n\n      case 'acknowledge':\n      case 'ack':\n        ioHost.currentAction = 'notices';\n        return cli.acknowledge(args.ID);\n\n      case 'cli-telemetry':\n        ioHost.currentAction = 'cli-telemetry';\n        if (args.enable === undefined && args.disable === undefined && args.status === undefined) {\n          throw new ToolkitError('TelemetryArgRequired', 'Must specify \\'--enable\\', \\'--disable\\', or \\'--status\\'');\n        }\n\n        if (args.status) {\n          return cli.cliTelemetryStatus(args);\n        } else {\n          const enable = args.enable ?? !args.disable;\n          return cli.cliTelemetry(enable);\n        }\n      case 'init':\n        ioHost.currentAction = 'init';\n        const language = configuration.settings.get(['language']);\n        if (args.list) {\n          return printAvailableTemplates(ioHelper, language);\n        } else {\n          // Gate custom template support with unstable flag\n          if (args['from-path'] && !configuration.settings.get(['unstable']).includes('init')) {\n            throw new ToolkitError('UnstableInit', 'Unstable feature use: \\'init\\' with custom templates is unstable. It must be opted in via \\'--unstable\\', e.g. \\'cdk init --from-path=./my-template --unstable=init\\'');\n          }\n          return cliInit({\n            ioHelper,\n            type: args.TEMPLATE,\n            language,\n            canUseNetwork: undefined,\n            generateOnly: args.generateOnly,\n            libVersion: args.libVersion,\n            fromPath: args['from-path'],\n            templatePath: args['template-path'],\n            packageManager: args['package-manager'],\n            projectName: args.name,\n          });\n        }\n      case 'migrate':\n        ioHost.currentAction = 'migrate';\n        return cli.migrate({\n          stackName: args['stack-name'],\n          fromPath: args['from-path'],\n          fromStack: args['from-stack'],\n          language: args.language,\n          outputPath: args['output-path'],\n          fromScan: getMigrateScanType(args['from-scan']),\n          filter: args.filter,\n          account: args.account,\n          region: args.region,\n          compress: args.compress,\n        });\n      case 'version':\n        ioHost.currentAction = 'version';\n        return ioHost.defaults.result(versionWithBuild());\n\n      default:\n        throw new ToolkitError('UnknownCommand', 'Unknown command: ' + command);\n    }\n  }\n}\n\n/**\n * Determine which version of bootstrapping\n */\nasync function determineBootstrapVersion(ioHost: CliIoHost, args: { template?: string }): Promise<BootstrapSource> {\n  let source: BootstrapSource;\n  if (args.template) {\n    await ioHost.defaults.info(`Using bootstrapping template from ${args.template}`);\n    source = { source: 'custom', templateFile: args.template };\n  } else if (process.env.CDK_LEGACY_BOOTSTRAP) {\n    await ioHost.defaults.info('CDK_LEGACY_BOOTSTRAP set, using legacy-style bootstrapping');\n    source = { source: 'legacy' };\n  } else {\n    // in V2, the \"new\" bootstrapping is the default\n    source = { source: 'default' };\n  }\n  return source;\n}\n\nfunction isFeatureEnabled(configuration: Configuration, featureFlag: string) {\n  return configuration.context.get(featureFlag) ?? cxapi.futureFlagDefault(featureFlag);\n}\n\n/**\n * Convert a StackSelector and exclusively flag to toolkit-lib's StackSelector format\n */\nfunction convertStackSelector(selector: StackSelector, exclusively?: boolean) {\n  return {\n    patterns: selector.patterns,\n    strategy: selector.patterns.length > 0 ? StackSelectionStrategy.PATTERN_MATCH : StackSelectionStrategy.ALL_STACKS,\n    expand: exclusively ? ExpandStackSelection.NONE : ExpandStackSelection.UPSTREAM,\n  };\n}\n\n/**\n * Translate a Yargs input array to something that makes more sense in a programming language\n * model (telling the difference between absence and an empty array)\n *\n * - An empty array is the default case, meaning the user didn't pass any arguments. We return\n *   undefined.\n * - If the user passed a single empty string, they did something like `--array=`, which we'll\n *   take to mean they passed an empty array.\n */\nfunction arrayFromYargs(xs: string[]): string[] | undefined {\n  if (xs.length === 0) {\n    return undefined;\n  }\n  return xs.filter((x) => x !== '');\n}\n\n/**\n * Resolve the diff method from CLI args.\n * --method takes precedence, then deprecated --change-set, then --template implies template.\n */\nfunction determineDiffMethod(args: any): 'change-set' | 'template' | 'auto' {\n  if (args.method && args.method !== 'auto') {\n    return args.method;\n  }\n\n  // Deprecated --no-change-set maps to template\n  if (args['change-set'] === false) {\n    return 'template';\n  }\n\n  // --template implies template\n  if (args.template) {\n    return 'template';\n  }\n\n  return 'auto';\n}\n\nfunction determineDeploymentMethod(args: any, configuration: Configuration, watch?: boolean): DeploymentMethod {\n  let deploymentMethod: ChangeSetDeployment | DirectDeployment | undefined;\n  switch (args.method) {\n    case 'direct':\n      if (args.changeSetName) {\n        throw new ToolkitError('ChangeSetNameWithDirect', '--change-set-name cannot be used with method=direct');\n      }\n      if (args.importExistingResources) {\n        throw new ToolkitError('ImportWithDirect', '--import-existing-resources cannot be enabled with method=direct');\n      }\n      if (args.revertDrift) {\n        throw new ToolkitError('RevertDriftWithDirect', '--revert-drift cannot be used with method=direct');\n      }\n      deploymentMethod = { method: 'direct' };\n      break;\n    case 'change-set':\n      deploymentMethod = {\n        method: 'change-set',\n        execute: true,\n        changeSetName: args.changeSetName,\n        importExistingResources: args.importExistingResources,\n        revertDrift: args.revertDrift,\n      };\n      break;\n    case 'prepare-change-set':\n      deploymentMethod = {\n        method: 'change-set',\n        execute: false,\n        changeSetName: args.changeSetName,\n        importExistingResources: args.importExistingResources,\n        revertDrift: args.revertDrift,\n      };\n      break;\n    case undefined:\n    default:\n      deploymentMethod = {\n        method: 'change-set',\n        execute: watch ? true : args.execute ?? true,\n        changeSetName: args.changeSetName,\n        importExistingResources: args.importExistingResources,\n        revertDrift: args.revertDrift,\n      };\n      break;\n  }\n\n  const hotswapMode = determineHotswapMode(args.hotswap, args.hotswapFallback, watch);\n  const hotswapProperties = configuration.settings.get(['hotswap']) || {};\n  switch (hotswapMode) {\n    case HotswapMode.FALL_BACK:\n      return {\n        method: 'hotswap',\n        properties: hotswapProperties,\n        fallback: deploymentMethod,\n      };\n    case HotswapMode.HOTSWAP_ONLY:\n      return {\n        method: 'hotswap',\n        properties: hotswapProperties,\n      };\n    default:\n    case HotswapMode.FULL_DEPLOYMENT:\n      return deploymentMethod;\n  }\n}\n\nfunction determineHotswapMode(hotswap?: boolean, hotswapFallback?: boolean, watch?: boolean): HotswapMode {\n  if (hotswap && hotswapFallback) {\n    throw new ToolkitError('ConflictingHotswapArgs', 'Can not supply both --hotswap and --hotswap-fallback at the same time');\n  } else if (!hotswap && !hotswapFallback) {\n    if (hotswap === undefined && hotswapFallback === undefined) {\n      return watch ? HotswapMode.HOTSWAP_ONLY : HotswapMode.FULL_DEPLOYMENT;\n    } else if (hotswap === false || hotswapFallback === false) {\n      return HotswapMode.FULL_DEPLOYMENT;\n    }\n  }\n\n  let hotswapMode: HotswapMode;\n  if (hotswap) {\n    hotswapMode = HotswapMode.HOTSWAP_ONLY;\n    /* if (hotswapFallback)*/\n  } else {\n    hotswapMode = HotswapMode.FALL_BACK;\n  }\n\n  return hotswapMode;\n}\n\n/* c8 ignore start */ // we never call this in unit tests\nexport function cli(args: string[] = process.argv.slice(2)) {\n  let error: ErrorDetails | undefined;\n  exec(args)\n    .then(async (value) => {\n      if (typeof value === 'number') {\n        process.exitCode = value;\n      }\n    })\n    .catch(async (err) => {\n      // Log the stack trace if we're on a developer workstation. Otherwise this will be into a minified\n      // file and the printed code line and stack trace are huge and useless.\n      prettyPrintError(err, isDeveloperBuildVersion());\n      error = {\n        name: cdkCliErrorName(err),\n      };\n      process.exitCode = 1;\n    })\n    .finally(async () => {\n      try {\n        await CliIoHost.get()?.telemetry?.end(error);\n      } catch (e: any) {\n        await CliIoHost.get()?.asIoHelper().defaults.trace(`Ending Telemetry failed: ${e.message}`);\n      }\n    });\n}\n/* c8 ignore stop */\n"]}