aws-cdk 0.0.0

package/lib/cli/cli.js

@@ -0,0 +1,538 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exec = exec;
+exports.cli = cli;
+const cxapi = require("@aws-cdk/cx-api");
+require("@jsii/check-node/run");
+const chalk = require("chalk");
+const cdk_toolkit_1 = require("./cdk-toolkit");
+const parse_command_line_arguments_1 = require("./parse-command-line-arguments");
+const platform_warnings_1 = require("./platform-warnings");
+const version = require("./version");
+const aws_auth_1 = require("../api/aws-auth");
+const sdk_logger_1 = require("../api/aws-auth/sdk-logger");
+const tracing_1 = require("../api/aws-auth/tracing");
+const bootstrap_1 = require("../api/bootstrap");
+const cloud_executable_1 = require("../api/cxapp/cloud-executable");
+const exec_1 = require("../api/cxapp/exec");
+const deployments_1 = require("../api/deployments");
+const common_1 = require("../api/hotswap/common");
+const plugin_1 = require("../api/plugin");
+const toolkit_info_1 = require("../api/toolkit-info");
+const context_1 = require("../commands/context");
+const docs_1 = require("../commands/docs");
+const doctor_1 = require("../commands/doctor");
+const migrate_1 = require("../commands/migrate");
+const init_1 = require("../init");
+const logging_1 = require("../logging");
+const notices_1 = require("../notices");
+const user_configuration_1 = require("./user-configuration");
+const cli_io_host_1 = require("../toolkit/cli-io-host");
+const error_1 = require("../toolkit/error");
+/* eslint-disable max-len */
+/* eslint-disable @typescript-eslint/no-shadow */ // yargs
+if (!process.stdout.isTTY) {
+    // Disable chalk color highlighting
+    process.env.FORCE_COLOR = '0';
+}
+async function exec(args, synthesizer) {
+    const argv = await (0, parse_command_line_arguments_1.parseCommandLineArguments)(args);
+    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 = cli_io_host_1.CliIoHost.instance({
+        logLevel: ioMessageLevel,
+        isTTY: process.stdout.isTTY,
+        isCI: Boolean(argv.ci),
+        currentAction: cmd,
+    }, true);
+    // Debug should always imply tracing
+    if (argv.debug || argv.verbose > 2) {
+        (0, tracing_1.setSdkTracing)(true);
+    }
+    else {
+        // cli-lib-alpha needs to explicitly set in case it was enabled before
+        (0, tracing_1.setSdkTracing)(false);
+    }
+    try {
+        await (0, platform_warnings_1.checkForPlatformWarnings)();
+    }
+    catch (e) {
+        (0, logging_1.debug)(`Error while checking for platform warnings: ${e}`);
+    }
+    (0, logging_1.debug)('CDK toolkit version:', version.DISPLAY_VERSION);
+    (0, logging_1.debug)('Command line arguments:', argv);
+    const configuration = new user_configuration_1.Configuration({
+        commandLineArguments: {
+            ...argv,
+            _: argv._, // TypeScript at its best
+        },
+    });
+    await configuration.load();
+    const notices = notices_1.Notices.create({
+        context: configuration.context,
+        output: configuration.settings.get(['outdir']),
+        shouldDisplay: configuration.settings.get(['notices']),
+        includeAcknowledged: cmd === 'notices' ? !argv.unacknowledged : false,
+        httpOptions: {
+            proxyAddress: configuration.settings.get(['proxy']),
+            caBundlePath: configuration.settings.get(['caBundlePath']),
+        },
+    });
+    await notices.refresh();
+    const sdkProvider = await aws_auth_1.SdkProvider.withAwsCliCompatibleDefaults({
+        profile: configuration.settings.get(['profile']),
+        httpOptions: {
+            proxyAddress: argv.proxy,
+            caBundlePath: argv['ca-bundle-path'],
+        },
+        logger: new sdk_logger_1.SdkToCliLogger(ioHost),
+    });
+    let outDirLock;
+    const cloudExecutable = new cloud_executable_1.CloudExecutable({
+        configuration,
+        sdkProvider,
+        synthesizer: synthesizer !== null && synthesizer !== void 0 ? 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 === null || outDirLock === void 0 ? void 0 : outDirLock.release());
+            const { assembly, lock } = await (0, exec_1.execProgram)(aws, config);
+            outDirLock = lock;
+            return assembly;
+        }),
+    });
+    /** Function to load plug-ins, using configurations additively. */
+    function loadPlugins(...settings) {
+        const loaded = new Set();
+        for (const source of settings) {
+            const plugins = source.get(['plugin']) || [];
+            for (const plugin of plugins) {
+                const resolved = tryResolve(plugin);
+                if (loaded.has(resolved)) {
+                    continue;
+                }
+                (0, logging_1.debug)(`Loading plug-in: ${chalk.green(plugin)} from ${chalk.blue(resolved)}`);
+                plugin_1.PluginHost.instance.load(plugin);
+                loaded.add(resolved);
+            }
+        }
+        function tryResolve(plugin) {
+            try {
+                return require.resolve(plugin);
+            }
+            catch (e) {
+                (0, logging_1.error)(`Unable to resolve plugin ${chalk.green(plugin)}: ${e.stack}`);
+                throw new error_1.ToolkitError(`Unable to resolve plug-in: ${plugin}`);
+            }
+        }
+    }
+    loadPlugins(configuration.settings);
+    if (typeof (cmd) !== 'string') {
+        throw new error_1.ToolkitError(`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 === null || outDirLock === void 0 ? void 0 : outDirLock.release());
+        // Do PSAs here
+        await version.displayVersionMessage();
+        if (cmd === 'notices') {
+            await notices.refresh({ force: true });
+            notices.display({ showTotal: argv.unacknowledged });
+        }
+        else if (cmd !== 'version') {
+            await notices.refresh();
+            notices.display();
+        }
+    }
+    async function main(command, args) {
+        var _a, _b, _c, _d, _e;
+        ioHost.currentAction = command;
+        const toolkitStackName = toolkit_info_1.ToolkitInfo.determineName(configuration.settings.get(['toolkitStackName']));
+        (0, logging_1.debug)(`Toolkit stack: ${chalk.bold(toolkitStackName)}`);
+        const cloudFormation = new deployments_1.Deployments({ sdkProvider, toolkitStackName });
+        if (args.all && args.STACKS) {
+            throw new error_1.ToolkitError('You must either specify a list of Stacks or the `--all` argument');
+        }
+        args.STACKS = (_a = args.STACKS) !== null && _a !== void 0 ? _a : (args.STACK ? [args.STACK] : []);
+        args.ENVIRONMENTS = (_b = args.ENVIRONMENTS) !== null && _b !== void 0 ? _b : [];
+        const selector = {
+            allTopLevel: args.all,
+            patterns: args.STACKS,
+        };
+        const cli = new cdk_toolkit_1.CdkToolkit({
+            ioHost,
+            cloudExecutable,
+            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)({
+                    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)({ browser: configuration.settings.get(['browser']) });
+            case 'doctor':
+                ioHost.currentAction = 'doctor';
+                return (0, doctor_1.doctor)();
+            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,
+                    stream: args.ci ? process.stdout : undefined,
+                    compareAgainstProcessedTemplate: args.processed,
+                    quiet: args.quiet,
+                    changeSet: args['change-set'],
+                    toolkitStackName: toolkitStackName,
+                });
+            case 'bootstrap':
+                ioHost.currentAction = 'bootstrap';
+                const source = determineBootstrapVersion(args);
+                if (args.showTemplate) {
+                    const bootstrapper = new bootstrap_1.Bootstrapper(source);
+                    return bootstrapper.showTemplate(args.json);
+                }
+                return cli.bootstrap(args.ENVIRONMENTS, {
+                    source,
+                    roleArn: args.roleArn,
+                    force: 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: (_c = args.qualifier) !== null && _c !== void 0 ? _c : 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),
+                    },
+                });
+            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 error_1.ToolkitError('Can not supply both --[no-]execute and --method at the same time');
+                }
+                let deploymentMethod;
+                switch (args.method) {
+                    case 'direct':
+                        if (args.changeSetName) {
+                            throw new error_1.ToolkitError('--change-set-name cannot be used with method=direct');
+                        }
+                        if (args.importExistingResources) {
+                            throw new error_1.ToolkitError('--import-existing-resources cannot be enabled with method=direct');
+                        }
+                        deploymentMethod = { method: 'direct' };
+                        break;
+                    case 'change-set':
+                        deploymentMethod = {
+                            method: 'change-set',
+                            execute: true,
+                            changeSetName: args.changeSetName,
+                            importExistingResources: args.importExistingResources,
+                        };
+                        break;
+                    case 'prepare-change-set':
+                        deploymentMethod = {
+                            method: 'change-set',
+                            execute: false,
+                            changeSetName: args.changeSetName,
+                            importExistingResources: args.importExistingResources,
+                        };
+                        break;
+                    case undefined:
+                        deploymentMethod = {
+                            method: 'change-set',
+                            execute: (_d = args.execute) !== null && _d !== void 0 ? _d : true,
+                            changeSetName: args.changeSetName,
+                            importExistingResources: args.importExistingResources,
+                        };
+                        break;
+                }
+                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,
+                    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']),
+                    hotswap: determineHotswapMode(args.hotswap, args.hotswapFallback),
+                    watch: args.watch,
+                    traceLogs: args.logs,
+                    concurrency: args.concurrency,
+                    assetParallelism: configuration.settings.get(['assetParallelism']),
+                    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 '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';
+                return cli.watch({
+                    selector,
+                    exclusively: args.exclusively,
+                    toolkitStackName,
+                    roleArn: args.roleArn,
+                    reuseAssets: args['build-exclude'],
+                    deploymentMethod: {
+                        method: 'change-set',
+                        changeSetName: args.changeSetName,
+                    },
+                    force: args.force,
+                    progress: configuration.settings.get(['progress']),
+                    rollback: configuration.settings.get(['rollback']),
+                    hotswap: determineHotswapMode(args.hotswap, args.hotswapFallback, true),
+                    traceLogs: args.logs,
+                    concurrency: args.concurrency,
+                });
+            case 'destroy':
+                ioHost.currentAction = 'destroy';
+                return cli.destroy({
+                    selector,
+                    exclusively: args.exclusively,
+                    force: args.force,
+                    roleArn: args.roleArn,
+                    ci: args.ci,
+                });
+            case 'gc':
+                ioHost.currentAction = 'gc';
+                if (!configuration.settings.get(['unstable']).includes('gc')) {
+                    throw new error_1.ToolkitError('Unstable feature use: \'gc\' is unstable. It must be opted in via \'--unstable\', e.g. \'cdk gc --unstable=gc\'');
+                }
+                return cli.garbageCollect(args.ENVIRONMENTS, {
+                    action: args.action,
+                    type: args.type,
+                    rollbackBufferDays: args['rollback-buffer-days'],
+                    createdBufferDays: args['created-buffer-days'],
+                    bootstrapStackName: args.bootstrapStackName,
+                    confirm: args.confirm,
+                });
+            case 'synthesize':
+            case 'synth':
+                ioHost.currentAction = 'synth';
+                const quiet = (_e = configuration.settings.get(['quiet'])) !== null && _e !== void 0 ? _e : 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';
+                // This is a valid command, but we're postponing its execution
+                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 'init':
+                ioHost.currentAction = 'init';
+                const language = configuration.settings.get(['language']);
+                if (args.list) {
+                    return (0, init_1.printAvailableTemplates)(language);
+                }
+                else {
+                    return (0, init_1.cliInit)({
+                        type: args.TEMPLATE,
+                        language,
+                        canUseNetwork: undefined,
+                        generateOnly: args.generateOnly,
+                    });
+                }
+            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 (0, logging_1.result)(version.DISPLAY_VERSION);
+            default:
+                throw new error_1.ToolkitError('Unknown command: ' + command);
+        }
+    }
+}
+/**
+ * Determine which version of bootstrapping
+ */
+function determineBootstrapVersion(args) {
+    let source;
+    if (args.template) {
+        (0, logging_1.info)(`Using bootstrapping template from ${args.template}`);
+        source = { source: 'custom', templateFile: args.template };
+    }
+    else if (process.env.CDK_LEGACY_BOOTSTRAP) {
+        (0, logging_1.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) {
+    var _a;
+    return (_a = configuration.context.get(featureFlag)) !== null && _a !== void 0 ? _a : cxapi.futureFlagDefault(featureFlag);
+}
+/**
+ * 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 !== '');
+}
+function determineHotswapMode(hotswap, hotswapFallback, watch) {
+    if (hotswap && hotswapFallback) {
+        throw new error_1.ToolkitError('Can not supply both --hotswap and --hotswap-fallback at the same time');
+    }
+    else if (!hotswap && !hotswapFallback) {
+        if (hotswap === undefined && hotswapFallback === undefined) {
+            return watch ? common_1.HotswapMode.HOTSWAP_ONLY : common_1.HotswapMode.FULL_DEPLOYMENT;
+        }
+        else if (hotswap === false || hotswapFallback === false) {
+            return common_1.HotswapMode.FULL_DEPLOYMENT;
+        }
+    }
+    let hotswapMode;
+    if (hotswap) {
+        hotswapMode = common_1.HotswapMode.HOTSWAP_ONLY;
+        /*if (hotswapFallback)*/
+    }
+    else {
+        hotswapMode = common_1.HotswapMode.FALL_BACK;
+    }
+    return hotswapMode;
+}
+/* istanbul ignore next: we never call this in unit tests */
+function cli(args = process.argv.slice(2)) {
+    exec(args)
+        .then(async (value) => {
+        if (typeof value === 'number') {
+            process.exitCode = value;
+        }
+    })
+        .catch((err) => {
+        (0, logging_1.error)(err.message);
+        // 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.
+        if (err.stack && version.isDeveloperBuild()) {
+            (0, logging_1.debug)(err.stack);
+        }
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["cli.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cxapi from '@aws-cdk/cx-api';\nimport '@jsii/check-node/run';\nimport * as chalk from 'chalk';\nimport { CdkToolkit, AssetBuildTime } from './cdk-toolkit';\nimport { parseCommandLineArguments } from './parse-command-line-arguments';\nimport { checkForPlatformWarnings } from './platform-warnings';\n\nimport * as version from './version';\nimport { SdkProvider } from '../api/aws-auth';\nimport { SdkToCliLogger } from '../api/aws-auth/sdk-logger';\nimport { setSdkTracing } from '../api/aws-auth/tracing';\nimport { BootstrapSource, Bootstrapper } from '../api/bootstrap';\nimport { StackSelector } from '../api/cxapp/cloud-assembly';\nimport { CloudExecutable, Synthesizer } from '../api/cxapp/cloud-executable';\nimport { execProgram } from '../api/cxapp/exec';\nimport { Deployments, DeploymentMethod } from '../api/deployments';\nimport { HotswapMode } from '../api/hotswap/common';\nimport { PluginHost } from '../api/plugin';\nimport { Settings } from '../api/settings';\nimport { ToolkitInfo } from '../api/toolkit-info';\nimport { ILock } from '../api/util/rwlock';\nimport { contextHandler as context } from '../commands/context';\nimport { docs } from '../commands/docs';\nimport { doctor } from '../commands/doctor';\nimport { getMigrateScanType } from '../commands/migrate';\nimport { cliInit, printAvailableTemplates } from '../init';\nimport { result, debug, error, info } from '../logging';\nimport { Notices } from '../notices';\nimport { Command, Configuration } from './user-configuration';\nimport { IoMessageLevel, CliIoHost } from '../toolkit/cli-io-host';\nimport { ToolkitError } from '../toolkit/error';\n\n/* eslint-disable max-len */\n/* eslint-disable @typescript-eslint/no-shadow */ // yargs\n\nif (!process.stdout.isTTY) {\n  // Disable chalk color highlighting\n  process.env.FORCE_COLOR = '0';\n}\n\nexport async function exec(args: string[], synthesizer?: Synthesizer): Promise<number | void> {\n  const argv = await parseCommandLineArguments(args);\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  }, true);\n\n  // Debug should always imply tracing\n  if (argv.debug || argv.verbose > 2) {\n    setSdkTracing(true);\n  } else {\n    // cli-lib-alpha needs to explicitly set in case it was enabled before\n    setSdkTracing(false);\n  }\n\n  try {\n    await checkForPlatformWarnings();\n  } catch (e) {\n    debug(`Error while checking for platform warnings: ${e}`);\n  }\n\n  debug('CDK toolkit version:', version.DISPLAY_VERSION);\n  debug('Command line arguments:', argv);\n\n  const configuration = new Configuration({\n    commandLineArguments: {\n      ...argv,\n      _: argv._ as [Command, ...string[]], // TypeScript at its best\n    },\n  });\n  await configuration.load();\n\n  const notices = Notices.create({\n    context: configuration.context,\n    output: configuration.settings.get(['outdir']),\n    shouldDisplay: configuration.settings.get(['notices']),\n    includeAcknowledged: cmd === 'notices' ? !argv.unacknowledged : false,\n    httpOptions: {\n      proxyAddress: configuration.settings.get(['proxy']),\n      caBundlePath: configuration.settings.get(['caBundlePath']),\n    },\n  });\n  await notices.refresh();\n\n  const sdkProvider = await SdkProvider.withAwsCliCompatibleDefaults({\n    profile: configuration.settings.get(['profile']),\n    httpOptions: {\n      proxyAddress: argv.proxy,\n      caBundlePath: argv['ca-bundle-path'],\n    },\n    logger: new SdkToCliLogger(ioHost),\n  });\n\n  let outDirLock: ILock | 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, config);\n        outDirLock = lock;\n        return assembly;\n      }),\n  });\n\n  /** Function to load plug-ins, using configurations additively. */\n  function loadPlugins(...settings: Settings[]) {\n    const loaded = new Set<string>();\n    for (const source of settings) {\n      const plugins: string[] = source.get(['plugin']) || [];\n      for (const plugin of plugins) {\n        const resolved = tryResolve(plugin);\n        if (loaded.has(resolved)) {\n          continue;\n        }\n        debug(`Loading plug-in: ${chalk.green(plugin)} from ${chalk.blue(resolved)}`);\n        PluginHost.instance.load(plugin);\n        loaded.add(resolved);\n      }\n    }\n\n    function tryResolve(plugin: string): string {\n      try {\n        return require.resolve(plugin);\n      } catch (e: any) {\n        error(`Unable to resolve plugin ${chalk.green(plugin)}: ${e.stack}`);\n        throw new ToolkitError(`Unable to resolve plug-in: ${plugin}`);\n      }\n    }\n  }\n\n  loadPlugins(configuration.settings);\n\n  if (typeof(cmd) !== 'string') {\n    throw new ToolkitError(`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 version.displayVersionMessage();\n\n    if (cmd === 'notices') {\n      await notices.refresh({ force: true });\n      notices.display({ showTotal: argv.unacknowledged });\n\n    } else if (cmd !== 'version') {\n      await notices.refresh();\n      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    debug(`Toolkit stack: ${chalk.bold(toolkitStackName)}`);\n\n    const cloudFormation = new Deployments({ sdkProvider, toolkitStackName });\n\n    if (args.all && args.STACKS) {\n      throw new ToolkitError('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      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          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({ browser: configuration.settings.get(['browser']) });\n\n      case 'doctor':\n        ioHost.currentAction = 'doctor';\n        return doctor();\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          stream: args.ci ? process.stdout : undefined,\n          compareAgainstProcessedTemplate: args.processed,\n          quiet: args.quiet,\n          changeSet: args['change-set'],\n          toolkitStackName: toolkitStackName,\n        });\n\n      case 'bootstrap':\n        ioHost.currentAction = 'bootstrap';\n        const source: BootstrapSource = determineBootstrapVersion(args);\n\n        if (args.showTemplate) {\n          const bootstrapper = new Bootstrapper(source);\n          return bootstrapper.showTemplate(args.json);\n        }\n\n        return cli.bootstrap(args.ENVIRONMENTS, {\n          source,\n          roleArn: args.roleArn,\n          force: 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          },\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('Can not supply both --[no-]execute and --method at the same time');\n        }\n\n        let deploymentMethod: DeploymentMethod | undefined;\n        switch (args.method) {\n          case 'direct':\n            if (args.changeSetName) {\n              throw new ToolkitError('--change-set-name cannot be used with method=direct');\n            }\n            if (args.importExistingResources) {\n              throw new ToolkitError('--import-existing-resources cannot be enabled 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            };\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            };\n            break;\n          case undefined:\n            deploymentMethod = {\n              method: 'change-set',\n              execute: args.execute ?? true,\n              changeSetName: args.changeSetName,\n              importExistingResources: args.importExistingResources,\n            };\n            break;\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,\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          hotswap: determineHotswapMode(args.hotswap, args.hotswapFallback),\n          watch: args.watch,\n          traceLogs: args.logs,\n          concurrency: args.concurrency,\n          assetParallelism: configuration.settings.get(['assetParallelism']),\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 '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        return cli.watch({\n          selector,\n          exclusively: args.exclusively,\n          toolkitStackName,\n          roleArn: args.roleArn,\n          reuseAssets: args['build-exclude'],\n          deploymentMethod: {\n            method: 'change-set',\n            changeSetName: args.changeSetName,\n          },\n          force: args.force,\n          progress: configuration.settings.get(['progress']),\n          rollback: configuration.settings.get(['rollback']),\n          hotswap: determineHotswapMode(args.hotswap, args.hotswapFallback, true),\n          traceLogs: args.logs,\n          concurrency: args.concurrency,\n        });\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          ci: args.ci,\n        });\n\n      case 'gc':\n        ioHost.currentAction = 'gc';\n        if (!configuration.settings.get(['unstable']).includes('gc')) {\n          throw new ToolkitError('Unstable feature use: \\'gc\\' is unstable. It must be opted in via \\'--unstable\\', e.g. \\'cdk gc --unstable=gc\\'');\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.bootstrapStackName,\n          confirm: args.confirm,\n        });\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        // This is a valid command, but we're postponing its execution\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 'init':\n        ioHost.currentAction = 'init';\n        const language = configuration.settings.get(['language']);\n        if (args.list) {\n          return printAvailableTemplates(language);\n        } else {\n          return cliInit({\n            type: args.TEMPLATE,\n            language,\n            canUseNetwork: undefined,\n            generateOnly: args.generateOnly,\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 result(version.DISPLAY_VERSION);\n\n      default:\n        throw new ToolkitError('Unknown command: ' + command);\n    }\n  }\n}\n\n/**\n * Determine which version of bootstrapping\n */\nfunction determineBootstrapVersion(args: { template?: string }): BootstrapSource {\n  let source: BootstrapSource;\n  if (args.template) {\n    info(`Using bootstrapping template from ${args.template}`);\n    source = { source: 'custom', templateFile: args.template };\n  } else if (process.env.CDK_LEGACY_BOOTSTRAP) {\n    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 * 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\nfunction determineHotswapMode(hotswap?: boolean, hotswapFallback?: boolean, watch?: boolean): HotswapMode {\n  if (hotswap && hotswapFallback) {\n    throw new ToolkitError('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/* istanbul ignore next: we never call this in unit tests */\nexport function cli(args: string[] = process.argv.slice(2)) {\n  exec(args)\n    .then(async (value) => {\n      if (typeof value === 'number') {\n        process.exitCode = value;\n      }\n    })\n    .catch((err) => {\n      error(err.message);\n\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      if (err.stack && version.isDeveloperBuild()) {\n        debug(err.stack);\n      }\n      process.exitCode = 1;\n    });\n}\n"]}

package/lib/cli/convert-to-user-input.d.ts

@@ -0,0 +1,3 @@
+import { UserInput } from './user-input';
+export declare function convertYargsToUserInput(args: any): UserInput;
+export declare function convertConfigToUserInput(config: any): UserInput;