@cloudsnorkel/cdk-github-runners 0.8.4 → 0.9.0

package/lib/providers/image-builders/components.js

@@ -0,0 +1,534 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerImageComponent = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path = require("path");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_image_builder_1 = require("./aws-image-builder");
+const common_1 = require("../common");
+/**
+ * Components are used to build runner images. They can run commands in the image, copy files into the image, and run some Docker commands.
+ */
+class RunnerImageComponent {
+    /**
+     * Define a custom component that can run commands in the image, copy files into the image, and run some Docker commands.
+     *
+     * The order of operations is (1) assets (2) commands (3) docker commands.
+     *
+     * Use this to customize the image for the runner.
+     *
+     * **WARNING:** Docker commands are not guaranteed to be included before the next component
+     */
+    static custom(props) {
+        return new class extends RunnerImageComponent {
+            get name() {
+                if (props.name && !props.name.match(/[a-zA-Z0-9\-]/)) {
+                    throw new Error(`Invalid component name: ${props.name}. Name must only contain alphanumeric characters and dashes.`);
+                }
+                return `Custom-${props.name ?? 'Undefined'}`;
+            }
+            getCommands(_os, _architecture) {
+                return props.commands ?? [];
+            }
+            getAssets(_os, _architecture) {
+                return props.assets ?? [];
+            }
+            getDockerCommands(_os, _architecture) {
+                return props.dockerCommands ?? [];
+            }
+        }();
+    }
+    /**
+     * A component to install the required packages for the runner.
+     */
+    static requiredPackages() {
+        return new class extends RunnerImageComponent {
+            constructor() {
+                super(...arguments);
+                this.name = 'RequiredPackages';
+            }
+            getCommands(os, architecture) {
+                if (os.is(common_1.Os.LINUX_UBUNTU)) {
+                    let archUrl;
+                    if (architecture.is(common_1.Architecture.X86_64)) {
+                        archUrl = 'amd64';
+                    }
+                    else if (architecture.is(common_1.Architecture.ARM64)) {
+                        archUrl = 'arm64';
+                    }
+                    else {
+                        throw new Error(`Unsupported architecture for required packages: ${architecture.name}`);
+                    }
+                    return [
+                        'apt-get update',
+                        'DEBIAN_FRONTEND=noninteractive apt-get upgrade -y',
+                        'DEBIAN_FRONTEND=noninteractive apt-get install -y curl sudo jq bash zip unzip iptables software-properties-common ca-certificates',
+                        `curl -sfLo /tmp/amazon-cloudwatch-agent.deb https://s3.amazonaws.com/amazoncloudwatch-agent/ubuntu/${archUrl}/latest/amazon-cloudwatch-agent.deb`,
+                        'dpkg -i -E /tmp/amazon-cloudwatch-agent.deb',
+                        'rm /tmp/amazon-cloudwatch-agent.deb',
+                    ];
+                }
+                else if (os.is(common_1.Os.LINUX_AMAZON_2)) {
+                    return [
+                        'yum update -y',
+                        'yum install -y jq tar gzip bzip2 which binutils zip unzip sudo shadow-utils',
+                    ];
+                }
+                else if (os.is(common_1.Os.WINDOWS)) {
+                    return [
+                        'Start-Process msiexec.exe -Wait -ArgumentList \'/i https://s3.amazonaws.com/amazoncloudwatch-agent/windows/amd64/latest/amazon-cloudwatch-agent.msi /qn\'',
+                    ];
+                }
+                throw new Error(`Unsupported OS for required packages: ${os.name}`);
+            }
+        };
+    }
+    /**
+     * A component to prepare the required runner user.
+     */
+    static runnerUser() {
+        return new class extends RunnerImageComponent {
+            constructor() {
+                super(...arguments);
+                this.name = 'RunnerUser';
+            }
+            getCommands(os, _architecture) {
+                if (os.is(common_1.Os.LINUX_UBUNTU)) {
+                    return [
+                        'addgroup runner',
+                        'adduser --system --disabled-password --home /home/runner --ingroup runner runner',
+                        'usermod -aG sudo runner',
+                        'echo "%sudo   ALL=(ALL:ALL) NOPASSWD: ALL" > /etc/sudoers.d/runner',
+                    ];
+                }
+                else if (os.is(common_1.Os.LINUX_AMAZON_2)) {
+                    return [
+                        '/usr/sbin/groupadd runner',
+                        '/usr/sbin/useradd --system --shell /usr/sbin/nologin --home-dir /home/runner --gid runner runner',
+                        'mkdir -p /home/runner',
+                        'chown runner /home/runner',
+                        'echo "%runner   ALL=(ALL:ALL) NOPASSWD: ALL" > /etc/sudoers.d/runner',
+                    ];
+                }
+                else if (os.is(common_1.Os.WINDOWS)) {
+                    return [];
+                }
+                throw new Error(`Unsupported OS for runner user: ${os.name}`);
+            }
+        };
+    }
+    /**
+     * A component to install the AWS CLI.
+     */
+    static awsCli() {
+        return new class extends RunnerImageComponent {
+            constructor() {
+                super(...arguments);
+                this.name = 'AwsCli';
+            }
+            getCommands(os, architecture) {
+                if (os.is(common_1.Os.LINUX_UBUNTU) || os.is(common_1.Os.LINUX_AMAZON_2)) {
+                    let archUrl;
+                    if (architecture.is(common_1.Architecture.X86_64)) {
+                        archUrl = 'x86_64';
+                    }
+                    else if (architecture.is(common_1.Architecture.ARM64)) {
+                        archUrl = 'aarch64';
+                    }
+                    else {
+                        throw new Error(`Unsupported architecture for awscli: ${architecture.name}`);
+                    }
+                    return [
+                        `curl -fsSL "https://awscli.amazonaws.com/awscli-exe-linux-${archUrl}.zip" -o awscliv2.zip`,
+                        'unzip -q awscliv2.zip',
+                        './aws/install',
+                        'rm -rf awscliv2.zip aws',
+                    ];
+                }
+                else if (os.is(common_1.Os.WINDOWS)) {
+                    return [
+                        'Start-Process msiexec.exe -Wait -ArgumentList \'/i https://awscli.amazonaws.com/AWSCLIV2.msi /qn\'',
+                    ];
+                }
+                throw new Error(`Unknown os/architecture combo for awscli: ${os.name}/${architecture.name}`);
+            }
+        }();
+    }
+    /**
+     * A component to install the GitHub CLI.
+     */
+    static githubCli() {
+        return new class extends RunnerImageComponent {
+            constructor() {
+                super(...arguments);
+                this.name = 'GithubCli';
+            }
+            getCommands(os, architecture) {
+                if (os.is(common_1.Os.LINUX_UBUNTU)) {
+                    return [
+                        'curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg',
+                        'echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] ' +
+                            '  https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null',
+                        'apt-get update',
+                        'DEBIAN_FRONTEND=noninteractive apt-get install -y gh',
+                    ];
+                }
+                else if (os.is(common_1.Os.LINUX_AMAZON_2)) {
+                    return [
+                        'curl -fsSSL https://cli.github.com/packages/rpm/gh-cli.repo -o /etc/yum.repos.d/gh-cli.repo',
+                        'yum install -y gh',
+                    ];
+                }
+                else if (os.is(common_1.Os.WINDOWS)) {
+                    return [
+                        'cmd /c curl -w "%{redirect_url}" -fsS https://github.com/cli/cli/releases/latest > $Env:TEMP\\latest-gh',
+                        '$LatestUrl = Get-Content $Env:TEMP\\latest-gh',
+                        '$GH_VERSION = ($LatestUrl -Split \'/\')[-1].substring(1)',
+                        'Invoke-WebRequest -UseBasicParsing -Uri "https://github.com/cli/cli/releases/download/v${GH_VERSION}/gh_${GH_VERSION}_windows_amd64.msi" -OutFile gh.msi',
+                        'Start-Process msiexec.exe -Wait -ArgumentList \'/i gh.msi /qn\'',
+                        'del gh.msi',
+                    ];
+                }
+                throw new Error(`Unknown os/architecture combo for github cli: ${os.name}/${architecture.name}`);
+            }
+        }();
+    }
+    /**
+     * A component to install the GitHub CLI.
+     */
+    static git() {
+        return new class extends RunnerImageComponent {
+            constructor() {
+                super(...arguments);
+                this.name = 'Git';
+            }
+            getCommands(os, architecture) {
+                if (os.is(common_1.Os.LINUX_UBUNTU)) {
+                    return [
+                        'add-apt-repository ppa:git-core/ppa',
+                        'apt-get update',
+                        'DEBIAN_FRONTEND=noninteractive apt-get install -y git',
+                    ];
+                }
+                else if (os.is(common_1.Os.LINUX_AMAZON_2)) {
+                    return [
+                        'yum install -y git',
+                    ];
+                }
+                else if (os.is(common_1.Os.WINDOWS)) {
+                    return [
+                        'cmd /c curl -w "%{redirect_url}" -fsS https://github.com/git-for-windows/git/releases/latest > $Env:TEMP\\latest-git',
+                        '$LatestUrl = Get-Content $Env:TEMP\\latest-git',
+                        '$GIT_VERSION = ($LatestUrl -Split \'/\')[-1].substring(1)',
+                        '$GIT_VERSION_SHORT = ($GIT_VERSION -Split \'.windows.\')[0]',
+                        '$GIT_REVISION = ($GIT_VERSION -Split \'.windows.\')[1]',
+                        'If ($GIT_REVISION -gt 1) {$GIT_VERSION_SHORT = "$GIT_VERSION_SHORT.$GIT_REVISION"}',
+                        'Invoke-WebRequest -UseBasicParsing -Uri https://github.com/git-for-windows/git/releases/download/v${GIT_VERSION}/Git-${GIT_VERSION_SHORT}-64-bit.exe -OutFile git-setup.exe',
+                        'Start-Process git-setup.exe -Wait -ArgumentList \'/VERYSILENT\'',
+                        'del git-setup.exe',
+                    ];
+                }
+                throw new Error(`Unknown os/architecture combo for git: ${os.name}/${architecture.name}`);
+            }
+        }();
+    }
+    /**
+     * A component to install the GitHub Actions Runner. This is the actual executable that connects to GitHub to ask for jobs and then execute them.
+     *
+     * @param runnerVersion The version of the runner to install. Usually you would set this to latest.
+     */
+    static githubRunner(runnerVersion) {
+        return new class extends RunnerImageComponent {
+            constructor() {
+                super(...arguments);
+                this.name = 'GithubRunner';
+            }
+            getCommands(os, architecture) {
+                if (os.is(common_1.Os.LINUX_UBUNTU) || os.is(common_1.Os.LINUX_AMAZON_2)) {
+                    let versionCommand;
+                    if (runnerVersion.is(common_1.RunnerVersion.latest())) {
+                        versionCommand = 'RUNNER_VERSION=`curl -w "%{redirect_url}" -fsS https://github.com/actions/runner/releases/latest | grep -oE "[^/v]+$"`';
+                    }
+                    else {
+                        versionCommand = `RUNNER_VERSION='${runnerVersion.version}'`;
+                    }
+                    let archUrl;
+                    if (architecture.is(common_1.Architecture.X86_64)) {
+                        archUrl = 'x64';
+                    }
+                    else if (architecture.is(common_1.Architecture.ARM64)) {
+                        archUrl = 'arm64';
+                    }
+                    else {
+                        throw new Error(`Unsupported architecture for GitHub Runner: ${architecture.name}`);
+                    }
+                    let commands = [
+                        versionCommand,
+                        `curl -fsSLO "https://github.com/actions/runner/releases/download/v\${RUNNER_VERSION}/actions-runner-linux-${archUrl}-\${RUNNER_VERSION}.tar.gz"`,
+                        `tar -C /home/runner -xzf "actions-runner-linux-${archUrl}-\${RUNNER_VERSION}.tar.gz"`,
+                        `rm actions-runner-linux-${archUrl}-\${RUNNER_VERSION}.tar.gz`,
+                        `echo -n ${runnerVersion.version} > /home/runner/RUNNER_VERSION`,
+                    ];
+                    if (os.is(common_1.Os.LINUX_UBUNTU)) {
+                        commands.push('/home/runner/bin/installdependencies.sh');
+                    }
+                    else if (os.is(common_1.Os.LINUX_AMAZON_2)) {
+                        commands.push('yum install -y openssl-libs krb5-libs zlib libicu60');
+                    }
+                    return commands;
+                }
+                else if (os.is(common_1.Os.WINDOWS)) {
+                    let runnerCommands;
+                    if (runnerVersion.is(common_1.RunnerVersion.latest())) {
+                        runnerCommands = [
+                            'cmd /c curl -w "%{redirect_url}" -fsS https://github.com/actions/runner/releases/latest > $Env:TEMP\\latest-gha',
+                            '$LatestUrl = Get-Content $Env:TEMP\\latest-gha',
+                            '$RUNNER_VERSION = ($LatestUrl -Split \'/\')[-1].substring(1)',
+                        ];
+                    }
+                    else {
+                        runnerCommands = [`$RUNNER_VERSION = '${runnerVersion.version}'`];
+                    }
+                    return runnerCommands.concat([
+                        'Invoke-WebRequest -UseBasicParsing -Uri "https://github.com/actions/runner/releases/download/v${RUNNER_VERSION}/actions-runner-win-x64-${RUNNER_VERSION}.zip" -OutFile actions.zip',
+                        'Expand-Archive actions.zip -DestinationPath C:\\actions',
+                        'del actions.zip',
+                        `echo ${runnerVersion.version} | Out-File -Encoding ASCII -NoNewline C:\\actions\\RUNNER_VERSION`,
+                    ]);
+                }
+                throw new Error(`Unknown os/architecture combo for github runner: ${os.name}/${architecture.name}`);
+            }
+            getDockerCommands(_os, _architecture) {
+                return [
+                    `ENV RUNNER_VERSION=${runnerVersion.version}`,
+                ];
+            }
+        }();
+    }
+    /**
+     * A component to install Docker. On Windows this installs Docker Desktop.
+     */
+    static docker() {
+        return new class extends RunnerImageComponent {
+            constructor() {
+                super(...arguments);
+                this.name = 'Docker';
+            }
+            getCommands(os, architecture) {
+                if (os.is(common_1.Os.LINUX_UBUNTU)) {
+                    return [
+                        'curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg',
+                        'echo ' +
+                            '  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu ' +
+                            '  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null',
+                        'apt-get update',
+                        'DEBIAN_FRONTEND=noninteractive apt-get install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin',
+                        'usermod -aG docker runner',
+                        'ln -s /usr/libexec/docker/cli-plugins/docker-compose /usr/bin/docker-compose',
+                    ];
+                }
+                else if (os.is(common_1.Os.LINUX_AMAZON_2)) {
+                    return [
+                        'yum install -y docker',
+                    ];
+                }
+                else if (os.is(common_1.Os.WINDOWS)) {
+                    return [
+                        'Invoke-WebRequest -UseBasicParsing -Uri https://desktop.docker.com/win/main/amd64/Docker%20Desktop%20Installer.exe -OutFile docker-setup.exe',
+                        'Start-Process \'docker-setup.exe\' -Wait -ArgumentList \'/install --quiet --accept-license\'',
+                        'del docker-setup.exe',
+                        'cmd /c curl -w "%{redirect_url}" -fsS https://github.com/docker/compose/releases/latest > $Env:TEMP\\latest-docker-compose',
+                        '$LatestUrl = Get-Content $Env:TEMP\\latest-docker-compose',
+                        '$LatestDockerCompose = ($LatestUrl -Split \'/\')[-1]',
+                        'Invoke-WebRequest -UseBasicParsing -Uri  "https://github.com/docker/compose/releases/download/${LatestDockerCompose}/docker-compose-Windows-x86_64.exe" -OutFile $Env:ProgramFiles\\Docker\\docker-compose.exe',
+                        'copy $Env:ProgramFiles\\Docker\\docker-compose.exe $Env:ProgramFiles\\Docker\\cli-plugins\\docker-compose.exe',
+                    ];
+                }
+                throw new Error(`Unknown os/architecture combo for docker: ${os.name}/${architecture.name}`);
+            }
+        }();
+    }
+    /**
+     * A component to install Docker-in-Docker.
+     */
+    static dockerInDocker() {
+        return new class extends RunnerImageComponent {
+            constructor() {
+                super(...arguments);
+                this.name = 'Docker-in-Docker';
+            }
+            getCommands(os, architecture) {
+                if (os.is(common_1.Os.LINUX_UBUNTU) || os.is(common_1.Os.LINUX_AMAZON_2)) {
+                    let archUrl;
+                    if (architecture.is(common_1.Architecture.X86_64)) {
+                        archUrl = 'x86_64';
+                    }
+                    else if (architecture.is(common_1.Architecture.ARM64)) {
+                        archUrl = 'aarch64';
+                    }
+                    else {
+                        throw new Error(`Unsupported architecture for Docker-in-Docker: ${architecture.name}`);
+                    }
+                    return [
+                        'DOCKER_CHANNEL="stable"',
+                        'DIND_COMMIT="42b1175eda071c0e9121e1d64345928384a93df1"',
+                        'DOCKER_VERSION="20.10.18"',
+                        'DOCKER_COMPOSE_VERSION="2.11.0"',
+                        `curl -fsSL "https://download.docker.com/linux/static/\${DOCKER_CHANNEL}/${archUrl}/docker-\${DOCKER_VERSION}.tgz" -o docker.tgz`,
+                        'tar --strip-components 1 -C /usr/local/bin/ -xzf docker.tgz',
+                        'rm docker.tgz',
+                        '# set up subuid/subgid so that "--userns-remap=default" works out-of-the box',
+                        'addgroup dockremap',
+                        'useradd -g dockremap dockremap',
+                        'echo \'dockremap:165536:65536\' >> /etc/subuid',
+                        'echo \'dockremap:165536:65536\' >> /etc/subgid',
+                        'curl -fsSL "https://raw.githubusercontent.com/docker/docker/${DIND_COMMIT}/hack/dind" -o /usr/local/bin/dind',
+                        `curl -fsSL https://github.com/docker/compose/releases/download/v\${DOCKER_COMPOSE_VERSION}/docker-compose-linux-${archUrl} -o /usr/local/bin/docker-compose`,
+                        'mkdir -p /home/runner/.docker/cli-plugins && ln -s /usr/local/bin/docker-compose /home/runner/.docker/cli-plugins/docker-compose',
+                        'chown -R runner /home/runner/.docker',
+                        'chmod +x /usr/local/bin/dind /usr/local/bin/docker-compose',
+                        'addgroup docker && usermod -aG docker runner',
+                    ];
+                }
+                throw new Error(`Unknown os/architecture combo for Docker-in-Docker: ${os.name}/${architecture.name}`);
+            }
+        }();
+    }
+    /**
+     * A component to add a trusted certificate authority. This can be used to support GitHub Enterprise Server with self-signed certificate.
+     *
+     * @param source path to certificate file in PEM format
+     * @param name unique certificate name to be used on runner file system
+     */
+    static extraCertificates(source, name) {
+        return new class extends RunnerImageComponent {
+            constructor() {
+                super(...arguments);
+                this.name = `Extra-Certificates-${name}`;
+            }
+            getCommands(os, architecture) {
+                if (!name.match(/^[a-zA-Z0-9_-]+$/)) {
+                    throw new Error(`Invalid certificate name: ${name}. Name must only contain alphanumeric characters, dashes and underscores.`);
+                }
+                if (os.is(common_1.Os.LINUX_UBUNTU)) {
+                    return [
+                        'update-ca-certificates',
+                    ];
+                }
+                else if (os.is(common_1.Os.LINUX_AMAZON_2)) {
+                    return [
+                        'update-ca-trust',
+                    ];
+                }
+                else if (os.is(common_1.Os.WINDOWS)) {
+                    return [
+                        `Import-Certificate -FilePath C:\\${name}.crt -CertStoreLocation Cert:\\LocalMachine\\Root`,
+                        `Remove-Item C:\\${name}.crt`,
+                    ];
+                }
+                throw new Error(`Unknown os/architecture combo for extra certificates: ${os.name}/${architecture.name}`);
+            }
+            getAssets(os, _architecture) {
+                if (os.is(common_1.Os.LINUX_UBUNTU)) {
+                    return [
+                        { source, target: `/usr/local/share/ca-certificates/${name}.crt` },
+                    ];
+                }
+                else if (os.is(common_1.Os.LINUX_AMAZON_2)) {
+                    return [
+                        { source, target: `/etc/pki/ca-trust/source/anchors/${name}.crt` },
+                    ];
+                }
+                else if (os.is(common_1.Os.WINDOWS)) {
+                    return [
+                        { source, target: `C:\\${name}.crt` },
+                    ];
+                }
+                throw new Error(`Unsupported OS for extra certificates: ${os.name}`);
+            }
+        }();
+    }
+    /**
+     * A component to set up the required Lambda entrypoint for Lambda runners.
+     */
+    static lambdaEntrypoint() {
+        return new class extends RunnerImageComponent {
+            constructor() {
+                super(...arguments);
+                this.name = 'Lambda-Entrypoint';
+            }
+            getCommands(os, _architecture) {
+                if (!os.is(common_1.Os.LINUX_AMAZON_2) && !os.is(common_1.Os.LINUX_UBUNTU)) {
+                    throw new Error(`Unsupported OS for Lambda entrypoint: ${os.name}`);
+                }
+                return [];
+            }
+            getAssets(_os, _architecture) {
+                return [
+                    {
+                        source: path.join(__dirname, '..', 'docker-images', 'lambda', 'linux-x64', 'runner.js'),
+                        target: '${LAMBDA_TASK_ROOT}/runner.js',
+                    },
+                    {
+                        source: path.join(__dirname, '..', 'docker-images', 'lambda', 'linux-x64', 'runner.sh'),
+                        target: '${LAMBDA_TASK_ROOT}/runner.sh',
+                    },
+                ];
+            }
+            getDockerCommands(_os, _architecture) {
+                return [
+                    'WORKDIR ${LAMBDA_TASK_ROOT}',
+                    'CMD ["runner.handler"]',
+                ];
+            }
+        };
+    }
+    /**
+     * Returns assets to copy into the built image. Can be used to copy files into the image.
+     */
+    getAssets(_os, _architecture) {
+        return [];
+    }
+    /**
+     * Returns Docker commands to run to in built image. Can be used to add commands like `VOLUME`, `ENTRYPOINT`, `CMD`, etc.
+     *
+     * Docker commands are added after assets and normal commands.
+     */
+    getDockerCommands(_os, _architecture) {
+        return [];
+    }
+    /**
+     * Convert component to an AWS Image Builder component.
+     *
+     * @internal
+     */
+    _asAwsImageBuilderComponent(scope, id, os, architecture) {
+        let platform;
+        if (os.is(common_1.Os.LINUX_UBUNTU) || os.is(common_1.Os.LINUX_AMAZON_2)) {
+            platform = 'Linux';
+        }
+        else if (os.is(common_1.Os.WINDOWS)) {
+            platform = 'Windows';
+        }
+        else {
+            throw new Error(`Unknown os/architecture combo for image builder component: ${os.name}/${architecture.name}`);
+        }
+        return new aws_image_builder_1.ImageBuilderComponent(scope, id, {
+            platform: platform,
+            commands: this.getCommands(os, architecture),
+            assets: this.getAssets(os, architecture).map((asset, index) => {
+                return {
+                    asset: new aws_cdk_lib_1.aws_s3_assets.Asset(scope, `${id} asset ${index}`, { path: asset.source }),
+                    path: asset.target,
+                };
+            }),
+            displayName: id,
+            description: id,
+        });
+    }
+}
+_a = JSII_RTTI_SYMBOL_1;
+RunnerImageComponent[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.RunnerImageComponent", version: "0.9.0" };
+exports.RunnerImageComponent = RunnerImageComponent;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"components.js","sourceRoot":"","sources":["../../../src/providers/image-builders/components.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport { aws_s3_assets as s3_assets } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { ImageBuilderComponent } from './aws-image-builder';\nimport { RunnerImageAsset } from './common';\nimport { Architecture, Os, RunnerVersion } from '../common';\n\nexport interface RunnerImageComponentCustomProps {\n  /**\n   * Component name used for (1) image build logging and (2) identifier for {@link ImageRunnerBuilder.removeComponent}.\n   *\n   * Name must only contain alphanumeric characters and dashes.\n   */\n  readonly name?: string;\n\n  /**\n   * Commands to run in the built image.\n   */\n  readonly commands?: string[];\n\n  /**\n   * Assets to copy into the built image.\n   */\n  readonly assets?: RunnerImageAsset[];\n\n  /**\n   * Docker commands to run in the built image.\n   *\n   * For example: `['ENV foo=bar', 'RUN echo $foo']`\n   *\n   * These commands are ignored when building AMIs.\n   */\n  readonly dockerCommands?: string[];\n}\n\n/**\n * Components are used to build runner images. They can run commands in the image, copy files into the image, and run some Docker commands.\n */\nexport abstract class RunnerImageComponent {\n  /**\n   * Define a custom component that can run commands in the image, copy files into the image, and run some Docker commands.\n   *\n   * The order of operations is (1) assets (2) commands (3) docker commands.\n   *\n   * Use this to customize the image for the runner.\n   *\n   * **WARNING:** Docker commands are not guaranteed to be included before the next component\n   */\n  static custom(props: RunnerImageComponentCustomProps): RunnerImageComponent {\n    return new class extends RunnerImageComponent {\n      get name() {\n        if (props.name && !props.name.match(/[a-zA-Z0-9\\-]/)) {\n          throw new Error(`Invalid component name: ${props.name}. Name must only contain alphanumeric characters and dashes.`);\n        }\n        return `Custom-${props.name ?? 'Undefined'}`;\n      }\n\n      getCommands(_os: Os, _architecture: Architecture) {\n        return props.commands ?? [];\n      }\n      getAssets(_os: Os, _architecture: Architecture) {\n        return props.assets ?? [];\n      }\n\n      getDockerCommands(_os: Os, _architecture: Architecture) {\n        return props.dockerCommands ?? [];\n      }\n    }();\n  }\n\n  /**\n   * A component to install the required packages for the runner.\n   */\n  static requiredPackages(): RunnerImageComponent {\n    return new class extends RunnerImageComponent {\n      name = 'RequiredPackages';\n\n      getCommands(os: Os, architecture: Architecture): string[] {\n        if (os.is(Os.LINUX_UBUNTU)) {\n          let archUrl;\n          if (architecture.is(Architecture.X86_64)) {\n            archUrl = 'amd64';\n          } else if (architecture.is(Architecture.ARM64)) {\n            archUrl = 'arm64';\n          } else {\n            throw new Error(`Unsupported architecture for required packages: ${architecture.name}`);\n          }\n\n          return [\n            'apt-get update',\n            'DEBIAN_FRONTEND=noninteractive apt-get upgrade -y',\n            'DEBIAN_FRONTEND=noninteractive apt-get install -y curl sudo jq bash zip unzip iptables software-properties-common ca-certificates',\n            `curl -sfLo /tmp/amazon-cloudwatch-agent.deb https://s3.amazonaws.com/amazoncloudwatch-agent/ubuntu/${archUrl}/latest/amazon-cloudwatch-agent.deb`,\n            'dpkg -i -E /tmp/amazon-cloudwatch-agent.deb',\n            'rm /tmp/amazon-cloudwatch-agent.deb',\n          ];\n        } else if (os.is(Os.LINUX_AMAZON_2)) {\n          return [\n            'yum update -y',\n            'yum install -y jq tar gzip bzip2 which binutils zip unzip sudo shadow-utils',\n          ];\n        } else if (os.is(Os.WINDOWS)) {\n          return [\n            'Start-Process msiexec.exe -Wait -ArgumentList \\'/i https://s3.amazonaws.com/amazoncloudwatch-agent/windows/amd64/latest/amazon-cloudwatch-agent.msi /qn\\'',\n          ];\n        }\n\n        throw new Error(`Unsupported OS for required packages: ${os.name}`);\n      }\n    };\n  }\n\n  /**\n   * A component to prepare the required runner user.\n   */\n  static runnerUser(): RunnerImageComponent {\n    return new class extends RunnerImageComponent {\n      name = 'RunnerUser';\n\n      getCommands(os: Os, _architecture: Architecture): string[] {\n        if (os.is(Os.LINUX_UBUNTU)) {\n          return [\n            'addgroup runner',\n            'adduser --system --disabled-password --home /home/runner --ingroup runner runner',\n            'usermod -aG sudo runner',\n            'echo \"%sudo   ALL=(ALL:ALL) NOPASSWD: ALL\" > /etc/sudoers.d/runner',\n          ];\n        } else if (os.is(Os.LINUX_AMAZON_2)) {\n          return [\n            '/usr/sbin/groupadd runner',\n            '/usr/sbin/useradd --system --shell /usr/sbin/nologin --home-dir /home/runner --gid runner runner',\n            'mkdir -p /home/runner',\n            'chown runner /home/runner',\n            'echo \"%runner   ALL=(ALL:ALL) NOPASSWD: ALL\" > /etc/sudoers.d/runner',\n          ];\n        } else if (os.is(Os.WINDOWS)) {\n          return [];\n        }\n\n        throw new Error(`Unsupported OS for runner user: ${os.name}`);\n      }\n    };\n  }\n\n  /**\n   * A component to install the AWS CLI.\n   */\n  static awsCli(): RunnerImageComponent {\n    return new class extends RunnerImageComponent {\n      name = 'AwsCli';\n\n      getCommands(os: Os, architecture: Architecture) {\n        if (os.is(Os.LINUX_UBUNTU) || os.is(Os.LINUX_AMAZON_2)) {\n          let archUrl: string;\n          if (architecture.is(Architecture.X86_64)) {\n            archUrl = 'x86_64';\n          } else if (architecture.is(Architecture.ARM64)) {\n            archUrl = 'aarch64';\n          } else {\n            throw new Error(`Unsupported architecture for awscli: ${architecture.name}`);\n          }\n\n          return [\n            `curl -fsSL \"https://awscli.amazonaws.com/awscli-exe-linux-${archUrl}.zip\" -o awscliv2.zip`,\n            'unzip -q awscliv2.zip',\n            './aws/install',\n            'rm -rf awscliv2.zip aws',\n          ];\n        } else if (os.is(Os.WINDOWS)) {\n          return [\n            'Start-Process msiexec.exe -Wait -ArgumentList \\'/i https://awscli.amazonaws.com/AWSCLIV2.msi /qn\\'',\n          ];\n        }\n\n        throw new Error(`Unknown os/architecture combo for awscli: ${os.name}/${architecture.name}`);\n      }\n    }();\n  }\n\n  /**\n   * A component to install the GitHub CLI.\n   */\n  static githubCli(): RunnerImageComponent {\n    return new class extends RunnerImageComponent {\n      name = 'GithubCli';\n\n      getCommands(os: Os, architecture: Architecture) {\n        if (os.is(Os.LINUX_UBUNTU)) {\n          return [\n            'curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg',\n            'echo \"deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] ' +\n            '  https://cli.github.com/packages stable main\" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null',\n            'apt-get update',\n            'DEBIAN_FRONTEND=noninteractive apt-get install -y gh',\n          ];\n        } else if (os.is(Os.LINUX_AMAZON_2)) {\n          return [\n            'curl -fsSSL https://cli.github.com/packages/rpm/gh-cli.repo -o /etc/yum.repos.d/gh-cli.repo',\n            'yum install -y gh',\n          ];\n        } else if (os.is(Os.WINDOWS)) {\n          return [\n            'cmd /c curl -w \"%{redirect_url}\" -fsS https://github.com/cli/cli/releases/latest > $Env:TEMP\\\\latest-gh',\n            '$LatestUrl = Get-Content $Env:TEMP\\\\latest-gh',\n            '$GH_VERSION = ($LatestUrl -Split \\'/\\')[-1].substring(1)',\n            'Invoke-WebRequest -UseBasicParsing -Uri \"https://github.com/cli/cli/releases/download/v${GH_VERSION}/gh_${GH_VERSION}_windows_amd64.msi\" -OutFile gh.msi',\n            'Start-Process msiexec.exe -Wait -ArgumentList \\'/i gh.msi /qn\\'',\n            'del gh.msi',\n          ];\n        }\n\n        throw new Error(`Unknown os/architecture combo for github cli: ${os.name}/${architecture.name}`);\n      }\n    }();\n  }\n\n  /**\n   * A component to install the GitHub CLI.\n   */\n  static git(): RunnerImageComponent {\n    return new class extends RunnerImageComponent {\n      name = 'Git';\n\n      getCommands(os: Os, architecture: Architecture) {\n        if (os.is(Os.LINUX_UBUNTU)) {\n          return [\n            'add-apt-repository ppa:git-core/ppa',\n            'apt-get update',\n            'DEBIAN_FRONTEND=noninteractive apt-get install -y git',\n          ];\n        } else if (os.is(Os.LINUX_AMAZON_2)) {\n          return [\n            'yum install -y git',\n          ];\n        } else if (os.is(Os.WINDOWS)) {\n          return [\n            'cmd /c curl -w \"%{redirect_url}\" -fsS https://github.com/git-for-windows/git/releases/latest > $Env:TEMP\\\\latest-git',\n            '$LatestUrl = Get-Content $Env:TEMP\\\\latest-git',\n            '$GIT_VERSION = ($LatestUrl -Split \\'/\\')[-1].substring(1)',\n            '$GIT_VERSION_SHORT = ($GIT_VERSION -Split \\'.windows.\\')[0]',\n            '$GIT_REVISION = ($GIT_VERSION -Split \\'.windows.\\')[1]',\n            'If ($GIT_REVISION -gt 1) {$GIT_VERSION_SHORT = \"$GIT_VERSION_SHORT.$GIT_REVISION\"}',\n            'Invoke-WebRequest -UseBasicParsing -Uri https://github.com/git-for-windows/git/releases/download/v${GIT_VERSION}/Git-${GIT_VERSION_SHORT}-64-bit.exe -OutFile git-setup.exe',\n            'Start-Process git-setup.exe -Wait -ArgumentList \\'/VERYSILENT\\'',\n            'del git-setup.exe',\n          ];\n        }\n\n        throw new Error(`Unknown os/architecture combo for git: ${os.name}/${architecture.name}`);\n      }\n    }();\n  }\n\n  /**\n   * A component to install the GitHub Actions Runner. This is the actual executable that connects to GitHub to ask for jobs and then execute them.\n   *\n   * @param runnerVersion The version of the runner to install. Usually you would set this to latest.\n   */\n  static githubRunner(runnerVersion: RunnerVersion): RunnerImageComponent {\n    return new class extends RunnerImageComponent {\n      name = 'GithubRunner';\n\n      getCommands(os: Os, architecture: Architecture) {\n        if (os.is(Os.LINUX_UBUNTU) || os.is(Os.LINUX_AMAZON_2)) {\n          let versionCommand: string;\n          if (runnerVersion.is(RunnerVersion.latest())) {\n            versionCommand = 'RUNNER_VERSION=`curl -w \"%{redirect_url}\" -fsS https://github.com/actions/runner/releases/latest | grep -oE \"[^/v]+$\"`';\n          } else {\n            versionCommand = `RUNNER_VERSION='${runnerVersion.version}'`;\n          }\n\n          let archUrl;\n          if (architecture.is(Architecture.X86_64)) {\n            archUrl = 'x64';\n          } else if (architecture.is(Architecture.ARM64)) {\n            archUrl = 'arm64';\n          } else {\n            throw new Error(`Unsupported architecture for GitHub Runner: ${architecture.name}`);\n          }\n\n          let commands = [\n            versionCommand,\n            `curl -fsSLO \"https://github.com/actions/runner/releases/download/v\\${RUNNER_VERSION}/actions-runner-linux-${archUrl}-\\${RUNNER_VERSION}.tar.gz\"`,\n            `tar -C /home/runner -xzf \"actions-runner-linux-${archUrl}-\\${RUNNER_VERSION}.tar.gz\"`,\n            `rm actions-runner-linux-${archUrl}-\\${RUNNER_VERSION}.tar.gz`,\n            `echo -n ${runnerVersion.version} > /home/runner/RUNNER_VERSION`,\n          ];\n\n          if (os.is(Os.LINUX_UBUNTU)) {\n            commands.push('/home/runner/bin/installdependencies.sh');\n          } else if (os.is(Os.LINUX_AMAZON_2)) {\n            commands.push('yum install -y openssl-libs krb5-libs zlib libicu60');\n          }\n\n          return commands;\n        } else if (os.is(Os.WINDOWS)) {\n          let runnerCommands: string[];\n          if (runnerVersion.is(RunnerVersion.latest())) {\n            runnerCommands = [\n              'cmd /c curl -w \"%{redirect_url}\" -fsS https://github.com/actions/runner/releases/latest > $Env:TEMP\\\\latest-gha',\n              '$LatestUrl = Get-Content $Env:TEMP\\\\latest-gha',\n              '$RUNNER_VERSION = ($LatestUrl -Split \\'/\\')[-1].substring(1)',\n            ];\n          } else {\n            runnerCommands = [`$RUNNER_VERSION = '${runnerVersion.version}'`];\n          }\n\n          return runnerCommands.concat([\n            'Invoke-WebRequest -UseBasicParsing -Uri \"https://github.com/actions/runner/releases/download/v${RUNNER_VERSION}/actions-runner-win-x64-${RUNNER_VERSION}.zip\" -OutFile actions.zip',\n            'Expand-Archive actions.zip -DestinationPath C:\\\\actions',\n            'del actions.zip',\n            `echo ${runnerVersion.version} | Out-File -Encoding ASCII -NoNewline C:\\\\actions\\\\RUNNER_VERSION`,\n          ]);\n        }\n\n        throw new Error(`Unknown os/architecture combo for github runner: ${os.name}/${architecture.name}`);\n      }\n\n      getDockerCommands(_os: Os, _architecture: Architecture): string[] {\n        return [\n          `ENV RUNNER_VERSION=${runnerVersion.version}`,\n        ];\n      }\n    }();\n  }\n\n  /**\n   * A component to install Docker. On Windows this installs Docker Desktop.\n   */\n  static docker(): RunnerImageComponent {\n    return new class extends RunnerImageComponent {\n      name = 'Docker';\n\n      getCommands(os: Os, architecture: Architecture) {\n        if (os.is(Os.LINUX_UBUNTU)) {\n          return [\n            'curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg',\n            'echo ' +\n                '  \"deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu ' +\n                '  $(lsb_release -cs) stable\" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null',\n            'apt-get update',\n            'DEBIAN_FRONTEND=noninteractive apt-get install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin',\n            'usermod -aG docker runner',\n            'ln -s /usr/libexec/docker/cli-plugins/docker-compose /usr/bin/docker-compose',\n          ];\n        } else if (os.is(Os.LINUX_AMAZON_2)) {\n          return [\n            'yum install -y docker',\n          ];\n        } else if (os.is(Os.WINDOWS)) {\n          return [\n            'Invoke-WebRequest -UseBasicParsing -Uri https://desktop.docker.com/win/main/amd64/Docker%20Desktop%20Installer.exe -OutFile docker-setup.exe',\n            'Start-Process \\'docker-setup.exe\\' -Wait -ArgumentList \\'/install --quiet --accept-license\\'',\n            'del docker-setup.exe',\n            'cmd /c curl -w \"%{redirect_url}\" -fsS https://github.com/docker/compose/releases/latest > $Env:TEMP\\\\latest-docker-compose',\n            '$LatestUrl = Get-Content $Env:TEMP\\\\latest-docker-compose',\n            '$LatestDockerCompose = ($LatestUrl -Split \\'/\\')[-1]',\n            'Invoke-WebRequest -UseBasicParsing -Uri  \"https://github.com/docker/compose/releases/download/${LatestDockerCompose}/docker-compose-Windows-x86_64.exe\" -OutFile $Env:ProgramFiles\\\\Docker\\\\docker-compose.exe',\n            'copy $Env:ProgramFiles\\\\Docker\\\\docker-compose.exe $Env:ProgramFiles\\\\Docker\\\\cli-plugins\\\\docker-compose.exe',\n          ];\n        }\n\n        throw new Error(`Unknown os/architecture combo for docker: ${os.name}/${architecture.name}`);\n      }\n    }();\n  }\n\n  /**\n   * A component to install Docker-in-Docker.\n   */\n  static dockerInDocker(): RunnerImageComponent {\n    return new class extends RunnerImageComponent {\n      name = 'Docker-in-Docker';\n\n      getCommands(os: Os, architecture: Architecture) {\n        if (os.is(Os.LINUX_UBUNTU) || os.is(Os.LINUX_AMAZON_2)) {\n          let archUrl: string;\n          if (architecture.is(Architecture.X86_64)) {\n            archUrl = 'x86_64';\n          } else if (architecture.is(Architecture.ARM64)) {\n            archUrl = 'aarch64';\n          } else {\n            throw new Error(`Unsupported architecture for Docker-in-Docker: ${architecture.name}`);\n          }\n\n          return [\n            'DOCKER_CHANNEL=\"stable\"',\n            'DIND_COMMIT=\"42b1175eda071c0e9121e1d64345928384a93df1\"',\n            'DOCKER_VERSION=\"20.10.18\"',\n            'DOCKER_COMPOSE_VERSION=\"2.11.0\"',\n            `curl -fsSL \"https://download.docker.com/linux/static/\\${DOCKER_CHANNEL}/${archUrl}/docker-\\${DOCKER_VERSION}.tgz\" -o docker.tgz`,\n            'tar --strip-components 1 -C /usr/local/bin/ -xzf docker.tgz',\n            'rm docker.tgz',\n            '# set up subuid/subgid so that \"--userns-remap=default\" works out-of-the box',\n            'addgroup dockremap',\n            'useradd -g dockremap dockremap',\n            'echo \\'dockremap:165536:65536\\' >> /etc/subuid',\n            'echo \\'dockremap:165536:65536\\' >> /etc/subgid',\n            'curl -fsSL \"https://raw.githubusercontent.com/docker/docker/${DIND_COMMIT}/hack/dind\" -o /usr/local/bin/dind',\n            `curl -fsSL https://github.com/docker/compose/releases/download/v\\${DOCKER_COMPOSE_VERSION}/docker-compose-linux-${archUrl} -o /usr/local/bin/docker-compose`,\n            'mkdir -p /home/runner/.docker/cli-plugins && ln -s /usr/local/bin/docker-compose /home/runner/.docker/cli-plugins/docker-compose',\n            'chown -R runner /home/runner/.docker',\n            'chmod +x /usr/local/bin/dind /usr/local/bin/docker-compose',\n            'addgroup docker && usermod -aG docker runner',\n          ];\n        }\n\n        throw new Error(`Unknown os/architecture combo for Docker-in-Docker: ${os.name}/${architecture.name}`);\n      }\n    }();\n  }\n\n  /**\n   * A component to add a trusted certificate authority. This can be used to support GitHub Enterprise Server with self-signed certificate.\n   *\n   * @param source path to certificate file in PEM format\n   * @param name unique certificate name to be used on runner file system\n   */\n  static extraCertificates(source: string, name: string): RunnerImageComponent {\n    return new class extends RunnerImageComponent {\n      name = `Extra-Certificates-${name}`;\n\n      getCommands(os: Os, architecture: Architecture) {\n        if (!name.match(/^[a-zA-Z0-9_-]+$/)) {\n          throw new Error(`Invalid certificate name: ${name}. Name must only contain alphanumeric characters, dashes and underscores.`);\n        }\n\n        if (os.is(Os.LINUX_UBUNTU)) {\n          return [\n            'update-ca-certificates',\n          ];\n        } else if (os.is(Os.LINUX_AMAZON_2)) {\n          return [\n            'update-ca-trust',\n          ];\n        } else if (os.is(Os.WINDOWS)) {\n          return [\n            `Import-Certificate -FilePath C:\\\\${name}.crt -CertStoreLocation Cert:\\\\LocalMachine\\\\Root`,\n            `Remove-Item C:\\\\${name}.crt`,\n          ];\n        }\n\n        throw new Error(`Unknown os/architecture combo for extra certificates: ${os.name}/${architecture.name}`);\n      }\n\n      getAssets(os: Os, _architecture: Architecture): RunnerImageAsset[] {\n        if (os.is(Os.LINUX_UBUNTU)) {\n          return [\n            { source, target: `/usr/local/share/ca-certificates/${name}.crt` },\n          ];\n        } else if (os.is(Os.LINUX_AMAZON_2)) {\n          return [\n            { source, target: `/etc/pki/ca-trust/source/anchors/${name}.crt` },\n          ];\n        } else if (os.is(Os.WINDOWS)) {\n          return [\n            { source, target: `C:\\\\${name}.crt` },\n          ];\n        }\n\n        throw new Error(`Unsupported OS for extra certificates: ${os.name}`);\n      }\n    }();\n  }\n\n  /**\n   * A component to set up the required Lambda entrypoint for Lambda runners.\n   */\n  static lambdaEntrypoint(): RunnerImageComponent {\n    return new class extends RunnerImageComponent {\n      name = 'Lambda-Entrypoint';\n\n      getCommands(os: Os, _architecture: Architecture) {\n        if (!os.is(Os.LINUX_AMAZON_2) && !os.is(Os.LINUX_UBUNTU)) {\n          throw new Error(`Unsupported OS for Lambda entrypoint: ${os.name}`);\n        }\n\n        return [];\n      }\n\n      getAssets(_os: Os, _architecture: Architecture): RunnerImageAsset[] {\n        return [\n          {\n            source: path.join(__dirname, '..', 'docker-images', 'lambda', 'linux-x64', 'runner.js'),\n            target: '${LAMBDA_TASK_ROOT}/runner.js',\n          },\n          {\n            source: path.join(__dirname, '..', 'docker-images', 'lambda', 'linux-x64', 'runner.sh'),\n            target: '${LAMBDA_TASK_ROOT}/runner.sh',\n          },\n        ];\n      }\n\n      getDockerCommands(_os: Os, _architecture: Architecture): string[] {\n        return [\n          'WORKDIR ${LAMBDA_TASK_ROOT}',\n          'CMD [\"runner.handler\"]',\n        ];\n      }\n    };\n  }\n\n  /**\n   * Component name.\n   *\n   * Used to identify component in image build logs, and for {@link RunnerImageBuilder.removeComponent}\n   */\n  abstract readonly name: string;\n\n  /**\n   * Returns commands to run to in built image. Can be used to install packages, setup build prerequisites, etc.\n   */\n  abstract getCommands(_os: Os, _architecture: Architecture): string[];\n\n  /**\n   * Returns assets to copy into the built image. Can be used to copy files into the image.\n   */\n  getAssets(_os: Os, _architecture: Architecture): RunnerImageAsset[] {\n    return [];\n  }\n\n  /**\n   * Returns Docker commands to run to in built image. Can be used to add commands like `VOLUME`, `ENTRYPOINT`, `CMD`, etc.\n   *\n   * Docker commands are added after assets and normal commands.\n   */\n  getDockerCommands(_os: Os, _architecture: Architecture): string[] {\n    return [];\n  }\n\n  /**\n   * Convert component to an AWS Image Builder component.\n   *\n   * @internal\n   */\n  _asAwsImageBuilderComponent(scope: Construct, id: string, os: Os, architecture: Architecture) {\n    let platform: 'Linux' | 'Windows';\n    if (os.is(Os.LINUX_UBUNTU) || os.is(Os.LINUX_AMAZON_2)) {\n      platform = 'Linux';\n    } else if (os.is(Os.WINDOWS)) {\n      platform = 'Windows';\n    } else {\n      throw new Error(`Unknown os/architecture combo for image builder component: ${os.name}/${architecture.name}`);\n    }\n\n    return new ImageBuilderComponent(scope, id, {\n      platform: platform,\n      commands: this.getCommands(os, architecture),\n      assets: this.getAssets(os, architecture).map((asset, index) => {\n        return {\n          asset: new s3_assets.Asset(scope, `${id} asset ${index}`, { path: asset.source }),\n          path: asset.target,\n        };\n      }),\n      displayName: id,\n      description: id,\n    });\n  }\n}\n\n"]}

package/lib/providers/image-builders/index.d.ts

@@ -1,7 +1,9 @@
-export * from './ami';
+export * from './api';
+export * from './aws-image-builder';
 export * from './codebuild';
+export * from './codebuild-deprecated';
 export * from './common';
-export * from './container';
-export * from './windows-components';
-export * from './linux-components';
+export * from './components';
+export * from './aws-image-builder/deprecated/windows-components';
+export * from './aws-image-builder/deprecated/linux-components';
 export * from './static';