@cloudsnorkel/cdk-github-runners 0.9.4 → 0.9.5

package/lib/image-builders/aws-image-builder/deprecated/linux-components.js

@@ -0,0 +1,172 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinuxUbuntuComponents = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const common_1 = require("../../../providers/common");
+const index_1 = require("../index");
+/**
+ * Components for Ubuntu Linux that can be used with AWS Image Builder based builders. These cannot be used by {@link CodeBuildImageBuilder}.
+ *
+ * @deprecated Use `RunnerImageComponent` instead.
+ */
+class LinuxUbuntuComponents {
+    static requiredPackages(scope, id, architecture) {
+        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 new index_1.ImageBuilderComponent(scope, id, {
+            platform: 'Linux',
+            displayName: 'Required packages',
+            description: 'Install packages required for GitHub Runner and upgrade all packages',
+            commands: [
+                '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',
+            ],
+        });
+    }
+    static runnerUser(scope, id, _architecture) {
+        return new index_1.ImageBuilderComponent(scope, id, {
+            platform: 'Linux',
+            displayName: 'GitHub Runner user',
+            description: 'Install latest version of AWS CLI',
+            commands: [
+                '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',
+            ],
+        });
+    }
+    static awsCli(scope, id, architecture) {
+        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 new index_1.ImageBuilderComponent(scope, id, {
+            platform: 'Linux',
+            displayName: 'AWS CLI',
+            description: 'Install latest version of AWS CLI',
+            commands: [
+                `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',
+            ],
+        });
+    }
+    static githubCli(scope, id, _architecture) {
+        return new index_1.ImageBuilderComponent(scope, id, {
+            platform: 'Linux',
+            displayName: 'GitHub CLI',
+            description: 'Install latest version of gh',
+            commands: [
+                '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',
+            ],
+        });
+    }
+    static git(scope, id, _architecture) {
+        return new index_1.ImageBuilderComponent(scope, id, {
+            platform: 'Linux',
+            displayName: 'Git',
+            description: 'Install latest version of git',
+            commands: [
+                'add-apt-repository ppa:git-core/ppa',
+                'apt-get update',
+                'DEBIAN_FRONTEND=noninteractive apt-get install -y git',
+            ],
+        });
+    }
+    static githubRunner(scope, id, runnerVersion, architecture) {
+        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}`);
+        }
+        return new index_1.ImageBuilderComponent(scope, id, {
+            platform: 'Linux',
+            displayName: 'GitHub Actions Runner',
+            description: 'Install latest version of GitHub Actions Runner',
+            commands: [
+                versionCommand,
+                `curl -fsSLO "https://github.com/actions/runner/releases/download/v\${RUNNER_VERSION}/actions-runner-linux-${archUrl}-\${RUNNER_VERSION}.tar.gz"`,
+                `tar xzf "actions-runner-linux-${archUrl}-\${RUNNER_VERSION}.tar.gz"`,
+                `rm actions-runner-linux-${archUrl}-\${RUNNER_VERSION}.tar.gz`,
+                './bin/installdependencies.sh',
+                `echo -n ${runnerVersion.version} > RUNNER_VERSION`,
+            ],
+        });
+    }
+    static docker(scope, id, _architecture) {
+        return new index_1.ImageBuilderComponent(scope, id, {
+            platform: 'Linux',
+            displayName: 'Docker',
+            description: 'Install latest version of Docker',
+            commands: [
+                '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',
+            ],
+        });
+    }
+    static extraCertificates(scope, id, path) {
+        return new index_1.ImageBuilderComponent(scope, id, {
+            platform: 'Linux',
+            displayName: 'Extra certificates',
+            description: 'Install self-signed certificates to provide access to GitHub Enterprise Server',
+            commands: [
+                'cp certs/certs.pem /usr/local/share/ca-certificates/github-enterprise-server.crt',
+                'update-ca-certificates',
+            ],
+            assets: [
+                {
+                    path: 'certs',
+                    asset: new aws_cdk_lib_1.aws_s3_assets.Asset(scope, `${id} Asset`, { path }),
+                },
+            ],
+        });
+    }
+}
+_a = JSII_RTTI_SYMBOL_1;
+LinuxUbuntuComponents[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.LinuxUbuntuComponents", version: "0.9.5" };
+exports.LinuxUbuntuComponents = LinuxUbuntuComponents;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"linux-components.js","sourceRoot":"","sources":["../../../../src/image-builders/aws-image-builder/deprecated/linux-components.ts"],"names":[],"mappings":"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","sourcesContent":["import { aws_s3_assets as s3_assets } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { Architecture, RunnerVersion } from '../../../providers/common';\nimport { ImageBuilderComponent } from '../index';\n\n/**\n * Components for Ubuntu Linux that can be used with AWS Image Builder based builders. These cannot be used by {@link CodeBuildImageBuilder}.\n *\n * @deprecated Use `RunnerImageComponent` instead.\n */\nexport class LinuxUbuntuComponents {\n  public static requiredPackages(scope: Construct, id: string, architecture: Architecture) {\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 new ImageBuilderComponent(scope, id, {\n      platform: 'Linux',\n      displayName: 'Required packages',\n      description: 'Install packages required for GitHub Runner and upgrade all packages',\n      commands: [\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    });\n  }\n\n  public static runnerUser(scope: Construct, id: string, _architecture: Architecture) {\n    return new ImageBuilderComponent(scope, id, {\n      platform: 'Linux',\n      displayName: 'GitHub Runner user',\n      description: 'Install latest version of AWS CLI',\n      commands: [\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    });\n  }\n\n  public static awsCli(scope: Construct, id: string, architecture: Architecture) {\n    let archUrl;\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 new ImageBuilderComponent(scope, id, {\n      platform: 'Linux',\n      displayName: 'AWS CLI',\n      description: 'Install latest version of AWS CLI',\n      commands: [\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    });\n  }\n\n  public static githubCli(scope: Construct, id: string, _architecture: Architecture) {\n    return new ImageBuilderComponent(scope, id, {\n      platform: 'Linux',\n      displayName: 'GitHub CLI',\n      description: 'Install latest version of gh',\n      commands: [\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    });\n  }\n\n  public static git(scope: Construct, id: string, _architecture: Architecture) {\n    return new ImageBuilderComponent(scope, id, {\n      platform: 'Linux',\n      displayName: 'Git',\n      description: 'Install latest version of git',\n      commands: [\n        'add-apt-repository ppa:git-core/ppa',\n        'apt-get update',\n        'DEBIAN_FRONTEND=noninteractive apt-get install -y git',\n      ],\n    });\n  }\n\n  public static githubRunner(scope: Construct, id: string, runnerVersion: RunnerVersion, architecture: Architecture) {\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    return new ImageBuilderComponent(scope, id, {\n      platform: 'Linux',\n      displayName: 'GitHub Actions Runner',\n      description: 'Install latest version of GitHub Actions Runner',\n      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 xzf \"actions-runner-linux-${archUrl}-\\${RUNNER_VERSION}.tar.gz\"`,\n        `rm actions-runner-linux-${archUrl}-\\${RUNNER_VERSION}.tar.gz`,\n        './bin/installdependencies.sh',\n        `echo -n ${runnerVersion.version} > RUNNER_VERSION`,\n      ],\n    });\n  }\n\n  public static docker(scope: Construct, id: string, _architecture: Architecture) {\n    return new ImageBuilderComponent(scope, id, {\n      platform: 'Linux',\n      displayName: 'Docker',\n      description: 'Install latest version of Docker',\n      commands: [\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    });\n  }\n\n  public static extraCertificates(scope: Construct, id: string, path: string) {\n    return new ImageBuilderComponent(scope, id, {\n      platform: 'Linux',\n      displayName: 'Extra certificates',\n      description: 'Install self-signed certificates to provide access to GitHub Enterprise Server',\n      commands: [\n        'cp certs/certs.pem /usr/local/share/ca-certificates/github-enterprise-server.crt',\n        'update-ca-certificates',\n      ],\n      assets: [\n        {\n          path: 'certs',\n          asset: new s3_assets.Asset(scope, `${id} Asset`, { path }),\n        },\n      ],\n    });\n  }\n}\n"]}

package/lib/{providers/image-builders → image-builders}/aws-image-builder/deprecated/windows-components.d.ts

@@ -1,5 +1,5 @@
 import { Construct } from 'constructs';
-import { RunnerVersion } from '../../../common';
+import { RunnerVersion } from '../../../providers';
 import { ImageBuilderComponent } from '../builder';
 /**
  * Components for Windows that can be used with AWS Image Builder based builders. These cannot be used by {@link CodeBuildImageBuilder}.

package/lib/image-builders/aws-image-builder/deprecated/windows-components.js

@@ -0,0 +1,126 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowsComponents = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const providers_1 = require("../../../providers");
+const components_1 = require("../../components");
+const builder_1 = require("../builder");
+/**
+ * Components for Windows that can be used with AWS Image Builder based builders. These cannot be used by {@link CodeBuildImageBuilder}.
+ *
+ * @deprecated Use `RunnerImageComponent` instead.
+ */
+class WindowsComponents {
+    static cloudwatchAgent(scope, id) {
+        return new builder_1.ImageBuilderComponent(scope, id, {
+            platform: 'Windows',
+            displayName: 'CloudWatch agent',
+            description: 'Install latest version of CloudWatch agent for sending logs to CloudWatch',
+            commands: [
+                '$p = Start-Process msiexec.exe -PassThru -Wait -ArgumentList \'/i https://s3.amazonaws.com/amazoncloudwatch-agent/windows/amd64/latest/amazon-cloudwatch-agent.msi /qn\'',
+                'if ($p.ExitCode -ne 0) { throw "Exit code is $p.ExitCode" }',
+            ],
+        });
+    }
+    static awsCli(scope, id) {
+        return new builder_1.ImageBuilderComponent(scope, id, {
+            platform: 'Windows',
+            displayName: 'AWS CLI',
+            description: 'Install latest version of AWS CLI',
+            commands: [
+                '$p = Start-Process msiexec.exe -PassThru -Wait -ArgumentList \'/i https://awscli.amazonaws.com/AWSCLIV2.msi /qn\'',
+                'if ($p.ExitCode -ne 0) { throw "Exit code is $p.ExitCode" }',
+            ],
+        });
+    }
+    static githubCli(scope, id) {
+        return new builder_1.ImageBuilderComponent(scope, id, {
+            platform: 'Windows',
+            displayName: 'GitHub CLI',
+            description: 'Install latest version of gh',
+            commands: [
+                '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',
+                '$p = Start-Process msiexec.exe -PassThru -Wait -ArgumentList \'/i gh.msi /qn\'',
+                'if ($p.ExitCode -ne 0) { throw "Exit code is $p.ExitCode" }',
+                'del gh.msi',
+            ],
+        });
+    }
+    static git(scope, id) {
+        return new builder_1.ImageBuilderComponent(scope, id, {
+            platform: 'Windows',
+            displayName: 'Git',
+            description: 'Install latest version of git',
+            commands: [
+                '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',
+                '$p = Start-Process git-setup.exe -PassThru -Wait -ArgumentList \'/VERYSILENT\'',
+                'if ($p.ExitCode -ne 0) { throw "Exit code is $p.ExitCode" }',
+                'del git-setup.exe',
+            ],
+        });
+    }
+    static githubRunner(scope, id, runnerVersion) {
+        let runnerCommands;
+        if (runnerVersion.is(providers_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 new builder_1.ImageBuilderComponent(scope, id, {
+            platform: 'Windows',
+            displayName: 'GitHub Actions Runner',
+            description: 'Install latest version of GitHub Actions Runner',
+            commands: 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`,
+            ]),
+        });
+    }
+    static docker(scope, id) {
+        return new builder_1.ImageBuilderComponent(scope, id, {
+            platform: 'Windows',
+            displayName: 'Docker',
+            description: 'Install latest version of Docker',
+            commands: components_1.RunnerImageComponent.docker().getCommands(providers_1.Os.WINDOWS, providers_1.Architecture.X86_64),
+            reboot: true,
+        });
+    }
+    static extraCertificates(scope, id, path) {
+        return new builder_1.ImageBuilderComponent(scope, id, {
+            platform: 'Windows',
+            displayName: 'Extra certificates',
+            description: 'Install self-signed certificates to provide access to GitHub Enterprise Server',
+            commands: [
+                'Import-Certificate -FilePath certs\\certs.pem -CertStoreLocation Cert:\\LocalMachine\\Root',
+            ],
+            assets: [
+                {
+                    path: 'certs',
+                    asset: new aws_cdk_lib_1.aws_s3_assets.Asset(scope, `${id} Asset`, { path }),
+                },
+            ],
+        });
+    }
+}
+_a = JSII_RTTI_SYMBOL_1;
+WindowsComponents[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.WindowsComponents", version: "0.9.5" };
+exports.WindowsComponents = WindowsComponents;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"windows-components.js","sourceRoot":"","sources":["../../../../src/image-builders/aws-image-builder/deprecated/windows-components.ts"],"names":[],"mappings":"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","sourcesContent":["import { aws_s3_assets as s3_assets } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { Architecture, Os, RunnerVersion } from '../../../providers';\nimport { RunnerImageComponent } from '../../components';\nimport { ImageBuilderComponent } from '../builder';\n\n/**\n * Components for Windows that can be used with AWS Image Builder based builders. These cannot be used by {@link CodeBuildImageBuilder}.\n *\n * @deprecated Use `RunnerImageComponent` instead.\n */\nexport class WindowsComponents {\n  public static cloudwatchAgent(scope: Construct, id: string) {\n    return new ImageBuilderComponent(scope, id, {\n      platform: 'Windows',\n      displayName: 'CloudWatch agent',\n      description: 'Install latest version of CloudWatch agent for sending logs to CloudWatch',\n      commands: [\n        '$p = Start-Process msiexec.exe -PassThru -Wait -ArgumentList \\'/i https://s3.amazonaws.com/amazoncloudwatch-agent/windows/amd64/latest/amazon-cloudwatch-agent.msi /qn\\'',\n        'if ($p.ExitCode -ne 0) { throw \"Exit code is $p.ExitCode\" }',\n      ],\n    });\n  }\n\n  public static awsCli(scope: Construct, id: string) {\n    return new ImageBuilderComponent(scope, id, {\n      platform: 'Windows',\n      displayName: 'AWS CLI',\n      description: 'Install latest version of AWS CLI',\n      commands: [\n        '$p = Start-Process msiexec.exe -PassThru -Wait -ArgumentList \\'/i https://awscli.amazonaws.com/AWSCLIV2.msi /qn\\'',\n        'if ($p.ExitCode -ne 0) { throw \"Exit code is $p.ExitCode\" }',\n      ],\n    });\n  }\n\n  public static githubCli(scope: Construct, id: string) {\n    return new ImageBuilderComponent(scope, id, {\n      platform: 'Windows',\n      displayName: 'GitHub CLI',\n      description: 'Install latest version of gh',\n      commands: [\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        '$p = Start-Process msiexec.exe -PassThru -Wait -ArgumentList \\'/i gh.msi /qn\\'',\n        'if ($p.ExitCode -ne 0) { throw \"Exit code is $p.ExitCode\" }',\n        'del gh.msi',\n      ],\n    });\n  }\n\n  public static git(scope: Construct, id: string) {\n    return new ImageBuilderComponent(scope, id, {\n      platform: 'Windows',\n      displayName: 'Git',\n      description: 'Install latest version of git',\n      commands: [\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        '$p = Start-Process git-setup.exe -PassThru -Wait -ArgumentList \\'/VERYSILENT\\'',\n        'if ($p.ExitCode -ne 0) { throw \"Exit code is $p.ExitCode\" }',\n        'del git-setup.exe',\n      ],\n    });\n  }\n\n  public static githubRunner(scope: Construct, id: string, runnerVersion: RunnerVersion) {\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 new ImageBuilderComponent(scope, id, {\n      platform: 'Windows',\n      displayName: 'GitHub Actions Runner',\n      description: 'Install latest version of GitHub Actions Runner',\n      commands: 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\n  public static docker(scope: Construct, id: string) {\n    return new ImageBuilderComponent(scope, id, {\n      platform: 'Windows',\n      displayName: 'Docker',\n      description: 'Install latest version of Docker',\n      commands: RunnerImageComponent.docker().getCommands(Os.WINDOWS, Architecture.X86_64),\n      reboot: true,\n    });\n  }\n\n  public static extraCertificates(scope: Construct, id: string, path: string) {\n    return new ImageBuilderComponent(scope, id, {\n      platform: 'Windows',\n      displayName: 'Extra certificates',\n      description: 'Install self-signed certificates to provide access to GitHub Enterprise Server',\n      commands: [\n        'Import-Certificate -FilePath certs\\\\certs.pem -CertStoreLocation Cert:\\\\LocalMachine\\\\Root',\n      ],\n      assets: [\n        {\n          path: 'certs',\n          asset: new s3_assets.Asset(scope, `${id} Asset`, { path }),\n        },\n      ],\n    });\n  }\n}\n"]}

package/lib/{providers/image-builders → image-builders}/aws-image-builder/filter-failed-builds-function.d.ts

@@ -6,7 +6,7 @@ import { Construct } from 'constructs';
 export interface FilterFailedBuildsFunctionProps extends lambda.FunctionOptions {
 }
 /**
- * An AWS Lambda function which executes src/providers/image-builders/aws-image-builder/filter-failed-builds.
+ * An AWS Lambda function which executes src/image-builders/aws-image-builder/filter-failed-builds.
  */
 export declare class FilterFailedBuildsFunction extends lambda.Function {
     constructor(scope: Construct, id: string, props?: FilterFailedBuildsFunctionProps);

package/lib/image-builders/aws-image-builder/filter-failed-builds-function.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterFailedBuildsFunction = void 0;
+// ~~ Generated by projen. To modify, edit .projenrc.js and run "npx projen".
+const path = require("path");
+const lambda = require("aws-cdk-lib/aws-lambda");
+/**
+ * An AWS Lambda function which executes src/image-builders/aws-image-builder/filter-failed-builds.
+ */
+class FilterFailedBuildsFunction extends lambda.Function {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            description: 'src/image-builders/aws-image-builder/filter-failed-builds.lambda.ts',
+            ...props,
+            runtime: new lambda.Runtime('nodejs16.x', lambda.RuntimeFamily.NODEJS),
+            handler: 'index.handler',
+            code: lambda.Code.fromAsset(path.join(__dirname, '../../../assets/image-builders/aws-image-builder/filter-failed-builds.lambda')),
+        });
+        this.addEnvironment('AWS_NODEJS_CONNECTION_REUSE_ENABLED', '1', { removeInEdge: true });
+    }
+}
+exports.FilterFailedBuildsFunction = FilterFailedBuildsFunction;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/image-builders/aws-image-builder/filter-failed-builds.lambda.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable-next-line import/no-extraneous-dependencies */
+const AWS = require("aws-sdk");
+const sns = new AWS.SNS();
+exports.handler = async function (event) {
+    console.log(JSON.stringify(event));
+    for (const record of event.Records) {
+        let message = JSON.parse(record.Sns.Message);
+        if (message.state.status === 'FAILED') {
+            await sns.publish({
+                TopicArn: process.env.TARGET_TOPIC_ARN,
+                Message: record.Sns.Message,
+            }).promise();
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLWZhaWxlZC1idWlsZHMubGFtYmRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2ltYWdlLWJ1aWxkZXJzL2F3cy1pbWFnZS1idWlsZGVyL2ZpbHRlci1mYWlsZWQtYnVpbGRzLmxhbWJkYS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUVBLGdFQUFnRTtBQUNoRSwrQkFBK0I7QUFFL0IsTUFBTSxHQUFHLEdBQUcsSUFBSSxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUM7QUFFMUIsT0FBTyxDQUFDLE9BQU8sR0FBRyxLQUFLLFdBQVUsS0FBeUI7SUFDeEQsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDbkMsS0FBSyxNQUFNLE1BQU0sSUFBSSxLQUFLLENBQUMsT0FBTyxFQUFFO1FBQ2xDLElBQUksT0FBTyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUM3QyxJQUFJLE9BQU8sQ0FBQyxLQUFLLENBQUMsTUFBTSxLQUFLLFFBQVEsRUFBRTtZQUNyQyxNQUFNLEdBQUcsQ0FBQyxPQUFPLENBQUM7Z0JBQ2hCLFFBQVEsRUFBRSxPQUFPLENBQUMsR0FBRyxDQUFDLGdCQUFnQjtnQkFDdEMsT0FBTyxFQUFFLE1BQU0sQ0FBQyxHQUFHLENBQUMsT0FBTzthQUM1QixDQUFDLENBQUMsT0FBTyxFQUFFLENBQUM7U0FDZDtLQUNGO0FBQ0gsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIGltcG9ydC9uby1leHRyYW5lb3VzLWRlcGVuZGVuY2llcyxpbXBvcnQvbm8tdW5yZXNvbHZlZCAqL1xuaW1wb3J0ICogYXMgQVdTTGFtYmRhIGZyb20gJ2F3cy1sYW1iZGEnO1xuLyogZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIGltcG9ydC9uby1leHRyYW5lb3VzLWRlcGVuZGVuY2llcyAqL1xuaW1wb3J0ICogYXMgQVdTIGZyb20gJ2F3cy1zZGsnO1xuXG5jb25zdCBzbnMgPSBuZXcgQVdTLlNOUygpO1xuXG5leHBvcnRzLmhhbmRsZXIgPSBhc3luYyBmdW5jdGlvbihldmVudDogQVdTTGFtYmRhLlNOU0V2ZW50KSB7XG4gIGNvbnNvbGUubG9nKEpTT04uc3RyaW5naWZ5KGV2ZW50KSk7XG4gIGZvciAoY29uc3QgcmVjb3JkIG9mIGV2ZW50LlJlY29yZHMpIHtcbiAgICBsZXQgbWVzc2FnZSA9IEpTT04ucGFyc2UocmVjb3JkLlNucy5NZXNzYWdlKTtcbiAgICBpZiAobWVzc2FnZS5zdGF0ZS5zdGF0dXMgPT09ICdGQUlMRUQnKSB7XG4gICAgICBhd2FpdCBzbnMucHVibGlzaCh7XG4gICAgICAgIFRvcGljQXJuOiBwcm9jZXNzLmVudi5UQVJHRVRfVE9QSUNfQVJOLFxuICAgICAgICBNZXNzYWdlOiByZWNvcmQuU25zLk1lc3NhZ2UsXG4gICAgICB9KS5wcm9taXNlKCk7XG4gICAgfVxuICB9XG59O1xuIl19

package/lib/{providers/image-builders → image-builders}/aws-image-builder/index.js

@@ -19,4 +19,4 @@ __exportStar(require("./builder"), exports);
 __exportStar(require("./common"), exports);
 __exportStar(require("./container"), exports);
 __exportStar(require("./deprecated"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2ltYWdlLWJ1aWxkZXJzL2F3cy1pbWFnZS1idWlsZGVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx3Q0FBc0I7QUFDdEIsNENBQTBCO0FBQzFCLDJDQUF5QjtBQUN6Qiw4Q0FBNEI7QUFDNUIsK0NBQTZCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hbWknO1xuZXhwb3J0ICogZnJvbSAnLi9idWlsZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vY29tbW9uJztcbmV4cG9ydCAqIGZyb20gJy4vY29udGFpbmVyJztcbmV4cG9ydCAqIGZyb20gJy4vZGVwcmVjYXRlZCc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaW1hZ2UtYnVpbGRlcnMvYXdzLWltYWdlLWJ1aWxkZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHdDQUFzQjtBQUN0Qiw0Q0FBMEI7QUFDMUIsMkNBQXlCO0FBQ3pCLDhDQUE0QjtBQUM1QiwrQ0FBNkIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FtaSc7XG5leHBvcnQgKiBmcm9tICcuL2J1aWxkZXInO1xuZXhwb3J0ICogZnJvbSAnLi9jb21tb24nO1xuZXhwb3J0ICogZnJvbSAnLi9jb250YWluZXInO1xuZXhwb3J0ICogZnJvbSAnLi9kZXByZWNhdGVkJztcbiJdfQ==

package/lib/{providers/image-builders → image-builders}/aws-image-builder/versioner-function.d.ts

@@ -6,7 +6,7 @@ import { Construct } from 'constructs';
 export interface VersionerFunctionProps extends lambda.FunctionOptions {
 }
 /**
- * An AWS Lambda function which executes src/providers/image-builders/aws-image-builder/versioner.
+ * An AWS Lambda function which executes src/image-builders/aws-image-builder/versioner.
  */
 export declare class VersionerFunction extends lambda.Function {
     constructor(scope: Construct, id: string, props?: VersionerFunctionProps);

package/lib/image-builders/aws-image-builder/versioner-function.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionerFunction = void 0;
+// ~~ Generated by projen. To modify, edit .projenrc.js and run "npx projen".
+const path = require("path");
+const lambda = require("aws-cdk-lib/aws-lambda");
+/**
+ * An AWS Lambda function which executes src/image-builders/aws-image-builder/versioner.
+ */
+class VersionerFunction extends lambda.Function {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            description: 'src/image-builders/aws-image-builder/versioner.lambda.ts',
+            ...props,
+            runtime: new lambda.Runtime('nodejs16.x', lambda.RuntimeFamily.NODEJS),
+            handler: 'index.handler',
+            code: lambda.Code.fromAsset(path.join(__dirname, '../../../assets/image-builders/aws-image-builder/versioner.lambda')),
+        });
+        this.addEnvironment('AWS_NODEJS_CONNECTION_REUSE_ENABLED', '1', { removeInEdge: true });
+    }
+}
+exports.VersionerFunction = VersionerFunction;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/image-builders/aws-image-builder/versioner.lambda.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+/* eslint-disable import/no-extraneous-dependencies */
+const AWS = require("aws-sdk");
+const semver_1 = require("semver");
+const lambda_helpers_1 = require("../../lambda-helpers");
+const ib = new AWS.Imagebuilder();
+/* eslint-disable @typescript-eslint/no-require-imports, import/no-extraneous-dependencies */
+async function handler(event, context) {
+    console.log(JSON.stringify({ ...event, ResponseURL: '...' }));
+    try {
+        const objectType = event.ResourceProperties.ObjectType;
+        const objectName = event.ResourceProperties.ObjectName;
+        switch (event.RequestType) {
+            case 'Create':
+            case 'Update':
+                let version = '1.0.0';
+                let allVersions = [];
+                try {
+                    switch (objectType) {
+                        case 'Component': {
+                            let result = {};
+                            do {
+                                result = await ib.listComponents({
+                                    filters: [{
+                                            name: 'name',
+                                            values: [objectName],
+                                        }],
+                                    nextToken: result.nextToken,
+                                }).promise();
+                                allVersions = allVersions.concat(result.componentVersionList.map(i => i.version || '1.0.0'));
+                            } while (result.nextToken);
+                            break;
+                        }
+                        case 'ImageRecipe': {
+                            let result = {};
+                            do {
+                                result = await ib.listImageRecipes({
+                                    filters: [{
+                                            name: 'name',
+                                            values: [objectName],
+                                        }],
+                                    nextToken: result.nextToken,
+                                }).promise();
+                                allVersions = allVersions.concat(result.imageRecipeSummaryList.map(i => i.arn?.split('/').pop() || '1.0.0'));
+                            } while (result.nextToken);
+                            break;
+                        }
+                        case 'ContainerRecipe': {
+                            let result = {};
+                            do {
+                                result = await ib.listContainerRecipes({
+                                    filters: [{
+                                            name: 'name',
+                                            values: [objectName],
+                                        }],
+                                    nextToken: result.nextToken,
+                                }).promise();
+                                allVersions = allVersions.concat(result.containerRecipeSummaryList.map(i => i.arn?.split('/').pop() || '1.0.0'));
+                            } while (result.nextToken);
+                            break;
+                        }
+                    }
+                }
+                catch (e) {
+                    if (e.code !== 'ResourceNotFoundException') {
+                        throw e;
+                    }
+                    else {
+                        console.log('Resource not found, assuming first version');
+                    }
+                }
+                version = (0, semver_1.maxSatisfying)(allVersions, '>=0.0.0');
+                if (version === null) {
+                    version = '1.0.0';
+                }
+                console.log(`Found versions ${allVersions} -- latest is ${version}`);
+                version = (0, semver_1.inc)(version, 'patch');
+                if (version === null) {
+                    throw new Error('Unable to bump version');
+                }
+                await (0, lambda_helpers_1.customResourceRespond)(event, 'SUCCESS', 'OK', version, {});
+                break;
+            case 'Delete':
+                await (0, lambda_helpers_1.customResourceRespond)(event, 'SUCCESS', 'OK', event.PhysicalResourceId, {});
+                break;
+        }
+    }
+    catch (e) {
+        console.log(e);
+        await (0, lambda_helpers_1.customResourceRespond)(event, 'FAILED', e.message || 'Internal Error', context.logStreamName, {});
+    }
+}
+exports.handler = handler;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"versioner.lambda.js","sourceRoot":"","sources":["../../../src/image-builders/aws-image-builder/versioner.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable-next-line import/no-extraneous-dependencies,import/no-unresolved */\nimport * as AWSLambda from 'aws-lambda';\n/* eslint-disable import/no-extraneous-dependencies */\nimport * as AWS from 'aws-sdk';\nimport { inc, maxSatisfying } from 'semver';\nimport { customResourceRespond } from '../../lambda-helpers';\n\nconst ib = new AWS.Imagebuilder();\n\n/* eslint-disable @typescript-eslint/no-require-imports, import/no-extraneous-dependencies */\nexport async function handler(event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context) {\n  console.log(JSON.stringify({ ...event, ResponseURL: '...' }));\n\n  try {\n    const objectType = event.ResourceProperties.ObjectType;\n    const objectName = event.ResourceProperties.ObjectName;\n\n    switch (event.RequestType) {\n      case 'Create':\n      case 'Update':\n        let version: string | null = '1.0.0';\n        let allVersions: string[] = [];\n        try {\n          switch (objectType) {\n            case 'Component': {\n              let result: AWS.Imagebuilder.ListComponentsResponse = {};\n              do {\n                result = await ib.listComponents({\n                  filters: [{\n                    name: 'name',\n                    values: [objectName],\n                  }],\n                  nextToken: result.nextToken,\n                }).promise();\n                allVersions = allVersions.concat(result.componentVersionList!.map(i => i.version || '1.0.0'));\n              } while (result.nextToken);\n              break;\n            }\n            case 'ImageRecipe': {\n              let result: AWS.Imagebuilder.ListImageRecipesResponse = {};\n              do {\n                result = await ib.listImageRecipes({\n                  filters: [{\n                    name: 'name',\n                    values: [objectName],\n                  }],\n                  nextToken: result.nextToken,\n                }).promise();\n                allVersions = allVersions.concat(result.imageRecipeSummaryList!.map(i => i.arn?.split('/').pop() || '1.0.0'));\n              } while (result.nextToken);\n              break;\n            }\n            case 'ContainerRecipe': {\n              let result: AWS.Imagebuilder.ListContainerRecipesResponse = {};\n              do {\n                result = await ib.listContainerRecipes({\n                  filters: [{\n                    name: 'name',\n                    values: [objectName],\n                  }],\n                  nextToken: result.nextToken,\n                }).promise();\n                allVersions = allVersions.concat(result.containerRecipeSummaryList!.map(i => i.arn?.split('/').pop() || '1.0.0'));\n              } while (result.nextToken);\n              break;\n            }\n          }\n        } catch (e) {\n          if ((e as any).code !== 'ResourceNotFoundException') {\n            throw e;\n          } else {\n            console.log('Resource not found, assuming first version');\n          }\n        }\n\n        version = maxSatisfying(allVersions, '>=0.0.0');\n        if (version === null) {\n          version = '1.0.0';\n        }\n        console.log(`Found versions ${allVersions} -- latest is ${version}`);\n\n        version = inc(version, 'patch');\n        if (version === null) {\n          throw new Error('Unable to bump version');\n        }\n        await customResourceRespond(event, 'SUCCESS', 'OK', version, {});\n\n        break;\n      case 'Delete':\n        await customResourceRespond(event, 'SUCCESS', 'OK', event.PhysicalResourceId, {});\n        break;\n    }\n  } catch (e) {\n    console.log(e);\n    await customResourceRespond(event, 'FAILED', (e as Error).message || 'Internal Error', context.logStreamName, {});\n  }\n}\n"]}

package/lib/{providers/image-builders → image-builders}/codebuild-deprecated.d.ts

@@ -1,7 +1,7 @@
 import { aws_codebuild as codebuild, aws_ec2 as ec2, aws_iam as iam, aws_logs as logs, Duration, RemovalPolicy } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 import { IRunnerImageBuilder } from './common';
-import { Architecture, Os, RunnerAmi, RunnerImage, RunnerVersion } from '../common';
+import { Architecture, Os, RunnerAmi, RunnerImage, RunnerVersion } from '../providers/common';
 /**
  * Properties for CodeBuildImageBuilder construct.
  */
@@ -66,7 +66,7 @@ export interface CodeBuildImageBuilderProps {
      *
      * The only action taken in CodeBuild is running `docker build`. You would therefore not need to change this setting often.
      *
-     * @default Ubuntu 20.04 for x64 and Amazon Linux 2 for ARM64
+     * @default Ubuntu 22.04 for x64 and Amazon Linux 2 for ARM64
      */
     readonly buildImage?: codebuild.IBuildImage;
     /**