cdk-assets 0.0.0

package/lib/private/handlers/files.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileAssetHandler = void 0;
+const fs_1 = require("fs");
+const path = require("path");
+const cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema");
+const mime = require("mime");
+const client_options_1 = require("./client-options");
+const progress_1 = require("../../progress");
+const archive_1 = require("../archive");
+const fs_extra_1 = require("../fs-extra");
+const placeholders_1 = require("../placeholders");
+const shell_1 = require("../shell");
+/**
+ * The size of an empty zip file is 22 bytes
+ *
+ * Ref: https://en.wikipedia.org/wiki/ZIP_(file_format)
+ */
+const EMPTY_ZIP_FILE_SIZE = 22;
+class FileAssetHandler {
+    constructor(workDir, asset, host) {
+        this.workDir = workDir;
+        this.asset = asset;
+        this.host = host;
+        this.fileCacheRoot = path.join(workDir, '.cache');
+    }
+    async build() { }
+    async isPublished() {
+        const destination = await (0, placeholders_1.replaceAwsPlaceholders)(this.asset.destination, this.host.aws);
+        const s3Url = `s3://${destination.bucketName}/${destination.objectKey}`;
+        try {
+            const s3 = await this.host.aws.s3Client({
+                ...(0, client_options_1.destinationToClientOptions)(destination),
+                quiet: true,
+            });
+            this.host.emitMessage(progress_1.EventType.CHECK, `Check ${s3Url}`);
+            if (await objectExists(s3, destination.bucketName, destination.objectKey)) {
+                this.host.emitMessage(progress_1.EventType.FOUND, `Found ${s3Url}`);
+                return true;
+            }
+        }
+        catch (e) {
+            this.host.emitMessage(progress_1.EventType.DEBUG, `${e.message}`);
+        }
+        return false;
+    }
+    async publish(options = {}) {
+        const destination = await (0, placeholders_1.replaceAwsPlaceholders)(this.asset.destination, this.host.aws);
+        const s3Url = `s3://${destination.bucketName}/${destination.objectKey}`;
+        const clientOptions = (0, client_options_1.destinationToClientOptions)(destination);
+        const s3 = await this.host.aws.s3Client(clientOptions);
+        this.host.emitMessage(progress_1.EventType.CHECK, `Check ${s3Url}`);
+        const bucketInfo = BucketInformation.for(this.host);
+        // A thunk for describing the current account. Used when we need to format an error
+        // message, not in the success case.
+        const account = async () => (await this.host.aws.discoverTargetAccount(clientOptions)).accountId;
+        const allowCrossAccount = options.allowCrossAccount ?? true;
+        switch (await bucketInfo.bucketOwnership(s3, destination.bucketName, allowCrossAccount ? undefined : await account())) {
+            case BucketOwnership.MINE:
+                break;
+            case BucketOwnership.DOES_NOT_EXIST:
+                throw new Error(`No bucket named '${destination.bucketName}'. Is account ${await account()} bootstrapped?`);
+            case BucketOwnership.NO_ACCESS:
+                throw new Error(`Bucket named '${destination.bucketName}' exists, but we dont have access to it.`);
+            case BucketOwnership.SOMEONE_ELSES_AND_HAVE_ACCESS:
+                if (!allowCrossAccount) {
+                    throw new Error(`❗❗ UNEXPECTED BUCKET OWNER DETECTED ❗❗
+
+              We've detected that the S3 bucket ${destination.bucketName} was
+              originally created in account ${await account()} as part of the CloudFormation stack CDKToolkit,
+              but now resides in a different AWS account. To prevent cross-account asset bucket access of your
+              deployments, CDK will stop now.
+
+              If this situation is intentional and you own the AWS account that the bucket has moved to, remove the
+              resource named StagingBucket from the template of CloudFormation stack CDKToolkit and try again.
+
+              If this situation is not intentional, we strongly recommend auditing your account to make sure all
+              resources are configured the way you expect them [1]. For questions or concerns, please contact
+              AWS Support [2].
+
+              [1] https://repost.aws/knowledge-center/potential-account-compromise
+
+              [2] https://aws.amazon.com/support`);
+                }
+                break;
+        }
+        if (await objectExists(s3, destination.bucketName, destination.objectKey)) {
+            this.host.emitMessage(progress_1.EventType.FOUND, `Found ${s3Url}`);
+            return;
+        }
+        // Identify the the bucket encryption type to set the header on upload
+        // required for SCP rules denying uploads without encryption header
+        let paramsEncryption = {};
+        const encryption2 = await bucketInfo.bucketEncryption(s3, destination.bucketName);
+        switch (encryption2.type) {
+            case 'no_encryption':
+                break;
+            case 'aes256':
+                paramsEncryption = { ServerSideEncryption: 'AES256' };
+                break;
+            case 'kms':
+                // We must include the key ID otherwise S3 will encrypt with the default key
+                paramsEncryption = {
+                    ServerSideEncryption: 'aws:kms',
+                    SSEKMSKeyId: encryption2.kmsKeyId,
+                };
+                break;
+            case 'does_not_exist':
+                this.host.emitMessage(progress_1.EventType.DEBUG, `No bucket named '${destination.bucketName}'. Is account ${await account()} bootstrapped?`);
+                break;
+            case 'access_denied':
+                this.host.emitMessage(progress_1.EventType.DEBUG, `Could not read encryption settings of bucket '${destination.bucketName}': uploading with default settings ("cdk bootstrap" to version 9 if your organization's policies prevent a successful upload or to get rid of this message).`);
+                break;
+        }
+        if (this.host.aborted) {
+            return;
+        }
+        const publishFile = this.asset.source.executable
+            ? await this.externalPackageFile(this.asset.source.executable)
+            : await this.packageFile(this.asset.source);
+        this.host.emitMessage(progress_1.EventType.UPLOAD, `Upload ${s3Url}`);
+        const params = Object.assign({}, {
+            Bucket: destination.bucketName,
+            Key: destination.objectKey,
+            Body: (0, fs_1.createReadStream)(publishFile.packagedPath),
+            ContentType: publishFile.contentType,
+            ChecksumAlgorithm: 'SHA256',
+        }, paramsEncryption);
+        await s3.upload(params);
+    }
+    async packageFile(source) {
+        if (!source.path) {
+            throw new Error(`'path' is expected in the File asset source, got: ${JSON.stringify(source)}`);
+        }
+        const fullPath = path.resolve(this.workDir, source.path);
+        if (source.packaging === cloud_assembly_schema_1.FileAssetPackaging.ZIP_DIRECTORY) {
+            const contentType = 'application/zip';
+            await fs_1.promises.mkdir(this.fileCacheRoot, { recursive: true });
+            const packagedPath = path.join(this.fileCacheRoot, `${this.asset.id.assetId}.zip`);
+            if (await (0, fs_extra_1.pathExists)(packagedPath)) {
+                this.host.emitMessage(progress_1.EventType.CACHED, `From cache ${packagedPath}`);
+                return { packagedPath, contentType };
+            }
+            this.host.emitMessage(progress_1.EventType.BUILD, `Zip ${fullPath} -> ${packagedPath}`);
+            await (0, archive_1.zipDirectory)(fullPath, packagedPath, (m) => this.host.emitMessage(progress_1.EventType.DEBUG, m));
+            return { packagedPath, contentType };
+        }
+        else {
+            const contentType = mime.getType(fullPath) ?? 'application/octet-stream';
+            return { packagedPath: fullPath, contentType };
+        }
+    }
+    async externalPackageFile(executable) {
+        this.host.emitMessage(progress_1.EventType.BUILD, `Building asset source using command: '${executable}'`);
+        const shellEventPublisher = (0, progress_1.shellEventPublisherFromEventEmitter)(this.host.emitMessage);
+        return {
+            packagedPath: (await (0, shell_1.shell)(executable, { subprocessOutputDestination: 'ignore', shellEventPublisher })).trim(),
+            contentType: 'application/zip',
+        };
+    }
+}
+exports.FileAssetHandler = FileAssetHandler;
+var BucketOwnership;
+(function (BucketOwnership) {
+    BucketOwnership[BucketOwnership["DOES_NOT_EXIST"] = 0] = "DOES_NOT_EXIST";
+    BucketOwnership[BucketOwnership["MINE"] = 1] = "MINE";
+    BucketOwnership[BucketOwnership["NO_ACCESS"] = 2] = "NO_ACCESS";
+    BucketOwnership[BucketOwnership["SOMEONE_ELSES_AND_HAVE_ACCESS"] = 3] = "SOMEONE_ELSES_AND_HAVE_ACCESS";
+})(BucketOwnership || (BucketOwnership = {}));
+async function objectExists(s3, bucket, key) {
+    /*
+     * The object existence check here refrains from using the `headObject` operation because this
+     * would create a negative cache entry, making GET-after-PUT eventually consistent. This has been
+     * observed to result in CloudFormation issuing "ValidationError: S3 error: Access Denied", for
+     * example in https://github.com/aws/aws-cdk/issues/6430.
+     *
+     * To prevent this, we are instead using the listObjectsV2 call, using the looked up key as the
+     * prefix, and limiting results to 1. Since the list operation returns keys ordered by binary
+     * UTF-8 representation, the key we are looking for is guaranteed to always be the first match
+     * returned if it exists.
+     *
+     * If the file is too small, we discount it as a cache hit. There is an issue
+     * somewhere that sometimes produces empty zip files, and we would otherwise
+     * never retry building those assets without users having to manually clear
+     * their bucket, which is a bad experience.
+     */
+    const response = await s3.listObjectsV2({
+        Bucket: bucket,
+        Prefix: key,
+        MaxKeys: 1,
+    });
+    return (response.Contents != null &&
+        response.Contents.some((object) => object.Key === key && (object.Size == null || object.Size > EMPTY_ZIP_FILE_SIZE)));
+}
+/**
+ * Cache for bucket information, so we don't have to keep doing the same calls again and again
+ *
+ * We scope the lifetime of the cache to the lifetime of the host, so that we don't have to do
+ * anything special for tests and yet the cache will live for the entire lifetime of the asset
+ * upload session when used by the CLI.
+ */
+class BucketInformation {
+    static for(host) {
+        const existing = BucketInformation.caches.get(host);
+        if (existing) {
+            return existing;
+        }
+        const fresh = new BucketInformation();
+        BucketInformation.caches.set(host, fresh);
+        return fresh;
+    }
+    constructor() {
+        this.ownerships = new Map();
+        this.encryptions = new Map();
+    }
+    async bucketOwnership(s3, bucket, expectedAccount) {
+        return cached(this.ownerships, bucket, async () => {
+            const anyAccount = await this._bucketOwnership(s3, bucket);
+            switch (anyAccount) {
+                case BucketOwnership.MINE:
+                    if (expectedAccount &&
+                        (await this._bucketOwnership(s3, bucket, expectedAccount)) === BucketOwnership.NO_ACCESS) {
+                        // if the only difference between MINE and NO_ACCESS is the expected account,
+                        // then its definitely someone else's bucket.
+                        return BucketOwnership.SOMEONE_ELSES_AND_HAVE_ACCESS;
+                    }
+                    return BucketOwnership.MINE;
+                default:
+                    return anyAccount;
+            }
+        });
+    }
+    async bucketEncryption(s3, bucket) {
+        return cached(this.encryptions, bucket, () => this._bucketEncryption(s3, bucket));
+    }
+    async _bucketOwnership(s3, bucket, account) {
+        try {
+            await s3.getBucketLocation({ Bucket: bucket, ExpectedBucketOwner: account });
+            return BucketOwnership.MINE;
+        }
+        catch (e) {
+            if (e.name === 'NoSuchBucket') {
+                return BucketOwnership.DOES_NOT_EXIST;
+            }
+            if (['AccessDenied', 'AllAccessDisabled'].includes(e.name)) {
+                return BucketOwnership.NO_ACCESS;
+            }
+            throw e;
+        }
+    }
+    async _bucketEncryption(s3, bucket) {
+        try {
+            const encryption = await s3.getBucketEncryption({ Bucket: bucket });
+            const l = encryption?.ServerSideEncryptionConfiguration?.Rules?.length ?? 0;
+            if (l > 0) {
+                const apply = encryption?.ServerSideEncryptionConfiguration?.Rules?.at(0)?.ApplyServerSideEncryptionByDefault;
+                let ssealgo = apply?.SSEAlgorithm;
+                if (ssealgo === 'AES256')
+                    return { type: 'aes256' };
+                if (ssealgo === 'aws:kms')
+                    return { type: 'kms', kmsKeyId: apply?.KMSMasterKeyID };
+            }
+            return { type: 'no_encryption' };
+        }
+        catch (e) {
+            if (e.name === 'NoSuchBucket') {
+                return { type: 'does_not_exist' };
+            }
+            if (e.name === 'ServerSideEncryptionConfigurationNotFoundError') {
+                return { type: 'no_encryption' };
+            }
+            if (['AccessDenied', 'AllAccessDisabled'].includes(e.name)) {
+                return { type: 'access_denied' };
+            }
+            return { type: 'no_encryption' };
+        }
+    }
+}
+BucketInformation.caches = new WeakMap();
+async function cached(cache, key, factory) {
+    if (cache.has(key)) {
+        return cache.get(key);
+    }
+    const fresh = await factory(key);
+    cache.set(key, fresh);
+    return fresh;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"files.js","sourceRoot":"","sources":["files.ts"],"names":[],"mappings":"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","sourcesContent":["import { createReadStream, promises as fs } from 'fs';\nimport * as path from 'path';\nimport { FileAssetPackaging, FileSource } from '@aws-cdk/cloud-assembly-schema';\nimport * as mime from 'mime';\nimport { destinationToClientOptions } from './client-options';\nimport { FileManifestEntry } from '../../asset-manifest';\nimport { IS3Client } from '../../aws';\nimport { PutObjectCommandInput } from '../../aws-types';\nimport { EventType, shellEventPublisherFromEventEmitter } from '../../progress';\nimport { zipDirectory } from '../archive';\nimport { IAssetHandler, IHandlerHost, type PublishOptions } from '../asset-handler';\nimport { pathExists } from '../fs-extra';\nimport { replaceAwsPlaceholders } from '../placeholders';\nimport { shell } from '../shell';\n\n/**\n * The size of an empty zip file is 22 bytes\n *\n * Ref: https://en.wikipedia.org/wiki/ZIP_(file_format)\n */\nconst EMPTY_ZIP_FILE_SIZE = 22;\n\nexport class FileAssetHandler implements IAssetHandler {\n  private readonly fileCacheRoot: string;\n\n  constructor(\n    private readonly workDir: string,\n    private readonly asset: FileManifestEntry,\n    private readonly host: IHandlerHost,\n  ) {\n    this.fileCacheRoot = path.join(workDir, '.cache');\n  }\n\n  public async build(): Promise<void> {}\n\n  public async isPublished(): Promise<boolean> {\n    const destination = await replaceAwsPlaceholders(this.asset.destination, this.host.aws);\n    const s3Url = `s3://${destination.bucketName}/${destination.objectKey}`;\n    try {\n      const s3 = await this.host.aws.s3Client({\n        ...destinationToClientOptions(destination),\n        quiet: true,\n      });\n      this.host.emitMessage(EventType.CHECK, `Check ${s3Url}`);\n\n      if (await objectExists(s3, destination.bucketName, destination.objectKey)) {\n        this.host.emitMessage(EventType.FOUND, `Found ${s3Url}`);\n        return true;\n      }\n    } catch (e: any) {\n      this.host.emitMessage(EventType.DEBUG, `${e.message}`);\n    }\n    return false;\n  }\n\n  public async publish(options: PublishOptions = {}): Promise<void> {\n    const destination = await replaceAwsPlaceholders(this.asset.destination, this.host.aws);\n    const s3Url = `s3://${destination.bucketName}/${destination.objectKey}`;\n\n    const clientOptions = destinationToClientOptions(destination);\n    const s3 = await this.host.aws.s3Client(clientOptions);\n    this.host.emitMessage(EventType.CHECK, `Check ${s3Url}`);\n\n    const bucketInfo = BucketInformation.for(this.host);\n\n    // A thunk for describing the current account. Used when we need to format an error\n    // message, not in the success case.\n    const account = async () =>\n      (await this.host.aws.discoverTargetAccount(clientOptions)).accountId;\n\n    const allowCrossAccount = options.allowCrossAccount ?? true;\n    switch (\n      await bucketInfo.bucketOwnership(\n        s3,\n        destination.bucketName,\n        allowCrossAccount ? undefined : await account(),\n      )\n    ) {\n      case BucketOwnership.MINE:\n        break;\n      case BucketOwnership.DOES_NOT_EXIST:\n        throw new Error(\n          `No bucket named '${destination.bucketName}'. Is account ${await account()} bootstrapped?`,\n        );\n      case BucketOwnership.NO_ACCESS:\n        throw new Error(\n          `Bucket named '${destination.bucketName}' exists, but we dont have access to it.`,\n        );\n      case BucketOwnership.SOMEONE_ELSES_AND_HAVE_ACCESS:\n        if (!allowCrossAccount) {\n          throw new Error(\n            `❗❗ UNEXPECTED BUCKET OWNER DETECTED ❗❗\n\n              We've detected that the S3 bucket ${destination.bucketName} was\n              originally created in account ${await account()} as part of the CloudFormation stack CDKToolkit,\n              but now resides in a different AWS account. To prevent cross-account asset bucket access of your\n              deployments, CDK will stop now.\n\n              If this situation is intentional and you own the AWS account that the bucket has moved to, remove the\n              resource named StagingBucket from the template of CloudFormation stack CDKToolkit and try again.\n\n              If this situation is not intentional, we strongly recommend auditing your account to make sure all\n              resources are configured the way you expect them [1]. For questions or concerns, please contact\n              AWS Support [2].\n\n              [1] https://repost.aws/knowledge-center/potential-account-compromise\n\n              [2] https://aws.amazon.com/support`,\n          );\n        }\n        break;\n    }\n\n    if (await objectExists(s3, destination.bucketName, destination.objectKey)) {\n      this.host.emitMessage(EventType.FOUND, `Found ${s3Url}`);\n      return;\n    }\n\n    // Identify the the bucket encryption type to set the header on upload\n    // required for SCP rules denying uploads without encryption header\n    let paramsEncryption: { [index: string]: any } = {};\n    const encryption2 = await bucketInfo.bucketEncryption(s3, destination.bucketName);\n    switch (encryption2.type) {\n      case 'no_encryption':\n        break;\n      case 'aes256':\n        paramsEncryption = { ServerSideEncryption: 'AES256' };\n        break;\n      case 'kms':\n        // We must include the key ID otherwise S3 will encrypt with the default key\n        paramsEncryption = {\n          ServerSideEncryption: 'aws:kms',\n          SSEKMSKeyId: encryption2.kmsKeyId,\n        };\n        break;\n      case 'does_not_exist':\n        this.host.emitMessage(\n          EventType.DEBUG,\n          `No bucket named '${destination.bucketName}'. Is account ${await account()} bootstrapped?`,\n        );\n        break;\n      case 'access_denied':\n        this.host.emitMessage(\n          EventType.DEBUG,\n          `Could not read encryption settings of bucket '${destination.bucketName}': uploading with default settings (\"cdk bootstrap\" to version 9 if your organization's policies prevent a successful upload or to get rid of this message).`,\n        );\n        break;\n    }\n\n    if (this.host.aborted) {\n      return;\n    }\n    const publishFile = this.asset.source.executable\n      ? await this.externalPackageFile(this.asset.source.executable)\n      : await this.packageFile(this.asset.source);\n\n    this.host.emitMessage(EventType.UPLOAD, `Upload ${s3Url}`);\n\n    const params = Object.assign(\n      {},\n      {\n        Bucket: destination.bucketName,\n        Key: destination.objectKey,\n        Body: createReadStream(publishFile.packagedPath),\n        ContentType: publishFile.contentType,\n        ChecksumAlgorithm: 'SHA256',\n      } satisfies PutObjectCommandInput,\n      paramsEncryption,\n    );\n\n    await s3.upload(params);\n  }\n\n  private async packageFile(source: FileSource): Promise<PackagedFileAsset> {\n    if (!source.path) {\n      throw new Error(\n        `'path' is expected in the File asset source, got: ${JSON.stringify(source)}`,\n      );\n    }\n\n    const fullPath = path.resolve(this.workDir, source.path);\n\n    if (source.packaging === FileAssetPackaging.ZIP_DIRECTORY) {\n      const contentType = 'application/zip';\n\n      await fs.mkdir(this.fileCacheRoot, { recursive: true });\n      const packagedPath = path.join(this.fileCacheRoot, `${this.asset.id.assetId}.zip`);\n\n      if (await pathExists(packagedPath)) {\n        this.host.emitMessage(EventType.CACHED, `From cache ${packagedPath}`);\n        return { packagedPath, contentType };\n      }\n\n      this.host.emitMessage(EventType.BUILD, `Zip ${fullPath} -> ${packagedPath}`);\n      await zipDirectory(fullPath, packagedPath, (m) => this.host.emitMessage(EventType.DEBUG, m));\n      return { packagedPath, contentType };\n    } else {\n      const contentType = mime.getType(fullPath) ?? 'application/octet-stream';\n      return { packagedPath: fullPath, contentType };\n    }\n  }\n\n  private async externalPackageFile(executable: string[]): Promise<PackagedFileAsset> {\n    this.host.emitMessage(EventType.BUILD, `Building asset source using command: '${executable}'`);\n\n    const shellEventPublisher = shellEventPublisherFromEventEmitter(this.host.emitMessage);\n\n    return {\n      packagedPath: (\n        await shell(executable, { subprocessOutputDestination: 'ignore', shellEventPublisher })\n      ).trim(),\n      contentType: 'application/zip',\n    };\n  }\n}\n\nenum BucketOwnership {\n  DOES_NOT_EXIST,\n  MINE,\n  NO_ACCESS,\n  SOMEONE_ELSES_AND_HAVE_ACCESS,\n}\n\ntype BucketEncryption =\n  | { readonly type: 'no_encryption' }\n  | { readonly type: 'aes256' }\n  | { readonly type: 'kms'; readonly kmsKeyId?: string }\n  | { readonly type: 'access_denied' }\n  | { readonly type: 'does_not_exist' };\n\nasync function objectExists(s3: IS3Client, bucket: string, key: string) {\n  /*\n   * The object existence check here refrains from using the `headObject` operation because this\n   * would create a negative cache entry, making GET-after-PUT eventually consistent. This has been\n   * observed to result in CloudFormation issuing \"ValidationError: S3 error: Access Denied\", for\n   * example in https://github.com/aws/aws-cdk/issues/6430.\n   *\n   * To prevent this, we are instead using the listObjectsV2 call, using the looked up key as the\n   * prefix, and limiting results to 1. Since the list operation returns keys ordered by binary\n   * UTF-8 representation, the key we are looking for is guaranteed to always be the first match\n   * returned if it exists.\n   *\n   * If the file is too small, we discount it as a cache hit. There is an issue\n   * somewhere that sometimes produces empty zip files, and we would otherwise\n   * never retry building those assets without users having to manually clear\n   * their bucket, which is a bad experience.\n   */\n  const response = await s3.listObjectsV2({\n    Bucket: bucket,\n    Prefix: key,\n    MaxKeys: 1,\n  });\n  return (\n    response.Contents != null &&\n    response.Contents.some(\n      (object) => object.Key === key && (object.Size == null || object.Size > EMPTY_ZIP_FILE_SIZE),\n    )\n  );\n}\n\n/**\n * A packaged asset which can be uploaded (either a single file or directory)\n */\ninterface PackagedFileAsset {\n  /**\n   * Path of the file or directory\n   */\n  readonly packagedPath: string;\n\n  /**\n   * Content type to be added in the S3 upload action\n   *\n   * @default - No content type\n   */\n  readonly contentType?: string;\n}\n\n/**\n * Cache for bucket information, so we don't have to keep doing the same calls again and again\n *\n * We scope the lifetime of the cache to the lifetime of the host, so that we don't have to do\n * anything special for tests and yet the cache will live for the entire lifetime of the asset\n * upload session when used by the CLI.\n */\nclass BucketInformation {\n  public static for(host: IHandlerHost) {\n    const existing = BucketInformation.caches.get(host);\n    if (existing) {\n      return existing;\n    }\n\n    const fresh = new BucketInformation();\n    BucketInformation.caches.set(host, fresh);\n    return fresh;\n  }\n\n  private static readonly caches = new WeakMap<IHandlerHost, BucketInformation>();\n\n  private readonly ownerships = new Map<string, BucketOwnership>();\n  private readonly encryptions = new Map<string, BucketEncryption>();\n\n  private constructor() {}\n\n  public async bucketOwnership(\n    s3: IS3Client,\n    bucket: string,\n    expectedAccount?: string,\n  ): Promise<BucketOwnership> {\n    return cached(this.ownerships, bucket, async () => {\n      const anyAccount = await this._bucketOwnership(s3, bucket);\n\n      switch (anyAccount) {\n        case BucketOwnership.MINE:\n          if (\n            expectedAccount &&\n            (await this._bucketOwnership(s3, bucket, expectedAccount)) === BucketOwnership.NO_ACCESS\n          ) {\n            // if the only difference between MINE and NO_ACCESS is the expected account,\n            // then its definitely someone else's bucket.\n            return BucketOwnership.SOMEONE_ELSES_AND_HAVE_ACCESS;\n          }\n          return BucketOwnership.MINE;\n        default:\n          return anyAccount;\n      }\n    });\n  }\n\n  public async bucketEncryption(s3: IS3Client, bucket: string): Promise<BucketEncryption> {\n    return cached(this.encryptions, bucket, () => this._bucketEncryption(s3, bucket));\n  }\n\n  private async _bucketOwnership(\n    s3: IS3Client,\n    bucket: string,\n    account?: string,\n  ): Promise<BucketOwnership.MINE | BucketOwnership.DOES_NOT_EXIST | BucketOwnership.NO_ACCESS> {\n    try {\n      await s3.getBucketLocation({ Bucket: bucket, ExpectedBucketOwner: account });\n      return BucketOwnership.MINE;\n    } catch (e: any) {\n      if (e.name === 'NoSuchBucket') {\n        return BucketOwnership.DOES_NOT_EXIST;\n      }\n      if (['AccessDenied', 'AllAccessDisabled'].includes(e.name)) {\n        return BucketOwnership.NO_ACCESS;\n      }\n      throw e;\n    }\n  }\n\n  private async _bucketEncryption(s3: IS3Client, bucket: string): Promise<BucketEncryption> {\n    try {\n      const encryption = await s3.getBucketEncryption({ Bucket: bucket });\n      const l = encryption?.ServerSideEncryptionConfiguration?.Rules?.length ?? 0;\n      if (l > 0) {\n        const apply =\n          encryption?.ServerSideEncryptionConfiguration?.Rules?.at(\n            0,\n          )?.ApplyServerSideEncryptionByDefault;\n        let ssealgo = apply?.SSEAlgorithm;\n        if (ssealgo === 'AES256') return { type: 'aes256' };\n        if (ssealgo === 'aws:kms') return { type: 'kms', kmsKeyId: apply?.KMSMasterKeyID };\n      }\n      return { type: 'no_encryption' };\n    } catch (e: any) {\n      if (e.name === 'NoSuchBucket') {\n        return { type: 'does_not_exist' };\n      }\n      if (e.name === 'ServerSideEncryptionConfigurationNotFoundError') {\n        return { type: 'no_encryption' };\n      }\n\n      if (['AccessDenied', 'AllAccessDisabled'].includes(e.name)) {\n        return { type: 'access_denied' };\n      }\n      return { type: 'no_encryption' };\n    }\n  }\n}\n\nasync function cached<A, B>(cache: Map<A, B>, key: A, factory: (x: A) => Promise<B>): Promise<B> {\n  if (cache.has(key)) {\n    return cache.get(key)!;\n  }\n\n  const fresh = await factory(key);\n  cache.set(key, fresh);\n  return fresh;\n}\n"]}

package/lib/private/handlers/index.d.ts

@@ -0,0 +1,3 @@
+import { type AssetManifest, type IManifestEntry } from '../../asset-manifest';
+import type { IAssetHandler, IHandlerHost, IHandlerOptions } from '../asset-handler';
+export declare function makeAssetHandler(manifest: AssetManifest, asset: IManifestEntry, host: IHandlerHost, options: IHandlerOptions): IAssetHandler;

package/lib/private/handlers/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAssetHandler = makeAssetHandler;
+const container_images_1 = require("./container-images");
+const files_1 = require("./files");
+const asset_manifest_1 = require("../../asset-manifest");
+function makeAssetHandler(manifest, asset, host, options) {
+    if (asset instanceof asset_manifest_1.FileManifestEntry) {
+        return new files_1.FileAssetHandler(manifest.directory, asset, host);
+    }
+    if (asset instanceof asset_manifest_1.DockerImageManifestEntry) {
+        return new container_images_1.ContainerImageAssetHandler(manifest.directory, asset, host, options);
+    }
+    throw new Error(`Unrecognized asset type: '${asset}'`);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQVVBLDRDQWNDO0FBeEJELHlEQUFnRTtBQUNoRSxtQ0FBMkM7QUFDM0MseURBSzhCO0FBRzlCLFNBQWdCLGdCQUFnQixDQUM5QixRQUF1QixFQUN2QixLQUFxQixFQUNyQixJQUFrQixFQUNsQixPQUF3QjtJQUV4QixJQUFJLEtBQUssWUFBWSxrQ0FBaUIsRUFBRSxDQUFDO1FBQ3ZDLE9BQU8sSUFBSSx3QkFBZ0IsQ0FBQyxRQUFRLENBQUMsU0FBUyxFQUFFLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQztJQUMvRCxDQUFDO0lBQ0QsSUFBSSxLQUFLLFlBQVkseUNBQXdCLEVBQUUsQ0FBQztRQUM5QyxPQUFPLElBQUksNkNBQTBCLENBQUMsUUFBUSxDQUFDLFNBQVMsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ2xGLENBQUM7SUFFRCxNQUFNLElBQUksS0FBSyxDQUFDLDZCQUE2QixLQUFLLEdBQUcsQ0FBQyxDQUFDO0FBQ3pELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb250YWluZXJJbWFnZUFzc2V0SGFuZGxlciB9IGZyb20gJy4vY29udGFpbmVyLWltYWdlcyc7XG5pbXBvcnQgeyBGaWxlQXNzZXRIYW5kbGVyIH0gZnJvbSAnLi9maWxlcyc7XG5pbXBvcnQge1xuICB0eXBlIEFzc2V0TWFuaWZlc3QsXG4gIERvY2tlckltYWdlTWFuaWZlc3RFbnRyeSxcbiAgRmlsZU1hbmlmZXN0RW50cnksXG4gIHR5cGUgSU1hbmlmZXN0RW50cnksXG59IGZyb20gJy4uLy4uL2Fzc2V0LW1hbmlmZXN0JztcbmltcG9ydCB0eXBlIHsgSUFzc2V0SGFuZGxlciwgSUhhbmRsZXJIb3N0LCBJSGFuZGxlck9wdGlvbnMgfSBmcm9tICcuLi9hc3NldC1oYW5kbGVyJztcblxuZXhwb3J0IGZ1bmN0aW9uIG1ha2VBc3NldEhhbmRsZXIoXG4gIG1hbmlmZXN0OiBBc3NldE1hbmlmZXN0LFxuICBhc3NldDogSU1hbmlmZXN0RW50cnksXG4gIGhvc3Q6IElIYW5kbGVySG9zdCxcbiAgb3B0aW9uczogSUhhbmRsZXJPcHRpb25zLFxuKTogSUFzc2V0SGFuZGxlciB7XG4gIGlmIChhc3NldCBpbnN0YW5jZW9mIEZpbGVNYW5pZmVzdEVudHJ5KSB7XG4gICAgcmV0dXJuIG5ldyBGaWxlQXNzZXRIYW5kbGVyKG1hbmlmZXN0LmRpcmVjdG9yeSwgYXNzZXQsIGhvc3QpO1xuICB9XG4gIGlmIChhc3NldCBpbnN0YW5jZW9mIERvY2tlckltYWdlTWFuaWZlc3RFbnRyeSkge1xuICAgIHJldHVybiBuZXcgQ29udGFpbmVySW1hZ2VBc3NldEhhbmRsZXIobWFuaWZlc3QuZGlyZWN0b3J5LCBhc3NldCwgaG9zdCwgb3B0aW9ucyk7XG4gIH1cblxuICB0aHJvdyBuZXcgRXJyb3IoYFVucmVjb2duaXplZCBhc3NldCB0eXBlOiAnJHthc3NldH0nYCk7XG59XG4iXX0=

package/lib/private/p-limit.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A minimal  of p-limit that does not bring in new dependencies, and is not ESM.
+ */
+type PromiseFactory<A> = () => Promise<A>;
+export declare function pLimit(concurrency: number): PLimit;
+interface PLimit {
+    dispose(): void;
+    <A>(promiseFactory: PromiseFactory<A>): Promise<A>;
+}
+export {};

package/lib/private/p-limit.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * A minimal  of p-limit that does not bring in new dependencies, and is not ESM.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pLimit = pLimit;
+function pLimit(concurrency) {
+    const queue = [];
+    let activeCount = 0;
+    let stopped = false;
+    function dispatch() {
+        if (activeCount < concurrency && queue.length > 0) {
+            const [fac, resolve, reject] = queue.shift();
+            activeCount++;
+            fac().then((r) => {
+                // Start a new job before reporting back on the previous one
+                resumeNext();
+                resolve(r);
+            }, (e) => {
+                // Start a new job before reporting back on the previous one
+                resumeNext();
+                reject(e);
+            });
+        }
+    }
+    function resumeNext() {
+        activeCount--;
+        if (stopped) {
+            for (const [_, __, reject] of queue) {
+                reject(new Error('Task has been cancelled'));
+            }
+            queue.splice(0, queue.length);
+        }
+        dispatch();
+    }
+    const ret = (promiseFactory) => {
+        return new Promise((resolve, reject) => {
+            queue.push([promiseFactory, resolve, reject]);
+            dispatch();
+        });
+    };
+    Object.defineProperties(ret, {
+        dispose: {
+            value: () => {
+                stopped = true;
+            },
+        },
+    });
+    return ret;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/private/placeholders.d.ts

@@ -0,0 +1,10 @@
+import { IAws } from '../aws';
+/**
+ * Replace the {ACCOUNT} and {REGION} placeholders in all strings found in a complex object.
+ *
+ * Duplicated between cdk-assets and aws-cdk CLI because we don't have a good single place to put it
+ * (they're nominally independent tools).
+ */
+export declare function replaceAwsPlaceholders<A extends {
+    region?: string;
+}>(object: A, aws: IAws): Promise<A>;

package/lib/private/placeholders.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceAwsPlaceholders = replaceAwsPlaceholders;
+const cx_api_1 = require("@aws-cdk/cx-api");
+/**
+ * Replace the {ACCOUNT} and {REGION} placeholders in all strings found in a complex object.
+ *
+ * Duplicated between cdk-assets and aws-cdk CLI because we don't have a good single place to put it
+ * (they're nominally independent tools).
+ */
+async function replaceAwsPlaceholders(object, aws) {
+    let partition = async () => {
+        const p = await aws.discoverPartition();
+        partition = () => Promise.resolve(p);
+        return p;
+    };
+    let account = async () => {
+        const a = await aws.discoverCurrentAccount();
+        account = () => Promise.resolve(a);
+        return a;
+    };
+    return cx_api_1.EnvironmentPlaceholders.replaceAsync(object, {
+        async region() {
+            return object.region ?? aws.discoverDefaultRegion();
+        },
+        async accountId() {
+            return (await account()).accountId;
+        },
+        async partition() {
+            return partition();
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/private/shell.d.ts

@@ -0,0 +1,24 @@
+import * as child_process from 'child_process';
+import { SubprocessOutputDestination } from './asset-handler';
+export type ShellEventType = 'open' | 'data_stdout' | 'data_stderr' | 'close';
+export type ShellEventPublisher = (event: ShellEventType, message: string) => void;
+export interface ShellOptions extends child_process.SpawnOptions {
+    readonly shellEventPublisher: ShellEventPublisher;
+    readonly input?: string;
+    readonly subprocessOutputDestination?: SubprocessOutputDestination;
+}
+/**
+ * OS helpers
+ *
+ * Shell function which both prints to stdout and collects the output into a
+ * string.
+ */
+export declare function shell(command: string[], options: ShellOptions): Promise<string>;
+export type ProcessFailedError = ProcessFailed;
+declare class ProcessFailed extends Error {
+    readonly exitCode: number | null;
+    readonly signal: NodeJS.Signals | null;
+    readonly code = "PROCESS_FAILED";
+    constructor(exitCode: number | null, signal: NodeJS.Signals | null, message: string);
+}
+export {};