@aws-cdk/toolkit-lib 0.3.2 → 0.3.4

package/lib/api/aws-auth/account-cache.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountAccessKeyCache = void 0;
+const path = require("path");
+const fs = require("fs-extra");
+const util_1 = require("../../util");
+/**
+ * Disk cache which maps access key IDs to account IDs.
+ * Usage:
+ *   cache.get(accessKey) => accountId | undefined
+ *   cache.put(accessKey, accountId)
+ */
+class AccountAccessKeyCache {
+    /**
+     * Max number of entries in the cache, after which the cache will be reset.
+     */
+    static MAX_ENTRIES = 1000;
+    /**
+     * The default path used for the accounts access key cache
+     */
+    static get DEFAULT_PATH() {
+        // needs to be a getter because cdkCacheDir can be set via env variable and might change
+        return path.join((0, util_1.cdkCacheDir)(), 'accounts_partitions.json');
+    }
+    cacheFile;
+    debug;
+    /**
+     * @param filePath Path to the cache file
+     */
+    constructor(filePath = AccountAccessKeyCache.DEFAULT_PATH, debugFn) {
+        this.cacheFile = filePath;
+        this.debug = debugFn;
+    }
+    /**
+     * Tries to fetch the account ID from cache. If it's not in the cache, invokes
+     * the resolver function which should retrieve the account ID and return it.
+     * Then, it will be stored into disk cache returned.
+     *
+     * Example:
+     *
+     *    const accountId = cache.fetch(accessKey, async () => {
+     *      return await fetchAccountIdFromSomewhere(accessKey);
+     *    });
+     */
+    async fetch(accessKeyId, resolver) {
+        // try to get account ID based on this access key ID from disk.
+        const cached = await this.get(accessKeyId);
+        if (cached) {
+            await this.debug(`Retrieved account ID ${cached.accountId} from disk cache`);
+            return cached;
+        }
+        // if it's not in the cache, resolve and put in cache.
+        const account = await resolver();
+        if (account) {
+            await this.put(accessKeyId, account);
+        }
+        return account;
+    }
+    /** Get the account ID from an access key or undefined if not in cache */
+    async get(accessKeyId) {
+        const map = await this.loadMap();
+        return map[accessKeyId];
+    }
+    /** Put a mapping between access key and account ID */
+    async put(accessKeyId, account) {
+        let map = await this.loadMap();
+        // nuke cache if it's too big.
+        if (Object.keys(map).length >= AccountAccessKeyCache.MAX_ENTRIES) {
+            map = {};
+        }
+        map[accessKeyId] = account;
+        await this.saveMap(map);
+    }
+    async loadMap() {
+        try {
+            return await fs.readJson(this.cacheFile);
+        }
+        catch (e) {
+            // File doesn't exist or is not readable. This is a cache,
+            // pretend we successfully loaded an empty map.
+            if (e.code === 'ENOENT' || e.code === 'EACCES') {
+                return {};
+            }
+            // File is not JSON, could be corrupted because of concurrent writes.
+            // Again, an empty cache is fine.
+            if (e instanceof SyntaxError) {
+                return {};
+            }
+            throw e;
+        }
+    }
+    async saveMap(map) {
+        try {
+            await fs.ensureFile(this.cacheFile);
+            await fs.writeJson(this.cacheFile, map, { spaces: 2 });
+        }
+        catch (e) {
+            // File doesn't exist or file/dir isn't writable. This is a cache,
+            // if we can't write it then too bad.
+            if (e.code === 'ENOENT' || e.code === 'EACCES' || e.code === 'EROFS') {
+                return;
+            }
+            throw e;
+        }
+    }
+}
+exports.AccountAccessKeyCache = AccountAccessKeyCache;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"account-cache.js","sourceRoot":"","sources":["account-cache.ts"],"names":[],"mappings":";;;AAAA,6BAA6B;AAC7B,+BAA+B;AAE/B,qCAAyC;AAEzC;;;;;GAKG;AACH,MAAa,qBAAqB;IAChC;;OAEG;IACI,MAAM,CAAU,WAAW,GAAG,IAAI,CAAC;IAE1C;;OAEG;IACI,MAAM,KAAK,YAAY;QAC5B,wFAAwF;QACxF,OAAO,IAAI,CAAC,IAAI,CAAC,IAAA,kBAAW,GAAE,EAAE,0BAA0B,CAAC,CAAC;IAC9D,CAAC;IAEgB,SAAS,CAAS;IAElB,KAAK,CAAiC;IAEvD;;OAEG;IACH,YAAY,WAAmB,qBAAqB,CAAC,YAAY,EAAE,OAAuC;QACxG,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC;IACvB,CAAC;IAED;;;;;;;;;;OAUG;IACI,KAAK,CAAC,KAAK,CAAoB,WAAmB,EAAE,QAA0B;QACnF,+DAA+D;QAC/D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QAC3C,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,IAAI,CAAC,KAAK,CAAC,wBAAwB,MAAM,CAAC,SAAS,kBAAkB,CAAC,CAAC;YAC7E,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,sDAAsD;QACtD,MAAM,OAAO,GAAG,MAAM,QAAQ,EAAE,CAAC;QACjC,IAAI,OAAO,EAAE,CAAC;YACZ,MAAM,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;QACvC,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,yEAAyE;IAClE,KAAK,CAAC,GAAG,CAAC,WAAmB;QAClC,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QACjC,OAAO,GAAG,CAAC,WAAW,CAAC,CAAC;IAC1B,CAAC;IAED,sDAAsD;IAC/C,KAAK,CAAC,GAAG,CAAC,WAAmB,EAAE,OAAgB;QACpD,IAAI,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QAE/B,8BAA8B;QAC9B,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,IAAI,qBAAqB,CAAC,WAAW,EAAE,CAAC;YACjE,GAAG,GAAG,EAAE,CAAC;QACX,CAAC;QAED,GAAG,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC;QAC3B,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC1B,CAAC;IAEO,KAAK,CAAC,OAAO;QACnB,IAAI,CAAC;YACH,OAAO,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC3C,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,0DAA0D;YAC1D,+CAA+C;YAC/C,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC/C,OAAO,EAAE,CAAC;YACZ,CAAC;YACD,qEAAqE;YACrE,iCAAiC;YACjC,IAAI,CAAC,YAAY,WAAW,EAAE,CAAC;gBAC7B,OAAO,EAAE,CAAC;YACZ,CAAC;YACD,MAAM,CAAC,CAAC;QACV,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,OAAO,CAAC,GAAuC;QAC3D,IAAI,CAAC;YACH,MAAM,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACpC,MAAM,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;QACzD,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,kEAAkE;YAClE,qCAAqC;YACrC,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;gBACrE,OAAO;YACT,CAAC;YACD,MAAM,CAAC,CAAC;QACV,CAAC;IACH,CAAC;;AAvGH,sDAwGC","sourcesContent":["import * as path from 'path';\nimport * as fs from 'fs-extra';\nimport type { Account } from './sdk-provider';\nimport { cdkCacheDir } from '../../util';\n\n/**\n * Disk cache which maps access key IDs to account IDs.\n * Usage:\n *   cache.get(accessKey) => accountId | undefined\n *   cache.put(accessKey, accountId)\n */\nexport class AccountAccessKeyCache {\n  /**\n   * Max number of entries in the cache, after which the cache will be reset.\n   */\n  public static readonly MAX_ENTRIES = 1000;\n\n  /**\n   * The default path used for the accounts access key cache\n   */\n  public static get DEFAULT_PATH(): string {\n    // needs to be a getter because cdkCacheDir can be set via env variable and might change\n    return path.join(cdkCacheDir(), 'accounts_partitions.json');\n  }\n\n  private readonly cacheFile: string;\n\n  private readonly debug: (msg: string) => Promise<void>;\n\n  /**\n   * @param filePath Path to the cache file\n   */\n  constructor(filePath: string = AccountAccessKeyCache.DEFAULT_PATH, debugFn: (msg: string) => Promise<void>) {\n    this.cacheFile = filePath;\n    this.debug = debugFn;\n  }\n\n  /**\n   * Tries to fetch the account ID from cache. If it's not in the cache, invokes\n   * the resolver function which should retrieve the account ID and return it.\n   * Then, it will be stored into disk cache returned.\n   *\n   * Example:\n   *\n   *    const accountId = cache.fetch(accessKey, async () => {\n   *      return await fetchAccountIdFromSomewhere(accessKey);\n   *    });\n   */\n  public async fetch<A extends Account>(accessKeyId: string, resolver: () => Promise<A>) {\n    // try to get account ID based on this access key ID from disk.\n    const cached = await this.get(accessKeyId);\n    if (cached) {\n      await this.debug(`Retrieved account ID ${cached.accountId} from disk cache`);\n      return cached;\n    }\n\n    // if it's not in the cache, resolve and put in cache.\n    const account = await resolver();\n    if (account) {\n      await this.put(accessKeyId, account);\n    }\n\n    return account;\n  }\n\n  /** Get the account ID from an access key or undefined if not in cache */\n  public async get(accessKeyId: string): Promise<Account | undefined> {\n    const map = await this.loadMap();\n    return map[accessKeyId];\n  }\n\n  /** Put a mapping between access key and account ID */\n  public async put(accessKeyId: string, account: Account) {\n    let map = await this.loadMap();\n\n    // nuke cache if it's too big.\n    if (Object.keys(map).length >= AccountAccessKeyCache.MAX_ENTRIES) {\n      map = {};\n    }\n\n    map[accessKeyId] = account;\n    await this.saveMap(map);\n  }\n\n  private async loadMap(): Promise<{ [accessKeyId: string]: Account }> {\n    try {\n      return await fs.readJson(this.cacheFile);\n    } catch (e: any) {\n      // File doesn't exist or is not readable. This is a cache,\n      // pretend we successfully loaded an empty map.\n      if (e.code === 'ENOENT' || e.code === 'EACCES') {\n        return {};\n      }\n      // File is not JSON, could be corrupted because of concurrent writes.\n      // Again, an empty cache is fine.\n      if (e instanceof SyntaxError) {\n        return {};\n      }\n      throw e;\n    }\n  }\n\n  private async saveMap(map: { [accessKeyId: string]: Account }) {\n    try {\n      await fs.ensureFile(this.cacheFile);\n      await fs.writeJson(this.cacheFile, map, { spaces: 2 });\n    } catch (e: any) {\n      // File doesn't exist or file/dir isn't writable. This is a cache,\n      // if we can't write it then too bad.\n      if (e.code === 'ENOENT' || e.code === 'EACCES' || e.code === 'EROFS') {\n        return;\n      }\n      throw e;\n    }\n  }\n}\n"]}

package/lib/api/aws-auth/awscli-compatible.d.ts

@@ -0,0 +1,70 @@
+import type { NodeHttpHandlerOptions } from '@smithy/node-http-handler';
+import type { AwsCredentialIdentityProvider, Logger } from '@smithy/types';
+import type { SdkHttpOptions } from './types';
+import { type IoHelper } from '../io/private';
+/**
+ * Behaviors to match AWS CLI
+ *
+ * See these links:
+ *
+ * https://docs.aws.amazon.com/cli/latest/topic/config-vars.html
+ * https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html
+ */
+export declare class AwsCliCompatible {
+    private readonly ioHelper;
+    private readonly requestHandler;
+    private readonly logger?;
+    constructor(ioHelper: IoHelper, requestHandler: NodeHttpHandlerOptions, logger?: Logger);
+    baseConfig(profile?: string): Promise<{
+        credentialProvider: AwsCredentialIdentityProvider;
+        defaultRegion: string;
+    }>;
+    /**
+     * Build an AWS CLI-compatible credential chain provider
+     *
+     * The credential chain returned by this function is always caching.
+     */
+    credentialChainBuilder(options?: CredentialChainOptions): Promise<AwsCredentialIdentityProvider>;
+    /**
+     * Attempts to get the region from a number of sources and falls back to us-east-1 if no region can be found,
+     * as is done in the AWS CLI.
+     *
+     * The order of priority is the following:
+     *
+     * 1. Environment variables specifying region, with both an AWS prefix and AMAZON prefix
+     *    to maintain backwards compatibility, and without `DEFAULT` in the name because
+     *    Lambda and CodeBuild set the $AWS_REGION variable.
+     * 2. Regions listed in the Shared Ini Files - First checking for the profile provided
+     *    and then checking for the default profile.
+     * 3. IMDS instance identity region from the Metadata Service.
+     * 4. us-east-1
+     */
+    region(maybeProfile?: string): Promise<string>;
+    /**
+     * The MetadataService class will attempt to fetch the instance identity document from
+     * IMDSv2 first, and then will attempt v1 as a fallback.
+     *
+     * If this fails, we will use us-east-1 as the region so no error should be thrown.
+     * @returns The region for the instance identity
+     */
+    private regionFromMetadataService;
+    /**
+     * Looks up the region of the provided profile. If no region is present,
+     * it will attempt to lookup the default region.
+     * @param profile The profile to use to lookup the region
+     * @returns The region for the profile or default profile, if present. Otherwise returns undefined.
+     */
+    private getRegionFromIni;
+    private getRegionFromIniFile;
+    /**
+     * Ask user for MFA token for given serial
+     *
+     * Result is send to callback function for SDK to authorize the request
+     */
+    private tokenCodeFn;
+}
+export interface CredentialChainOptions {
+    readonly profile?: string;
+    readonly logger?: Logger;
+}
+export declare function makeRequestHandler(ioHelper: IoHelper, options?: SdkHttpOptions): Promise<NodeHttpHandlerOptions>;

package/lib/api/aws-auth/awscli-compatible.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsCliCompatible = void 0;
+exports.makeRequestHandler = makeRequestHandler;
+const node_util_1 = require("node:util");
+const credential_providers_1 = require("@aws-sdk/credential-providers");
+const ec2_metadata_service_1 = require("@aws-sdk/ec2-metadata-service");
+const shared_ini_file_loader_1 = require("@smithy/shared-ini-file-loader");
+const promptly = require("promptly");
+const provider_caching_1 = require("./provider-caching");
+const proxy_agent_1 = require("./proxy-agent");
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+const private_1 = require("../io/private");
+const DEFAULT_CONNECTION_TIMEOUT = 10000;
+const DEFAULT_TIMEOUT = 300000;
+/**
+ * Behaviors to match AWS CLI
+ *
+ * See these links:
+ *
+ * https://docs.aws.amazon.com/cli/latest/topic/config-vars.html
+ * https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html
+ */
+class AwsCliCompatible {
+    ioHelper;
+    requestHandler;
+    logger;
+    constructor(ioHelper, requestHandler, logger) {
+        this.ioHelper = ioHelper;
+        this.requestHandler = requestHandler;
+        this.logger = logger;
+    }
+    async baseConfig(profile) {
+        const credentialProvider = await this.credentialChainBuilder({
+            profile,
+            logger: this.logger,
+        });
+        const defaultRegion = await this.region(profile);
+        return { credentialProvider, defaultRegion };
+    }
+    /**
+     * Build an AWS CLI-compatible credential chain provider
+     *
+     * The credential chain returned by this function is always caching.
+     */
+    async credentialChainBuilder(options = {}) {
+        const clientConfig = {
+            requestHandler: this.requestHandler,
+            customUserAgent: 'aws-cdk',
+            logger: options.logger,
+        };
+        // Super hacky solution to https://github.com/aws/aws-cdk/issues/32510, proposed by the SDK team.
+        //
+        // Summary of the problem: we were reading the region from the config file and passing it to
+        // the credential providers. However, in the case of SSO, this makes the credential provider
+        // use that region to do the SSO flow, which is incorrect. The region that should be used for
+        // that is the one set in the sso_session section of the config file.
+        //
+        // The idea here: the "clientConfig" is for configuring the inner auth client directly,
+        // and has the highest priority, whereas "parentClientConfig" is the upper data client
+        // and has lower priority than the sso_region but still higher priority than STS global region.
+        const parentClientConfig = {
+            region: await this.region(options.profile),
+        };
+        /**
+         * The previous implementation matched AWS CLI behavior:
+         *
+         * If a profile is explicitly set using `--profile`,
+         * we use that to the exclusion of everything else.
+         *
+         * Note: this does not apply to AWS_PROFILE,
+         * environment credentials still take precedence over AWS_PROFILE
+         */
+        if (options.profile) {
+            return (0, provider_caching_1.makeCachingProvider)((0, credential_providers_1.fromIni)({
+                profile: options.profile,
+                ignoreCache: true,
+                mfaCodeProvider: this.tokenCodeFn.bind(this),
+                clientConfig,
+                parentClientConfig,
+                logger: options.logger,
+            }));
+        }
+        const envProfile = process.env.AWS_PROFILE || process.env.AWS_DEFAULT_PROFILE;
+        /**
+         * Env AWS - EnvironmentCredentials with string AWS
+         * Env Amazon - EnvironmentCredentials with string AMAZON
+         * Profile Credentials - PatchedSharedIniFileCredentials with implicit profile, credentials file, http options, and token fn
+         *    SSO with implicit profile only
+         *    SharedIniFileCredentials with implicit profile and preferStaticCredentials true (profile with source_profile)
+         *    Shared Credential file that points to Environment Credentials with AWS prefix
+         *    Shared Credential file that points to EC2 Metadata
+         *    Shared Credential file that points to ECS Credentials
+         * SSO Credentials - SsoCredentials with implicit profile and http options
+         * ProcessCredentials with implicit profile
+         * ECS Credentials - ECSCredentials with no input OR Web Identity - TokenFileWebIdentityCredentials with no input OR EC2 Metadata - EC2MetadataCredentials with no input
+         *
+         * These translate to:
+         * fromEnv()
+         * fromSSO()/fromIni()
+         * fromProcess()
+         * fromContainerMetadata()
+         * fromTokenFile()
+         * fromInstanceMetadata()
+         *
+         * The NodeProviderChain is already cached.
+         */
+        const nodeProviderChain = (0, credential_providers_1.fromNodeProviderChain)({
+            profile: envProfile,
+            clientConfig,
+            parentClientConfig,
+            logger: options.logger,
+            mfaCodeProvider: this.tokenCodeFn.bind(this),
+            ignoreCache: true,
+        });
+        return shouldPrioritizeEnv()
+            ? (0, credential_providers_1.createCredentialChain)((0, credential_providers_1.fromEnv)(), nodeProviderChain).expireAfter(60 * 60_000)
+            : nodeProviderChain;
+    }
+    /**
+     * Attempts to get the region from a number of sources and falls back to us-east-1 if no region can be found,
+     * as is done in the AWS CLI.
+     *
+     * The order of priority is the following:
+     *
+     * 1. Environment variables specifying region, with both an AWS prefix and AMAZON prefix
+     *    to maintain backwards compatibility, and without `DEFAULT` in the name because
+     *    Lambda and CodeBuild set the $AWS_REGION variable.
+     * 2. Regions listed in the Shared Ini Files - First checking for the profile provided
+     *    and then checking for the default profile.
+     * 3. IMDS instance identity region from the Metadata Service.
+     * 4. us-east-1
+     */
+    async region(maybeProfile) {
+        const defaultRegion = 'us-east-1';
+        const profile = maybeProfile || process.env.AWS_PROFILE || process.env.AWS_DEFAULT_PROFILE || 'default';
+        const region = process.env.AWS_REGION ||
+            process.env.AMAZON_REGION ||
+            process.env.AWS_DEFAULT_REGION ||
+            process.env.AMAZON_DEFAULT_REGION ||
+            (await this.getRegionFromIni(profile)) ||
+            (await this.regionFromMetadataService());
+        if (!region) {
+            const usedProfile = !profile ? '' : ` (profile: "${profile}")`;
+            await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(`Unable to determine AWS region from environment or AWS configuration${usedProfile}, defaulting to '${defaultRegion}'`));
+            return defaultRegion;
+        }
+        return region;
+    }
+    /**
+     * The MetadataService class will attempt to fetch the instance identity document from
+     * IMDSv2 first, and then will attempt v1 as a fallback.
+     *
+     * If this fails, we will use us-east-1 as the region so no error should be thrown.
+     * @returns The region for the instance identity
+     */
+    async regionFromMetadataService() {
+        await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg('Looking up AWS region in the EC2 Instance Metadata Service (IMDS).'));
+        try {
+            const metadataService = new ec2_metadata_service_1.MetadataService({
+                httpOptions: {
+                    timeout: 1000,
+                },
+            });
+            await metadataService.fetchMetadataToken();
+            const document = await metadataService.request('/latest/dynamic/instance-identity/document', {});
+            return JSON.parse(document).region;
+        }
+        catch (e) {
+            await this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg(`Unable to retrieve AWS region from IMDS: ${e}`));
+        }
+    }
+    /**
+     * Looks up the region of the provided profile. If no region is present,
+     * it will attempt to lookup the default region.
+     * @param profile The profile to use to lookup the region
+     * @returns The region for the profile or default profile, if present. Otherwise returns undefined.
+     */
+    async getRegionFromIni(profile) {
+        const sharedFiles = await (0, shared_ini_file_loader_1.loadSharedConfigFiles)({ ignoreCache: true });
+        // Priority:
+        //
+        // credentials come before config because aws-cli v1 behaves like that.
+        //
+        // 1. profile-region-in-credentials
+        // 2. profile-region-in-config
+        // 3. default-region-in-credentials
+        // 4. default-region-in-config
+        return this.getRegionFromIniFile(profile, sharedFiles.credentialsFile)
+            ?? this.getRegionFromIniFile(profile, sharedFiles.configFile)
+            ?? this.getRegionFromIniFile('default', sharedFiles.credentialsFile)
+            ?? this.getRegionFromIniFile('default', sharedFiles.configFile);
+    }
+    getRegionFromIniFile(profile, data) {
+        return data?.[profile]?.region;
+    }
+    /**
+     * Ask user for MFA token for given serial
+     *
+     * Result is send to callback function for SDK to authorize the request
+     */
+    async tokenCodeFn(serialArn) {
+        const debugFn = (msg, ...args) => this.ioHelper.notify(private_1.IO.DEFAULT_SDK_DEBUG.msg((0, node_util_1.format)(msg, ...args)));
+        await debugFn('Require MFA token for serial ARN', serialArn);
+        try {
+            const token = await promptly.prompt(`MFA token for ${serialArn}: `, {
+                trim: true,
+                default: '',
+            });
+            await debugFn('Successfully got MFA token from user');
+            return token;
+        }
+        catch (err) {
+            await debugFn('Failed to get MFA token', err);
+            const e = new toolkit_error_1.AuthenticationError(`Error fetching MFA token: ${err.message ?? err}`);
+            e.name = 'SharedIniFileCredentialsProviderFailure';
+            throw e;
+        }
+    }
+}
+exports.AwsCliCompatible = AwsCliCompatible;
+/**
+ * We used to support both AWS and AMAZON prefixes for these environment variables.
+ *
+ * Adding this for backward compatibility.
+ */
+function shouldPrioritizeEnv() {
+    const id = process.env.AWS_ACCESS_KEY_ID || process.env.AMAZON_ACCESS_KEY_ID;
+    const key = process.env.AWS_SECRET_ACCESS_KEY || process.env.AMAZON_SECRET_ACCESS_KEY;
+    if (!!id && !!key) {
+        process.env.AWS_ACCESS_KEY_ID = id;
+        process.env.AWS_SECRET_ACCESS_KEY = key;
+        const sessionToken = process.env.AWS_SESSION_TOKEN ?? process.env.AMAZON_SESSION_TOKEN;
+        if (sessionToken) {
+            process.env.AWS_SESSION_TOKEN = sessionToken;
+        }
+        return true;
+    }
+    return false;
+}
+async function makeRequestHandler(ioHelper, options = {}) {
+    const agent = await new proxy_agent_1.ProxyAgentProvider(ioHelper).create(options);
+    return {
+        connectionTimeout: DEFAULT_CONNECTION_TIMEOUT,
+        requestTimeout: DEFAULT_TIMEOUT,
+        httpsAgent: agent,
+        httpAgent: agent,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"awscli-compatible.js","sourceRoot":"","sources":["awscli-compatible.ts"],"names":[],"mappings":"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","sourcesContent":["import { format } from 'node:util';\nimport { createCredentialChain, fromEnv, fromIni, fromNodeProviderChain } from '@aws-sdk/credential-providers';\nimport { MetadataService } from '@aws-sdk/ec2-metadata-service';\nimport type { NodeHttpHandlerOptions } from '@smithy/node-http-handler';\nimport { loadSharedConfigFiles } from '@smithy/shared-ini-file-loader';\nimport type { AwsCredentialIdentityProvider, Logger } from '@smithy/types';\nimport * as promptly from 'promptly';\nimport { makeCachingProvider } from './provider-caching';\nimport { ProxyAgentProvider } from './proxy-agent';\nimport type { SdkHttpOptions } from './types';\nimport { AuthenticationError } from '../../toolkit/toolkit-error';\nimport { IO, type IoHelper } from '../io/private';\n\nconst DEFAULT_CONNECTION_TIMEOUT = 10000;\nconst DEFAULT_TIMEOUT = 300000;\n\n/**\n * Behaviors to match AWS CLI\n *\n * See these links:\n *\n * https://docs.aws.amazon.com/cli/latest/topic/config-vars.html\n * https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html\n */\nexport class AwsCliCompatible {\n  private readonly ioHelper: IoHelper;\n  private readonly requestHandler: NodeHttpHandlerOptions;\n  private readonly logger?: Logger;\n\n  public constructor(ioHelper: IoHelper, requestHandler: NodeHttpHandlerOptions, logger?: Logger) {\n    this.ioHelper = ioHelper;\n    this.requestHandler = requestHandler;\n    this.logger = logger;\n  }\n\n  public async baseConfig(profile?: string): Promise<{ credentialProvider: AwsCredentialIdentityProvider; defaultRegion: string }> {\n    const credentialProvider = await this.credentialChainBuilder({\n      profile,\n      logger: this.logger,\n    });\n    const defaultRegion = await this.region(profile);\n    return { credentialProvider, defaultRegion };\n  }\n\n  /**\n   * Build an AWS CLI-compatible credential chain provider\n   *\n   * The credential chain returned by this function is always caching.\n   */\n  public async credentialChainBuilder(\n    options: CredentialChainOptions = {},\n  ): Promise<AwsCredentialIdentityProvider> {\n    const clientConfig = {\n      requestHandler: this.requestHandler,\n      customUserAgent: 'aws-cdk',\n      logger: options.logger,\n    };\n\n    // Super hacky solution to https://github.com/aws/aws-cdk/issues/32510, proposed by the SDK team.\n    //\n    // Summary of the problem: we were reading the region from the config file and passing it to\n    // the credential providers. However, in the case of SSO, this makes the credential provider\n    // use that region to do the SSO flow, which is incorrect. The region that should be used for\n    // that is the one set in the sso_session section of the config file.\n    //\n    // The idea here: the \"clientConfig\" is for configuring the inner auth client directly,\n    // and has the highest priority, whereas \"parentClientConfig\" is the upper data client\n    // and has lower priority than the sso_region but still higher priority than STS global region.\n    const parentClientConfig = {\n      region: await this.region(options.profile),\n    };\n    /**\n     * The previous implementation matched AWS CLI behavior:\n     *\n     * If a profile is explicitly set using `--profile`,\n     * we use that to the exclusion of everything else.\n     *\n     * Note: this does not apply to AWS_PROFILE,\n     * environment credentials still take precedence over AWS_PROFILE\n     */\n    if (options.profile) {\n      return makeCachingProvider(fromIni({\n        profile: options.profile,\n        ignoreCache: true,\n        mfaCodeProvider: this.tokenCodeFn.bind(this),\n        clientConfig,\n        parentClientConfig,\n        logger: options.logger,\n      }));\n    }\n\n    const envProfile = process.env.AWS_PROFILE || process.env.AWS_DEFAULT_PROFILE;\n\n    /**\n     * Env AWS - EnvironmentCredentials with string AWS\n     * Env Amazon - EnvironmentCredentials with string AMAZON\n     * Profile Credentials - PatchedSharedIniFileCredentials with implicit profile, credentials file, http options, and token fn\n     *    SSO with implicit profile only\n     *    SharedIniFileCredentials with implicit profile and preferStaticCredentials true (profile with source_profile)\n     *    Shared Credential file that points to Environment Credentials with AWS prefix\n     *    Shared Credential file that points to EC2 Metadata\n     *    Shared Credential file that points to ECS Credentials\n     * SSO Credentials - SsoCredentials with implicit profile and http options\n     * ProcessCredentials with implicit profile\n     * ECS Credentials - ECSCredentials with no input OR Web Identity - TokenFileWebIdentityCredentials with no input OR EC2 Metadata - EC2MetadataCredentials with no input\n     *\n     * These translate to:\n     * fromEnv()\n     * fromSSO()/fromIni()\n     * fromProcess()\n     * fromContainerMetadata()\n     * fromTokenFile()\n     * fromInstanceMetadata()\n     *\n     * The NodeProviderChain is already cached.\n     */\n    const nodeProviderChain = fromNodeProviderChain({\n      profile: envProfile,\n      clientConfig,\n      parentClientConfig,\n      logger: options.logger,\n      mfaCodeProvider: this.tokenCodeFn.bind(this),\n      ignoreCache: true,\n    });\n\n    return shouldPrioritizeEnv()\n      ? createCredentialChain(fromEnv(), nodeProviderChain).expireAfter(60 * 60_000)\n      : nodeProviderChain;\n  }\n\n  /**\n   * Attempts to get the region from a number of sources and falls back to us-east-1 if no region can be found,\n   * as is done in the AWS CLI.\n   *\n   * The order of priority is the following:\n   *\n   * 1. Environment variables specifying region, with both an AWS prefix and AMAZON prefix\n   *    to maintain backwards compatibility, and without `DEFAULT` in the name because\n   *    Lambda and CodeBuild set the $AWS_REGION variable.\n   * 2. Regions listed in the Shared Ini Files - First checking for the profile provided\n   *    and then checking for the default profile.\n   * 3. IMDS instance identity region from the Metadata Service.\n   * 4. us-east-1\n   */\n  public async region(maybeProfile?: string): Promise<string> {\n    const defaultRegion = 'us-east-1';\n    const profile = maybeProfile || process.env.AWS_PROFILE || process.env.AWS_DEFAULT_PROFILE || 'default';\n\n    const region =\n      process.env.AWS_REGION ||\n      process.env.AMAZON_REGION ||\n      process.env.AWS_DEFAULT_REGION ||\n      process.env.AMAZON_DEFAULT_REGION ||\n      (await this.getRegionFromIni(profile)) ||\n      (await this.regionFromMetadataService());\n\n    if (!region) {\n      const usedProfile = !profile ? '' : ` (profile: \"${profile}\")`;\n      await this.ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg(\n        `Unable to determine AWS region from environment or AWS configuration${usedProfile}, defaulting to '${defaultRegion}'`,\n      ));\n      return defaultRegion;\n    }\n\n    return region;\n  }\n\n  /**\n   * The MetadataService class will attempt to fetch the instance identity document from\n   * IMDSv2 first, and then will attempt v1 as a fallback.\n   *\n   * If this fails, we will use us-east-1 as the region so no error should be thrown.\n   * @returns The region for the instance identity\n   */\n  private async regionFromMetadataService() {\n    await this.ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg('Looking up AWS region in the EC2 Instance Metadata Service (IMDS).'));\n    try {\n      const metadataService = new MetadataService({\n        httpOptions: {\n          timeout: 1000,\n        },\n      });\n\n      await metadataService.fetchMetadataToken();\n      const document = await metadataService.request('/latest/dynamic/instance-identity/document', {});\n      return JSON.parse(document).region;\n    } catch (e) {\n      await this.ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg(`Unable to retrieve AWS region from IMDS: ${e}`));\n    }\n  }\n\n  /**\n   * Looks up the region of the provided profile. If no region is present,\n   * it will attempt to lookup the default region.\n   * @param profile The profile to use to lookup the region\n   * @returns The region for the profile or default profile, if present. Otherwise returns undefined.\n   */\n  private async getRegionFromIni(profile: string): Promise<string | undefined> {\n    const sharedFiles = await loadSharedConfigFiles({ ignoreCache: true });\n\n    // Priority:\n    //\n    // credentials come before config because aws-cli v1 behaves like that.\n    //\n    // 1. profile-region-in-credentials\n    // 2. profile-region-in-config\n    // 3. default-region-in-credentials\n    // 4. default-region-in-config\n\n    return this.getRegionFromIniFile(profile, sharedFiles.credentialsFile)\n    ?? this.getRegionFromIniFile(profile, sharedFiles.configFile)\n    ?? this.getRegionFromIniFile('default', sharedFiles.credentialsFile)\n    ?? this.getRegionFromIniFile('default', sharedFiles.configFile);\n  }\n\n  private getRegionFromIniFile(profile: string, data?: any) {\n    return data?.[profile]?.region;\n  }\n\n  /**\n   * Ask user for MFA token for given serial\n   *\n   * Result is send to callback function for SDK to authorize the request\n   */\n  private async tokenCodeFn(serialArn: string): Promise<string> {\n    const debugFn = (msg: string, ...args: any[]) => this.ioHelper.notify(IO.DEFAULT_SDK_DEBUG.msg(format(msg, ...args)));\n    await debugFn('Require MFA token for serial ARN', serialArn);\n    try {\n      const token: string = await promptly.prompt(`MFA token for ${serialArn}: `, {\n        trim: true,\n        default: '',\n      });\n      await debugFn('Successfully got MFA token from user');\n      return token;\n    } catch (err: any) {\n      await debugFn('Failed to get MFA token', err);\n      const e = new AuthenticationError(`Error fetching MFA token: ${err.message ?? err}`);\n      e.name = 'SharedIniFileCredentialsProviderFailure';\n      throw e;\n    }\n  }\n}\n\n/**\n * We used to support both AWS and AMAZON prefixes for these environment variables.\n *\n * Adding this for backward compatibility.\n */\nfunction shouldPrioritizeEnv() {\n  const id = process.env.AWS_ACCESS_KEY_ID || process.env.AMAZON_ACCESS_KEY_ID;\n  const key = process.env.AWS_SECRET_ACCESS_KEY || process.env.AMAZON_SECRET_ACCESS_KEY;\n\n  if (!!id && !!key) {\n    process.env.AWS_ACCESS_KEY_ID = id;\n    process.env.AWS_SECRET_ACCESS_KEY = key;\n\n    const sessionToken = process.env.AWS_SESSION_TOKEN ?? process.env.AMAZON_SESSION_TOKEN;\n    if (sessionToken) {\n      process.env.AWS_SESSION_TOKEN = sessionToken;\n    }\n\n    return true;\n  }\n\n  return false;\n}\n\nexport interface CredentialChainOptions {\n  readonly profile?: string;\n  readonly logger?: Logger;\n}\n\nexport async function makeRequestHandler(ioHelper: IoHelper, options: SdkHttpOptions = {}): Promise<NodeHttpHandlerOptions> {\n  const agent = await new ProxyAgentProvider(ioHelper).create(options);\n\n  return {\n    connectionTimeout: DEFAULT_CONNECTION_TIMEOUT,\n    requestTimeout: DEFAULT_TIMEOUT,\n    httpsAgent: agent,\n    httpAgent: agent,\n  };\n}\n"]}

package/lib/api/aws-auth/cached.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Cache the result of a function on an object
+ *
+ * We could have used @decorators to make this nicer but we don't use them anywhere yet,
+ * so let's keep it simple and readable.
+ */
+export declare function cached<A extends object, B>(obj: A, sym: symbol, fn: () => B): B;
+/**
+ * Like 'cached', but async
+ */
+export declare function cachedAsync<A extends object, B>(obj: A, sym: symbol, fn: () => Promise<B>): Promise<B>;

package/lib/api/aws-auth/cached.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cached = cached;
+exports.cachedAsync = cachedAsync;
+/**
+ * Cache the result of a function on an object
+ *
+ * We could have used @decorators to make this nicer but we don't use them anywhere yet,
+ * so let's keep it simple and readable.
+ */
+function cached(obj, sym, fn) {
+    if (!(sym in obj)) {
+        obj[sym] = fn();
+    }
+    return obj[sym];
+}
+/**
+ * Like 'cached', but async
+ */
+async function cachedAsync(obj, sym, fn) {
+    if (!(sym in obj)) {
+        obj[sym] = await fn();
+    }
+    return obj[sym];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiY2FjaGVkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBTUEsd0JBS0M7QUFLRCxrQ0FLQztBQXJCRDs7Ozs7R0FLRztBQUNILFNBQWdCLE1BQU0sQ0FBc0IsR0FBTSxFQUFFLEdBQVcsRUFBRSxFQUFXO0lBQzFFLElBQUksQ0FBQyxDQUFDLEdBQUcsSUFBSSxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQ2pCLEdBQVcsQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FBQztJQUMzQixDQUFDO0lBQ0QsT0FBUSxHQUFXLENBQUMsR0FBRyxDQUFDLENBQUM7QUFDM0IsQ0FBQztBQUVEOztHQUVHO0FBQ0ksS0FBSyxVQUFVLFdBQVcsQ0FBc0IsR0FBTSxFQUFFLEdBQVcsRUFBRSxFQUFvQjtJQUM5RixJQUFJLENBQUMsQ0FBQyxHQUFHLElBQUksR0FBRyxDQUFDLEVBQUUsQ0FBQztRQUNqQixHQUFXLENBQUMsR0FBRyxDQUFDLEdBQUcsTUFBTSxFQUFFLEVBQUUsQ0FBQztJQUNqQyxDQUFDO0lBQ0QsT0FBUSxHQUFXLENBQUMsR0FBRyxDQUFDLENBQUM7QUFDM0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ2FjaGUgdGhlIHJlc3VsdCBvZiBhIGZ1bmN0aW9uIG9uIGFuIG9iamVjdFxuICpcbiAqIFdlIGNvdWxkIGhhdmUgdXNlZCBAZGVjb3JhdG9ycyB0byBtYWtlIHRoaXMgbmljZXIgYnV0IHdlIGRvbid0IHVzZSB0aGVtIGFueXdoZXJlIHlldCxcbiAqIHNvIGxldCdzIGtlZXAgaXQgc2ltcGxlIGFuZCByZWFkYWJsZS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNhY2hlZDxBIGV4dGVuZHMgb2JqZWN0LCBCPihvYmo6IEEsIHN5bTogc3ltYm9sLCBmbjogKCkgPT4gQik6IEIge1xuICBpZiAoIShzeW0gaW4gb2JqKSkge1xuICAgIChvYmogYXMgYW55KVtzeW1dID0gZm4oKTtcbiAgfVxuICByZXR1cm4gKG9iaiBhcyBhbnkpW3N5bV07XG59XG5cbi8qKlxuICogTGlrZSAnY2FjaGVkJywgYnV0IGFzeW5jXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBjYWNoZWRBc3luYzxBIGV4dGVuZHMgb2JqZWN0LCBCPihvYmo6IEEsIHN5bTogc3ltYm9sLCBmbjogKCkgPT4gUHJvbWlzZTxCPik6IFByb21pc2U8Qj4ge1xuICBpZiAoIShzeW0gaW4gb2JqKSkge1xuICAgIChvYmogYXMgYW55KVtzeW1dID0gYXdhaXQgZm4oKTtcbiAgfVxuICByZXR1cm4gKG9iaiBhcyBhbnkpW3N5bV07XG59XG4iXX0=

package/lib/api/aws-auth/credential-plugins.d.ts

@@ -0,0 +1,38 @@
+import type { AwsCredentialIdentityProvider } from '@smithy/types';
+import { type IoHelper } from '../io/private';
+import type { PluginHost } from '../plugin';
+import type { Mode } from '../plugin/mode';
+/**
+ * Cache for credential providers.
+ *
+ * Given an account and an operating mode (read or write) will return an
+ * appropriate credential provider for credentials for the given account. The
+ * credential provider will be cached so that multiple AWS clients for the same
+ * environment will not make multiple network calls to obtain credentials.
+ *
+ * Will use default credentials if they are for the right account; otherwise,
+ * all loaded credential provider plugins will be tried to obtain credentials
+ * for the given account.
+ */
+export declare class CredentialPlugins {
+    private readonly host;
+    private readonly ioHelper;
+    private readonly cache;
+    constructor(host: PluginHost, ioHelper: IoHelper);
+    fetchCredentialsFor(awsAccountId: string, mode: Mode): Promise<PluginCredentialsFetchResult | undefined>;
+    get availablePluginNames(): string[];
+    private lookupCredentials;
+}
+/**
+ * Result from trying to fetch credentials from the Plugin host
+ */
+export interface PluginCredentialsFetchResult {
+    /**
+     * SDK-v3 compatible credential provider
+     */
+    readonly credentials: AwsCredentialIdentityProvider;
+    /**
+     * Name of plugin that successfully provided credentials
+     */
+    readonly pluginName: string;
+}