@cloudsnorkel/cdk-github-runners 0.14.18 → 0.14.19

package/lib/image-builders/aws-image-builder/ami.d.ts

@@ -1,5 +1,6 @@
 import * as cdk from 'aws-cdk-lib';
 import { Construct } from 'constructs';
+import { BaseImage } from './base-image';
 import { ImageBuilderComponent } from './builder';
 import { Architecture, Os } from '../../providers';
 /**
@@ -19,7 +20,7 @@ interface AmiRecipeProperties {
     /**
      * Base AMI to use for the new runner AMI.
      */
-    readonly baseAmi: string;
+    readonly baseAmi: BaseImage;
     /**
      * Storage size for the builder.
      */
@@ -51,5 +52,5 @@ export declare class AmiRecipe extends cdk.Resource {
  *
  * @internal
  */
-export declare function defaultBaseAmi(scope: Construct, os: Os, architecture: Architecture): string;
+export declare function defaultBaseAmi(scope: Construct, os: Os, architecture: Architecture): BaseImage;
 export {};

package/lib/image-builders/aws-image-builder/ami.js

@@ -4,6 +4,7 @@ exports.AmiRecipe = void 0;
 exports.defaultBaseAmi = defaultBaseAmi;
 const cdk = require("aws-cdk-lib");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
+const base_image_1 = require("./base-image");
 const providers_1 = require("../../providers");
 const common_1 = require("../common");
 /**
@@ -21,7 +22,7 @@ class AmiRecipe extends cdk.Resource {
         });
         const blockDeviceMappings = props.storageSize ? [
             {
-                deviceName: (0, providers_1.amiRootDevice)(this, props.baseAmi).ref,
+                deviceName: (0, providers_1.amiRootDevice)(this, props.baseAmi.image).ref,
                 ebs: {
                     volumeSize: props.storageSize.toGibibytes(),
                     deleteOnTermination: true,
@@ -42,7 +43,7 @@ class AmiRecipe extends cdk.Resource {
         const recipe = new aws_cdk_lib_1.aws_imagebuilder.CfnImageRecipe(this, 'Recipe', {
             name: this.name,
             version: '1.0.x',
-            parentImage: props.baseAmi,
+            parentImage: props.baseAmi.image,
             components,
             workingDirectory,
             tags: props.tags,
@@ -59,7 +60,6 @@ exports.AmiRecipe = AmiRecipe;
  * @internal
  */
 function defaultBaseAmi(scope, os, architecture) {
-    const stack = cdk.Stack.of(scope);
     let arch;
     if (architecture.is(providers_1.Architecture.X86_64)) {
         arch = 'x86';
@@ -71,45 +71,20 @@ function defaultBaseAmi(scope, os, architecture) {
         throw new Error(`Unsupported architecture for base AMI: ${architecture.name}`);
     }
     if (os.is(providers_1.Os.LINUX_UBUNTU) || os.is(providers_1.Os.LINUX_UBUNTU_2204) || os.is(providers_1.Os.LINUX)) {
-        return stack.formatArn({
-            service: 'imagebuilder',
-            resource: 'image',
-            account: 'aws',
-            resourceName: `ubuntu-server-22-lts-${arch}/x.x.x`,
-        });
+        return base_image_1.BaseImage.fromImageBuilder(scope, `ubuntu-server-22-lts-${arch}`);
     }
     if (os.is(providers_1.Os.LINUX_UBUNTU_2404)) {
-        return stack.formatArn({
-            service: 'imagebuilder',
-            resource: 'image',
-            account: 'aws',
-            resourceName: `ubuntu-server-24-lts-${arch}/x.x.x`,
-        });
+        return base_image_1.BaseImage.fromImageBuilder(scope, `ubuntu-server-24-lts-${arch}`);
     }
     if (os.is(providers_1.Os.LINUX_AMAZON_2)) {
-        return stack.formatArn({
-            service: 'imagebuilder',
-            resource: 'image',
-            account: 'aws',
-            resourceName: `amazon-linux-2-${arch}/x.x.x`,
-        });
+        return base_image_1.BaseImage.fromImageBuilder(scope, `amazon-linux-2-${arch}`);
     }
     if (os.is(providers_1.Os.LINUX_AMAZON_2023)) {
-        return stack.formatArn({
-            service: 'imagebuilder',
-            resource: 'image',
-            account: 'aws',
-            resourceName: `amazon-linux-2023-${arch}/x.x.x`,
-        });
+        return base_image_1.BaseImage.fromImageBuilder(scope, `amazon-linux-2023-${arch}`);
     }
     if (os.is(providers_1.Os.WINDOWS)) {
-        return stack.formatArn({
-            service: 'imagebuilder',
-            resource: 'image',
-            account: 'aws',
-            resourceName: `windows-server-2022-english-full-base-${arch}/x.x.x`,
-        });
+        return base_image_1.BaseImage.fromImageBuilder(scope, `windows-server-2022-english-full-base-${arch}`);
     }
     throw new Error(`OS ${os.name} not supported for AMI runner image`);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ami.js","sourceRoot":"","sources":["../../../src/image-builders/aws-image-builder/ami.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport { aws_imagebuilder as imagebuilder } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { ImageBuilderComponent } from './builder';\nimport { amiRootDevice, Architecture, Os } from '../../providers';\nimport { uniqueImageBuilderName } from '../common';\n\n/**\n * Properties for AmiRecipe construct.\n *\n * @internal\n */\ninterface AmiRecipeProperties {\n  /**\n   * Target platform. Must match builder platform.\n   */\n  readonly platform: 'Linux' | 'Windows';\n\n  /**\n   * Target architecture. Must match builder platform.\n   */\n  readonly architecture: Architecture;\n\n  /**\n   * Base AMI to use for the new runner AMI.\n   */\n  readonly baseAmi: string;\n\n  /**\n   * Storage size for the builder.\n   */\n  readonly storageSize?: cdk.Size;\n\n  /**\n   * Components to add to target container image.\n   */\n  readonly components: ImageBuilderComponent[];\n\n  /**\n   * Tags to apply to the recipe and image.\n   */\n  readonly tags: { [key: string]: string };\n}\n\n/**\n * Image builder recipe for Amazon Machine Image (AMI).\n *\n * @internal\n */\nexport class AmiRecipe extends cdk.Resource {\n  public readonly arn: string;\n  public readonly name: string;\n  public readonly version: string;\n\n  constructor(scope: Construct, id: string, props: AmiRecipeProperties) {\n    super(scope, id);\n\n    let components = props.components.map(component => {\n      return {\n        componentArn: component.arn,\n      };\n    });\n\n    const blockDeviceMappings = props.storageSize ? [\n      {\n        deviceName: amiRootDevice(this, props.baseAmi).ref,\n        ebs: {\n          volumeSize: props.storageSize.toGibibytes(),\n          deleteOnTermination: true,\n        },\n      },\n    ] : undefined;\n\n    this.name = uniqueImageBuilderName(this);\n\n    let workingDirectory;\n    if (props.platform == 'Linux') {\n      workingDirectory = '/home/runner';\n    } else if (props.platform == 'Windows') {\n      workingDirectory = 'C:/'; // must exist or Image Builder fails and must not be empty or git will stall installing from the default windows\\system32\n    } else {\n      throw new Error(`Unsupported AMI recipe platform: ${props.platform}`);\n    }\n\n    const recipe = new imagebuilder.CfnImageRecipe(this, 'Recipe', {\n      name: this.name,\n      version: '1.0.x',\n      parentImage: props.baseAmi,\n      components,\n      workingDirectory,\n      tags: props.tags,\n      blockDeviceMappings,\n    });\n\n    this.arn = recipe.attrArn;\n    this.version = recipe.getAtt('Version', cdk.ResolutionTypeHint.STRING).toString();\n  }\n}\n\n/**\n * Default base AMI for given OS and architecture.\n *\n * @internal\n */\nexport function defaultBaseAmi(scope: Construct, os: Os, architecture: Architecture) {\n  const stack = cdk.Stack.of(scope);\n\n  let arch;\n  if (architecture.is(Architecture.X86_64)) {\n    arch = 'x86';\n  } else if (architecture.is(Architecture.ARM64)) {\n    arch = 'arm64';\n  } else {\n    throw new Error(`Unsupported architecture for base AMI: ${architecture.name}`);\n  }\n\n  if (os.is(Os.LINUX_UBUNTU) || os.is(Os.LINUX_UBUNTU_2204) || os.is(Os.LINUX)) {\n    return stack.formatArn({\n      service: 'imagebuilder',\n      resource: 'image',\n      account: 'aws',\n      resourceName: `ubuntu-server-22-lts-${arch}/x.x.x`,\n    });\n  }\n\n  if (os.is(Os.LINUX_UBUNTU_2404)) {\n    return stack.formatArn({\n      service: 'imagebuilder',\n      resource: 'image',\n      account: 'aws',\n      resourceName: `ubuntu-server-24-lts-${arch}/x.x.x`,\n    });\n  }\n\n  if (os.is(Os.LINUX_AMAZON_2)) {\n    return stack.formatArn({\n      service: 'imagebuilder',\n      resource: 'image',\n      account: 'aws',\n      resourceName: `amazon-linux-2-${arch}/x.x.x`,\n    });\n  }\n\n  if (os.is(Os.LINUX_AMAZON_2023)) {\n    return stack.formatArn({\n      service: 'imagebuilder',\n      resource: 'image',\n      account: 'aws',\n      resourceName: `amazon-linux-2023-${arch}/x.x.x`,\n    });\n  }\n\n  if (os.is(Os.WINDOWS)) {\n    return stack.formatArn({\n      service: 'imagebuilder',\n      resource: 'image',\n      account: 'aws',\n      resourceName: `windows-server-2022-english-full-base-${arch}/x.x.x`,\n    });\n  }\n\n  throw new Error(`OS ${os.name} not supported for AMI runner image`);\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ami.js","sourceRoot":"","sources":["../../../src/image-builders/aws-image-builder/ami.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport { aws_imagebuilder as imagebuilder } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { BaseImage } from './base-image';\nimport { ImageBuilderComponent } from './builder';\nimport { amiRootDevice, Architecture, Os } from '../../providers';\nimport { uniqueImageBuilderName } from '../common';\n\n/**\n * Properties for AmiRecipe construct.\n *\n * @internal\n */\ninterface AmiRecipeProperties {\n  /**\n   * Target platform. Must match builder platform.\n   */\n  readonly platform: 'Linux' | 'Windows';\n\n  /**\n   * Target architecture. Must match builder platform.\n   */\n  readonly architecture: Architecture;\n\n  /**\n   * Base AMI to use for the new runner AMI.\n   */\n  readonly baseAmi: BaseImage;\n\n  /**\n   * Storage size for the builder.\n   */\n  readonly storageSize?: cdk.Size;\n\n  /**\n   * Components to add to target container image.\n   */\n  readonly components: ImageBuilderComponent[];\n\n  /**\n   * Tags to apply to the recipe and image.\n   */\n  readonly tags: { [key: string]: string };\n}\n\n/**\n * Image builder recipe for Amazon Machine Image (AMI).\n *\n * @internal\n */\nexport class AmiRecipe extends cdk.Resource {\n  public readonly arn: string;\n  public readonly name: string;\n  public readonly version: string;\n\n  constructor(scope: Construct, id: string, props: AmiRecipeProperties) {\n    super(scope, id);\n\n    let components = props.components.map(component => {\n      return {\n        componentArn: component.arn,\n      };\n    });\n\n    const blockDeviceMappings = props.storageSize ? [\n      {\n        deviceName: amiRootDevice(this, props.baseAmi.image).ref,\n        ebs: {\n          volumeSize: props.storageSize.toGibibytes(),\n          deleteOnTermination: true,\n        },\n      },\n    ] : undefined;\n\n    this.name = uniqueImageBuilderName(this);\n\n    let workingDirectory;\n    if (props.platform == 'Linux') {\n      workingDirectory = '/home/runner';\n    } else if (props.platform == 'Windows') {\n      workingDirectory = 'C:/'; // must exist or Image Builder fails and must not be empty or git will stall installing from the default windows\\system32\n    } else {\n      throw new Error(`Unsupported AMI recipe platform: ${props.platform}`);\n    }\n\n    const recipe = new imagebuilder.CfnImageRecipe(this, 'Recipe', {\n      name: this.name,\n      version: '1.0.x',\n      parentImage: props.baseAmi.image,\n      components,\n      workingDirectory,\n      tags: props.tags,\n      blockDeviceMappings,\n    });\n\n    this.arn = recipe.attrArn;\n    this.version = recipe.getAtt('Version', cdk.ResolutionTypeHint.STRING).toString();\n  }\n}\n\n/**\n * Default base AMI for given OS and architecture.\n *\n * @internal\n */\nexport function defaultBaseAmi(scope: Construct, os: Os, architecture: Architecture): BaseImage {\n  let arch;\n  if (architecture.is(Architecture.X86_64)) {\n    arch = 'x86';\n  } else if (architecture.is(Architecture.ARM64)) {\n    arch = 'arm64';\n  } else {\n    throw new Error(`Unsupported architecture for base AMI: ${architecture.name}`);\n  }\n\n  if (os.is(Os.LINUX_UBUNTU) || os.is(Os.LINUX_UBUNTU_2204) || os.is(Os.LINUX)) {\n    return BaseImage.fromImageBuilder(scope, `ubuntu-server-22-lts-${arch}`);\n  }\n\n  if (os.is(Os.LINUX_UBUNTU_2404)) {\n    return BaseImage.fromImageBuilder(scope, `ubuntu-server-24-lts-${arch}`);\n  }\n\n  if (os.is(Os.LINUX_AMAZON_2)) {\n    return BaseImage.fromImageBuilder(scope, `amazon-linux-2-${arch}`);\n  }\n\n  if (os.is(Os.LINUX_AMAZON_2023)) {\n    return BaseImage.fromImageBuilder(scope, `amazon-linux-2023-${arch}`);\n  }\n\n  if (os.is(Os.WINDOWS)) {\n    return BaseImage.fromImageBuilder(scope, `windows-server-2022-english-full-base-${arch}`);\n  }\n\n  throw new Error(`OS ${os.name} not supported for AMI runner image`);\n}\n\n"]}

package/lib/image-builders/aws-image-builder/base-image.d.ts

@@ -0,0 +1,118 @@
+import * as ecr from 'aws-cdk-lib/aws-ecr';
+import * as ssm from 'aws-cdk-lib/aws-ssm';
+import { Construct } from 'constructs';
+/**
+ * Type that can be used to specify a base image - either a string (deprecated) or a BaseImage object.
+ *
+ * To create a BaseImage object, use the static factory methods like BaseImage.fromAmiId().
+ *
+ * Note: String support is deprecated and will be removed in a future version. Use BaseImage static factory methods instead.
+ */
+export type BaseImageInput = string | BaseImage;
+/**
+ * Represents a base image that is used to start from in EC2 Image Builder image builds.
+ *
+ * This class is adapted from AWS CDK's BaseImage class to support both string and object inputs.
+ */
+export declare class BaseImage {
+    /**
+     * The AMI ID to use as a base image in an image recipe
+     *
+     * @param amiId The AMI ID to use as the base image
+     */
+    static fromAmiId(amiId: string): BaseImage;
+    /**
+     * An AWS-provided EC2 Image Builder image to use as a base image in an image recipe.
+     *
+     * This constructs an Image Builder ARN for AWS-provided images like `ubuntu-server-22-lts-x86/x.x.x`.
+     *
+     * @param scope The construct scope (used to determine the stack and region)
+     * @param resourceName The Image Builder resource name pattern (e.g., `ubuntu-server-22-lts-x86` or `ubuntu-server-22-lts-${arch}`)
+     * @param version The version pattern (defaults to `x.x.x` to use the latest version)
+     */
+    static fromImageBuilder(scope: Construct, resourceName: string, version?: string): BaseImage;
+    /**
+     * The marketplace product ID for an AMI product to use as the base image in an image recipe
+     *
+     * @param productId The Marketplace AMI product ID to use as the base image
+     */
+    static fromMarketplaceProductId(productId: string): BaseImage;
+    /**
+     * The SSM parameter to use as the base image in an image recipe
+     *
+     * @param parameter The SSM parameter to use as the base image
+     */
+    static fromSsmParameter(parameter: ssm.IParameter): BaseImage;
+    /**
+     * The parameter name for the SSM parameter to use as the base image in an image recipe
+     *
+     * @param parameterName The name of the SSM parameter to use as the base image
+     */
+    static fromSsmParameterName(parameterName: string): BaseImage;
+    /**
+     * The direct string value of the base image to use in an image recipe. This can be an EC2 Image Builder image ARN,
+     * an SSM parameter, an AWS Marketplace product ID, or an AMI ID.
+     *
+     * @param baseImageString The base image as a direct string value
+     */
+    static fromString(baseImageString: string): BaseImage;
+    /**
+     * The rendered base image to use
+     */
+    readonly image: string;
+    protected constructor(image: string);
+}
+/**
+ * Type that can be used to specify a base container image - either a string (deprecated) or a BaseContainerImage object.
+ *
+ * To create a BaseContainerImage object, use the static factory methods like BaseContainerImage.fromEcr().
+ *
+ * Note: String support is deprecated and will be removed in a future version. Use BaseContainerImage static factory methods instead.
+ */
+export type BaseContainerImageInput = string | BaseContainerImage;
+/**
+ * Represents a base container image that is used to start from in EC2 Image Builder container builds.
+ *
+ * This class is adapted from AWS CDK's BaseContainerImage class to support both string and object inputs.
+ */
+export declare class BaseContainerImage {
+    /**
+     * The DockerHub image to use as the base image in a container recipe
+     *
+     * @param repository The DockerHub repository where the base image resides in
+     * @param tag The tag of the base image in the DockerHub repository
+     */
+    static fromDockerHub(repository: string, tag: string): BaseContainerImage;
+    /**
+     * The ECR container image to use as the base image in a container recipe
+     *
+     * @param repository The ECR repository where the base image resides in
+     * @param tag The tag of the base image in the ECR repository
+     */
+    static fromEcr(repository: ecr.IRepository, tag: string): BaseContainerImage;
+    /**
+     * The ECR public container image to use as the base image in a container recipe
+     *
+     * @param registryAlias The alias of the ECR public registry where the base image resides in
+     * @param repositoryName The name of the ECR public repository, where the base image resides in
+     * @param tag The tag of the base image in the ECR public repository
+     */
+    static fromEcrPublic(registryAlias: string, repositoryName: string, tag: string): BaseContainerImage;
+    /**
+     * The string value of the base image to use in a container recipe. This can be an EC2 Image Builder image ARN,
+     * an ECR or ECR public image, or a container URI sourced from a third-party container registry such as DockerHub.
+     *
+     * @param baseContainerImageString The base image as a direct string value
+     */
+    static fromString(baseContainerImageString: string): BaseContainerImage;
+    /**
+     * The rendered base image to use
+     */
+    readonly image: string;
+    /**
+     * The ECR repository if this image was created from an ECR repository.
+     * This allows automatic permission granting for CodeBuild.
+     */
+    readonly ecrRepository?: ecr.IRepository;
+    protected constructor(image: string, ecrRepository?: ecr.IRepository);
+}

package/lib/image-builders/aws-image-builder/base-image.js

@@ -0,0 +1,130 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseContainerImage = exports.BaseImage = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk = require("aws-cdk-lib");
+/**
+ * Represents a base image that is used to start from in EC2 Image Builder image builds.
+ *
+ * This class is adapted from AWS CDK's BaseImage class to support both string and object inputs.
+ */
+class BaseImage {
+    /**
+     * The AMI ID to use as a base image in an image recipe
+     *
+     * @param amiId The AMI ID to use as the base image
+     */
+    static fromAmiId(amiId) {
+        return new BaseImage(amiId);
+    }
+    /**
+     * An AWS-provided EC2 Image Builder image to use as a base image in an image recipe.
+     *
+     * This constructs an Image Builder ARN for AWS-provided images like `ubuntu-server-22-lts-x86/x.x.x`.
+     *
+     * @param scope The construct scope (used to determine the stack and region)
+     * @param resourceName The Image Builder resource name pattern (e.g., `ubuntu-server-22-lts-x86` or `ubuntu-server-22-lts-${arch}`)
+     * @param version The version pattern (defaults to `x.x.x` to use the latest version)
+     */
+    static fromImageBuilder(scope, resourceName, version = 'x.x.x') {
+        const stack = cdk.Stack.of(scope);
+        return new BaseImage(stack.formatArn({
+            service: 'imagebuilder',
+            resource: 'image',
+            account: 'aws',
+            resourceName: `${resourceName}/${version}`,
+        }));
+    }
+    /**
+     * The marketplace product ID for an AMI product to use as the base image in an image recipe
+     *
+     * @param productId The Marketplace AMI product ID to use as the base image
+     */
+    static fromMarketplaceProductId(productId) {
+        return new BaseImage(productId);
+    }
+    /**
+     * The SSM parameter to use as the base image in an image recipe
+     *
+     * @param parameter The SSM parameter to use as the base image
+     */
+    static fromSsmParameter(parameter) {
+        return new BaseImage(`ssm:${parameter.parameterArn}`);
+    }
+    /**
+     * The parameter name for the SSM parameter to use as the base image in an image recipe
+     *
+     * @param parameterName The name of the SSM parameter to use as the base image
+     */
+    static fromSsmParameterName(parameterName) {
+        return new BaseImage(`ssm:${parameterName}`);
+    }
+    /**
+     * The direct string value of the base image to use in an image recipe. This can be an EC2 Image Builder image ARN,
+     * an SSM parameter, an AWS Marketplace product ID, or an AMI ID.
+     *
+     * @param baseImageString The base image as a direct string value
+     */
+    static fromString(baseImageString) {
+        return new BaseImage(baseImageString);
+    }
+    constructor(image) {
+        this.image = image;
+    }
+}
+exports.BaseImage = BaseImage;
+_a = JSII_RTTI_SYMBOL_1;
+BaseImage[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.BaseImage", version: "0.14.19" };
+/**
+ * Represents a base container image that is used to start from in EC2 Image Builder container builds.
+ *
+ * This class is adapted from AWS CDK's BaseContainerImage class to support both string and object inputs.
+ */
+class BaseContainerImage {
+    /**
+     * The DockerHub image to use as the base image in a container recipe
+     *
+     * @param repository The DockerHub repository where the base image resides in
+     * @param tag The tag of the base image in the DockerHub repository
+     */
+    static fromDockerHub(repository, tag) {
+        return new BaseContainerImage(`${repository}:${tag}`);
+    }
+    /**
+     * The ECR container image to use as the base image in a container recipe
+     *
+     * @param repository The ECR repository where the base image resides in
+     * @param tag The tag of the base image in the ECR repository
+     */
+    static fromEcr(repository, tag) {
+        return new BaseContainerImage(repository.repositoryUriForTag(tag), repository);
+    }
+    /**
+     * The ECR public container image to use as the base image in a container recipe
+     *
+     * @param registryAlias The alias of the ECR public registry where the base image resides in
+     * @param repositoryName The name of the ECR public repository, where the base image resides in
+     * @param tag The tag of the base image in the ECR public repository
+     */
+    static fromEcrPublic(registryAlias, repositoryName, tag) {
+        return new BaseContainerImage(`public.ecr.aws/${registryAlias}/${repositoryName}:${tag}`);
+    }
+    /**
+     * The string value of the base image to use in a container recipe. This can be an EC2 Image Builder image ARN,
+     * an ECR or ECR public image, or a container URI sourced from a third-party container registry such as DockerHub.
+     *
+     * @param baseContainerImageString The base image as a direct string value
+     */
+    static fromString(baseContainerImageString) {
+        return new BaseContainerImage(baseContainerImageString);
+    }
+    constructor(image, ecrRepository) {
+        this.image = image;
+        this.ecrRepository = ecrRepository;
+    }
+}
+exports.BaseContainerImage = BaseContainerImage;
+_b = JSII_RTTI_SYMBOL_1;
+BaseContainerImage[_b] = { fqn: "@cloudsnorkel/cdk-github-runners.BaseContainerImage", version: "0.14.19" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-image.js","sourceRoot":"","sources":["../../../src/image-builders/aws-image-builder/base-image.ts"],"names":[],"mappings":";;;;;AAAA,mCAAmC;AAcnC;;;;GAIG;AACH,MAAa,SAAS;IACpB;;;;OAIG;IACI,MAAM,CAAC,SAAS,CAAC,KAAa;QACnC,OAAO,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;;;OAQG;IACI,MAAM,CAAC,gBAAgB,CAAC,KAAgB,EAAE,YAAoB,EAAE,UAAkB,OAAO;QAC9F,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAClC,OAAO,IAAI,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC;YACnC,OAAO,EAAE,cAAc;YACvB,QAAQ,EAAE,OAAO;YACjB,OAAO,EAAE,KAAK;YACd,YAAY,EAAE,GAAG,YAAY,IAAI,OAAO,EAAE;SAC3C,CAAC,CAAC,CAAC;IACN,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,wBAAwB,CAAC,SAAiB;QACtD,OAAO,IAAI,SAAS,CAAC,SAAS,CAAC,CAAC;IAClC,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,gBAAgB,CAAC,SAAyB;QACtD,OAAO,IAAI,SAAS,CAAC,OAAO,SAAS,CAAC,YAAY,EAAE,CAAC,CAAC;IACxD,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,oBAAoB,CAAC,aAAqB;QACtD,OAAO,IAAI,SAAS,CAAC,OAAO,aAAa,EAAE,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,UAAU,CAAC,eAAuB;QAC9C,OAAO,IAAI,SAAS,CAAC,eAAe,CAAC,CAAC;IACxC,CAAC;IAOD,YAAsB,KAAa;QACjC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;;AAzEH,8BA0EC;;;AAWD;;;;GAIG;AACH,MAAa,kBAAkB;IAC7B;;;;;OAKG;IACI,MAAM,CAAC,aAAa,CAAC,UAAkB,EAAE,GAAW;QACzD,OAAO,IAAI,kBAAkB,CAAC,GAAG,UAAU,IAAI,GAAG,EAAE,CAAC,CAAC;IACxD,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,OAAO,CAAC,UAA2B,EAAE,GAAW;QAC5D,OAAO,IAAI,kBAAkB,CAAC,UAAU,CAAC,mBAAmB,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC,CAAC;IACjF,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,aAAa,CAAC,aAAqB,EAAE,cAAsB,EAAE,GAAW;QACpF,OAAO,IAAI,kBAAkB,CAAC,kBAAkB,aAAa,IAAI,cAAc,IAAI,GAAG,EAAE,CAAC,CAAC;IAC5F,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,UAAU,CAAC,wBAAgC;QACvD,OAAO,IAAI,kBAAkB,CAAC,wBAAwB,CAAC,CAAC;IAC1D,CAAC;IAaD,YAAsB,KAAa,EAAE,aAA+B;QAClE,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;IACrC,CAAC;;AAxDH,gDAyDC","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport * as ecr from 'aws-cdk-lib/aws-ecr';\nimport * as ssm from 'aws-cdk-lib/aws-ssm';\nimport { Construct } from 'constructs';\n\n/**\n * Type that can be used to specify a base image - either a string (deprecated) or a BaseImage object.\n *\n * To create a BaseImage object, use the static factory methods like BaseImage.fromAmiId().\n *\n * Note: String support is deprecated and will be removed in a future version. Use BaseImage static factory methods instead.\n */\nexport type BaseImageInput = string | BaseImage;\n\n/**\n * Represents a base image that is used to start from in EC2 Image Builder image builds.\n *\n * This class is adapted from AWS CDK's BaseImage class to support both string and object inputs.\n */\nexport class BaseImage {\n  /**\n   * The AMI ID to use as a base image in an image recipe\n   *\n   * @param amiId The AMI ID to use as the base image\n   */\n  public static fromAmiId(amiId: string): BaseImage {\n    return new BaseImage(amiId);\n  }\n\n  /**\n   * An AWS-provided EC2 Image Builder image to use as a base image in an image recipe.\n   *\n   * This constructs an Image Builder ARN for AWS-provided images like `ubuntu-server-22-lts-x86/x.x.x`.\n   *\n   * @param scope The construct scope (used to determine the stack and region)\n   * @param resourceName The Image Builder resource name pattern (e.g., `ubuntu-server-22-lts-x86` or `ubuntu-server-22-lts-${arch}`)\n   * @param version The version pattern (defaults to `x.x.x` to use the latest version)\n   */\n  public static fromImageBuilder(scope: Construct, resourceName: string, version: string = 'x.x.x'): BaseImage {\n    const stack = cdk.Stack.of(scope);\n    return new BaseImage(stack.formatArn({\n      service: 'imagebuilder',\n      resource: 'image',\n      account: 'aws',\n      resourceName: `${resourceName}/${version}`,\n    }));\n  }\n\n  /**\n   * The marketplace product ID for an AMI product to use as the base image in an image recipe\n   *\n   * @param productId The Marketplace AMI product ID to use as the base image\n   */\n  public static fromMarketplaceProductId(productId: string): BaseImage {\n    return new BaseImage(productId);\n  }\n\n  /**\n   * The SSM parameter to use as the base image in an image recipe\n   *\n   * @param parameter The SSM parameter to use as the base image\n   */\n  public static fromSsmParameter(parameter: ssm.IParameter): BaseImage {\n    return new BaseImage(`ssm:${parameter.parameterArn}`);\n  }\n\n  /**\n   * The parameter name for the SSM parameter to use as the base image in an image recipe\n   *\n   * @param parameterName The name of the SSM parameter to use as the base image\n   */\n  public static fromSsmParameterName(parameterName: string): BaseImage {\n    return new BaseImage(`ssm:${parameterName}`);\n  }\n\n  /**\n   * The direct string value of the base image to use in an image recipe. This can be an EC2 Image Builder image ARN,\n   * an SSM parameter, an AWS Marketplace product ID, or an AMI ID.\n   *\n   * @param baseImageString The base image as a direct string value\n   */\n  public static fromString(baseImageString: string): BaseImage {\n    return new BaseImage(baseImageString);\n  }\n\n  /**\n   * The rendered base image to use\n   */\n  public readonly image: string;\n\n  protected constructor(image: string) {\n    this.image = image;\n  }\n}\n\n/**\n * Type that can be used to specify a base container image - either a string (deprecated) or a BaseContainerImage object.\n *\n * To create a BaseContainerImage object, use the static factory methods like BaseContainerImage.fromEcr().\n *\n * Note: String support is deprecated and will be removed in a future version. Use BaseContainerImage static factory methods instead.\n */\nexport type BaseContainerImageInput = string | BaseContainerImage;\n\n/**\n * Represents a base container image that is used to start from in EC2 Image Builder container builds.\n *\n * This class is adapted from AWS CDK's BaseContainerImage class to support both string and object inputs.\n */\nexport class BaseContainerImage {\n  /**\n   * The DockerHub image to use as the base image in a container recipe\n   *\n   * @param repository The DockerHub repository where the base image resides in\n   * @param tag The tag of the base image in the DockerHub repository\n   */\n  public static fromDockerHub(repository: string, tag: string): BaseContainerImage {\n    return new BaseContainerImage(`${repository}:${tag}`);\n  }\n\n  /**\n   * The ECR container image to use as the base image in a container recipe\n   *\n   * @param repository The ECR repository where the base image resides in\n   * @param tag The tag of the base image in the ECR repository\n   */\n  public static fromEcr(repository: ecr.IRepository, tag: string): BaseContainerImage {\n    return new BaseContainerImage(repository.repositoryUriForTag(tag), repository);\n  }\n\n  /**\n   * The ECR public container image to use as the base image in a container recipe\n   *\n   * @param registryAlias The alias of the ECR public registry where the base image resides in\n   * @param repositoryName The name of the ECR public repository, where the base image resides in\n   * @param tag The tag of the base image in the ECR public repository\n   */\n  public static fromEcrPublic(registryAlias: string, repositoryName: string, tag: string): BaseContainerImage {\n    return new BaseContainerImage(`public.ecr.aws/${registryAlias}/${repositoryName}:${tag}`);\n  }\n\n  /**\n   * The string value of the base image to use in a container recipe. This can be an EC2 Image Builder image ARN,\n   * an ECR or ECR public image, or a container URI sourced from a third-party container registry such as DockerHub.\n   *\n   * @param baseContainerImageString The base image as a direct string value\n   */\n  public static fromString(baseContainerImageString: string): BaseContainerImage {\n    return new BaseContainerImage(baseContainerImageString);\n  }\n\n  /**\n   * The rendered base image to use\n   */\n  public readonly image: string;\n\n  /**\n   * The ECR repository if this image was created from an ECR repository.\n   * This allows automatic permission granting for CodeBuild.\n   */\n  public readonly ecrRepository?: ecr.IRepository;\n\n  protected constructor(image: string, ecrRepository?: ecr.IRepository) {\n    this.image = image;\n    this.ecrRepository = ecrRepository;\n  }\n}\n"]}