@cloudsnorkel/cdk-github-runners 0.8.3 → 0.9.0

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

@@ -0,0 +1,180 @@
+"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("../../../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: [
+                'set -ex',
+                '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: [
+                'set -ex',
+                '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: [
+                'set -ex',
+                `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: [
+                'set -ex',
+                '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: [
+                'set -ex',
+                '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: [
+                'set -ex',
+                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: [
+                'set -ex',
+                '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: [
+                'set -ex',
+                '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.0" };
+exports.LinuxUbuntuComponents = LinuxUbuntuComponents;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"linux-components.js","sourceRoot":"","sources":["../../../../../src/providers/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 '../../../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        'set -ex',\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        'set -ex',\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        'set -ex',\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        'set -ex',\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        'set -ex',\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        'set -ex',\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        'set -ex',\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        'set -ex',\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/{windows-components.d.ts → aws-image-builder/deprecated/windows-components.d.ts}

@@ -1,8 +1,10 @@
 import { Construct } from 'constructs';
-import { ImageBuilderComponent } from './common';
-import { RunnerVersion } from '../common';
+import { RunnerVersion } from '../../../common';
+import { ImageBuilderComponent } from '../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.
  */
 export declare class WindowsComponents {
     static cloudwatchAgent(scope: Construct, id: string): ImageBuilderComponent;

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

@@ -0,0 +1,142 @@
+"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 common_1 = require("../../../common");
+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: [
+                '$ErrorActionPreference = \'Stop\'',
+                'Start-Process msiexec.exe -Wait -ArgumentList \'/i https://s3.amazonaws.com/amazoncloudwatch-agent/windows/amd64/latest/amazon-cloudwatch-agent.msi /qn\'',
+            ],
+        });
+    }
+    static awsCli(scope, id) {
+        return new builder_1.ImageBuilderComponent(scope, id, {
+            platform: 'Windows',
+            displayName: 'AWS CLI',
+            description: 'Install latest version of AWS CLI',
+            commands: [
+                '$ErrorActionPreference = \'Stop\'',
+                'Start-Process msiexec.exe -Wait -ArgumentList \'/i https://awscli.amazonaws.com/AWSCLIV2.msi /qn\'',
+            ],
+        });
+    }
+    static githubCli(scope, id) {
+        return new builder_1.ImageBuilderComponent(scope, id, {
+            platform: 'Windows',
+            displayName: 'GitHub CLI',
+            description: 'Install latest version of gh',
+            commands: [
+                '$ErrorActionPreference = \'Stop\'',
+                '$ProgressPreference = \'SilentlyContinue\'',
+                '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)',
+                '$ProgressPreference = \'SilentlyContinue\'',
+                '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',
+            ],
+        });
+    }
+    static git(scope, id) {
+        return new builder_1.ImageBuilderComponent(scope, id, {
+            platform: 'Windows',
+            displayName: 'Git',
+            description: 'Install latest version of git',
+            commands: [
+                '$ErrorActionPreference = \'Stop\'',
+                '$ProgressPreference = \'SilentlyContinue\'',
+                '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',
+            ],
+        });
+    }
+    static githubRunner(scope, id, runnerVersion) {
+        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 new builder_1.ImageBuilderComponent(scope, id, {
+            platform: 'Windows',
+            displayName: 'GitHub Actions Runner',
+            description: 'Install latest version of GitHub Actions Runner',
+            commands: [
+                '$ErrorActionPreference = \'Stop\'',
+                '$ProgressPreference = \'SilentlyContinue\'',
+            ].concat(runnerCommands, [
+                '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: [
+                '$ErrorActionPreference = \'Stop\'',
+                '$ProgressPreference = \'SilentlyContinue\'',
+                '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',
+            ],
+        });
+    }
+    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: [
+                '$ErrorActionPreference = \'Stop\'',
+                '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.0" };
+exports.WindowsComponents = WindowsComponents;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"windows-components.js","sourceRoot":"","sources":["../../../../../src/providers/image-builders/aws-image-builder/deprecated/windows-components.ts"],"names":[],"mappings":";;;;;AAAA,6CAAyD;AAEzD,4CAAgD;AAChD,wCAAmD;AAEnD;;;;GAIG;AACH,MAAa,iBAAiB;IACrB,MAAM,CAAC,eAAe,CAAC,KAAgB,EAAE,EAAU;QACxD,OAAO,IAAI,+BAAqB,CAAC,KAAK,EAAE,EAAE,EAAE;YAC1C,QAAQ,EAAE,SAAS;YACnB,WAAW,EAAE,kBAAkB;YAC/B,WAAW,EAAE,2EAA2E;YACxF,QAAQ,EAAE;gBACR,mCAAmC;gBACnC,2JAA2J;aAC5J;SACF,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,MAAM,CAAC,KAAgB,EAAE,EAAU;QAC/C,OAAO,IAAI,+BAAqB,CAAC,KAAK,EAAE,EAAE,EAAE;YAC1C,QAAQ,EAAE,SAAS;YACnB,WAAW,EAAE,SAAS;YACtB,WAAW,EAAE,mCAAmC;YAChD,QAAQ,EAAE;gBACR,mCAAmC;gBACnC,oGAAoG;aACrG;SACF,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,SAAS,CAAC,KAAgB,EAAE,EAAU;QAClD,OAAO,IAAI,+BAAqB,CAAC,KAAK,EAAE,EAAE,EAAE;YAC1C,QAAQ,EAAE,SAAS;YACnB,WAAW,EAAE,YAAY;YACzB,WAAW,EAAE,8BAA8B;YAC3C,QAAQ,EAAE;gBACR,mCAAmC;gBACnC,4CAA4C;gBAC5C,yGAAyG;gBACzG,+CAA+C;gBAC/C,0DAA0D;gBAC1D,4CAA4C;gBAC5C,0JAA0J;gBAC1J,iEAAiE;gBACjE,YAAY;aACb;SACF,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,GAAG,CAAC,KAAgB,EAAE,EAAU;QAC5C,OAAO,IAAI,+BAAqB,CAAC,KAAK,EAAE,EAAE,EAAE;YAC1C,QAAQ,EAAE,SAAS;YACnB,WAAW,EAAE,KAAK;YAClB,WAAW,EAAE,+BAA+B;YAC5C,QAAQ,EAAE;gBACR,mCAAmC;gBACnC,4CAA4C;gBAC5C,sHAAsH;gBACtH,gDAAgD;gBAChD,2DAA2D;gBAC3D,6DAA6D;gBAC7D,wDAAwD;gBACxD,oFAAoF;gBACpF,6KAA6K;gBAC7K,iEAAiE;gBACjE,mBAAmB;aACpB;SACF,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,YAAY,CAAC,KAAgB,EAAE,EAAU,EAAE,aAA4B;QACnF,IAAI,cAAwB,CAAC;QAC7B,IAAI,aAAa,CAAC,EAAE,CAAC,sBAAa,CAAC,MAAM,EAAE,CAAC,EAAE;YAC5C,cAAc,GAAG;gBACf,iHAAiH;gBACjH,gDAAgD;gBAChD,8DAA8D;aAC/D,CAAC;SACH;aAAM;YACL,cAAc,GAAG,CAAC,sBAAsB,aAAa,CAAC,OAAO,GAAG,CAAC,CAAC;SACnE;QAED,OAAO,IAAI,+BAAqB,CAAC,KAAK,EAAE,EAAE,EAAE;YAC1C,QAAQ,EAAE,SAAS;YACnB,WAAW,EAAE,uBAAuB;YACpC,WAAW,EAAE,iDAAiD;YAC9D,QAAQ,EAAE;gBACR,mCAAmC;gBACnC,4CAA4C;aAC7C,CAAC,MAAM,CAAC,cAAc,EAAE;gBACvB,oLAAoL;gBACpL,yDAAyD;gBACzD,iBAAiB;gBACjB,QAAQ,aAAa,CAAC,OAAO,oEAAoE;aAClG,CAAC;SACH,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,MAAM,CAAC,KAAgB,EAAE,EAAU;QAC/C,OAAO,IAAI,+BAAqB,CAAC,KAAK,EAAE,EAAE,EAAE;YAC1C,QAAQ,EAAE,SAAS;YACnB,WAAW,EAAE,QAAQ;YACrB,WAAW,EAAE,kCAAkC;YAC/C,QAAQ,EAAE;gBACR,mCAAmC;gBACnC,4CAA4C;gBAC5C,8IAA8I;gBAC9I,8FAA8F;gBAC9F,sBAAsB;gBACtB,4HAA4H;gBAC5H,2DAA2D;gBAC3D,sDAAsD;gBACtD,gNAAgN;gBAChN,+GAA+G;aAChH;SACF,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,iBAAiB,CAAC,KAAgB,EAAE,EAAU,EAAE,IAAY;QACxE,OAAO,IAAI,+BAAqB,CAAC,KAAK,EAAE,EAAE,EAAE;YAC1C,QAAQ,EAAE,SAAS;YACnB,WAAW,EAAE,oBAAoB;YACjC,WAAW,EAAE,gFAAgF;YAC7F,QAAQ,EAAE;gBACR,mCAAmC;gBACnC,4FAA4F;aAC7F;YACD,MAAM,EAAE;gBACN;oBACE,IAAI,EAAE,OAAO;oBACb,KAAK,EAAE,IAAI,2BAAS,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,CAAC;iBAC3D;aACF;SACF,CAAC,CAAC;IACL,CAAC;;;;AAjIU,8CAAiB","sourcesContent":["import { aws_s3_assets as s3_assets } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { RunnerVersion } from '../../../common';\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        '$ErrorActionPreference = \\'Stop\\'',\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\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        '$ErrorActionPreference = \\'Stop\\'',\n        'Start-Process msiexec.exe -Wait -ArgumentList \\'/i https://awscli.amazonaws.com/AWSCLIV2.msi /qn\\'',\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        '$ErrorActionPreference = \\'Stop\\'',\n        '$ProgressPreference = \\'SilentlyContinue\\'',\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        '$ProgressPreference = \\'SilentlyContinue\\'',\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\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        '$ErrorActionPreference = \\'Stop\\'',\n        '$ProgressPreference = \\'SilentlyContinue\\'',\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\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: [\n        '$ErrorActionPreference = \\'Stop\\'',\n        '$ProgressPreference = \\'SilentlyContinue\\'',\n      ].concat(runnerCommands, [\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: [\n        '$ErrorActionPreference = \\'Stop\\'',\n        '$ProgressPreference = \\'SilentlyContinue\\'',\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\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        '$ErrorActionPreference = \\'Stop\\'',\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/aws-image-builder/index.d.ts

@@ -0,0 +1,5 @@
+export * from './ami';
+export * from './builder';
+export * from './common';
+export * from './container';
+export * from './deprecated';

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

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ami"), exports);
+__exportStar(require("./builder"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./container"), exports);
+__exportStar(require("./deprecated"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2ltYWdlLWJ1aWxkZXJzL2F3cy1pbWFnZS1idWlsZGVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx3Q0FBc0I7QUFDdEIsNENBQTBCO0FBQzFCLDJDQUF5QjtBQUN6Qiw4Q0FBNEI7QUFDNUIsK0NBQTZCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hbWknO1xuZXhwb3J0ICogZnJvbSAnLi9idWlsZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vY29tbW9uJztcbmV4cG9ydCAqIGZyb20gJy4vY29udGFpbmVyJztcbmV4cG9ydCAqIGZyb20gJy4vZGVwcmVjYXRlZCc7XG4iXX0=

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

@@ -0,0 +1,195 @@
+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';
+/**
+ * Properties for CodeBuildImageBuilder construct.
+ */
+export interface CodeBuildImageBuilderProps {
+    /**
+     * Image architecture.
+     *
+     * @default Architecture.X86_64
+     */
+    readonly architecture?: Architecture;
+    /**
+     * Image OS.
+     *
+     * @default OS.LINUX
+     */
+    readonly os?: Os;
+    /**
+     * Path to Dockerfile to be built. It can be a path to a Dockerfile, a folder containing a Dockerfile, or a zip file containing a Dockerfile.
+     */
+    readonly dockerfilePath: string;
+    /**
+     * Version of GitHub Runners to install.
+     *
+     * @default latest version available
+     */
+    readonly runnerVersion?: RunnerVersion;
+    /**
+     * Schedule the image to be rebuilt every given interval. Useful for keeping the image up-do-date with the latest GitHub runner version and latest OS updates.
+     *
+     * Set to zero to disable.
+     *
+     * @default Duration.days(7)
+     */
+    readonly rebuildInterval?: Duration;
+    /**
+     * VPC to build the image in.
+     *
+     * @default no VPC
+     */
+    readonly vpc?: ec2.IVpc;
+    /**
+     * Security Group to assign to this instance.
+     *
+     * @default public project with no security group
+     */
+    readonly securityGroup?: ec2.ISecurityGroup;
+    /**
+     * Where to place the network interfaces within the VPC.
+     *
+     * @default no subnet
+     */
+    readonly subnetSelection?: ec2.SubnetSelection;
+    /**
+     * The type of compute to use for this build.
+     * See the {@link ComputeType} enum for the possible values.
+     *
+     * @default {@link ComputeType#SMALL}
+     */
+    readonly computeType?: codebuild.ComputeType;
+    /**
+     * Build image to use in CodeBuild. This is the image that's going to run the code that builds the runner image.
+     *
+     * 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
+     */
+    readonly buildImage?: codebuild.IBuildImage;
+    /**
+     * The number of minutes after which AWS CodeBuild stops the build if it's
+     * not complete. For valid values, see the timeoutInMinutes field in the AWS
+     * CodeBuild User Guide.
+     *
+     * @default Duration.hours(1)
+     */
+    readonly timeout?: Duration;
+    /**
+     * The number of days log events are kept in CloudWatch Logs. When updating
+     * this property, unsetting it doesn't remove the log retention policy. To
+     * remove the retention policy, set the value to `INFINITE`.
+     *
+     * @default logs.RetentionDays.ONE_MONTH
+     */
+    readonly logRetention?: logs.RetentionDays;
+    /**
+     * Removal policy for logs of image builds. If deployment fails on the custom resource, try setting this to `RemovalPolicy.RETAIN`. This way the CodeBuild logs can still be viewed, and you can see why the build failed.
+     *
+     * We try to not leave anything behind when removed. But sometimes a log staying behind is useful.
+     *
+     * @default RemovalPolicy.DESTROY
+     */
+    readonly logRemovalPolicy?: RemovalPolicy;
+}
+/**
+ * An image builder that uses CodeBuild to build Docker images pre-baked with all the GitHub Actions runner requirements. Builders can be used with runner providers.
+ *
+ * Each builder re-runs automatically at a set interval to make sure the images contain the latest versions of everything.
+ *
+ * You can create an instance of this construct to customize the image used to spin-up runners. Each provider has its own requirements for what an image should do. That's why they each provide their own Dockerfile.
+ *
+ * For example, to set a specific runner version, rebuild the image every 2 weeks, and add a few packages for the Fargate provider, use:
+ *
+ * ```
+ * const builder = new CodeBuildImageBuilder(this, 'Builder', {
+ *     dockerfilePath: FargateProvider.LINUX_X64_DOCKERFILE_PATH,
+ *     runnerVersion: RunnerVersion.specific('2.293.0'),
+ *     rebuildInterval: Duration.days(14),
+ * });
+ * builder.setBuildArg('EXTRA_PACKAGES', 'nginx xz-utils');
+ * new FargateRunner(this, 'Fargate provider', {
+ *     label: 'customized-fargate',
+ *     imageBuilder: builder,
+ * });
+ * ```
+ *
+ * @deprecated use RunnerImageBuilder
+ */
+export declare class CodeBuildImageBuilder extends Construct implements IRunnerImageBuilder {
+    readonly props: CodeBuildImageBuilderProps;
+    /**
+     * Bump this number every time the buildspec or any important setting of the project changes. It will force a rebuild of the image.
+     * @private
+     */
+    private static BUILDSPEC_VERSION;
+    private readonly architecture;
+    private readonly os;
+    private readonly repository;
+    private readonly dockerfile;
+    private preBuild;
+    private postBuild;
+    private buildArgs;
+    private policyStatements;
+    private secondaryAssets;
+    private readonly buildImage;
+    private boundImage?;
+    constructor(scope: Construct, id: string, props: CodeBuildImageBuilderProps);
+    /**
+     * Uploads a folder to the build server at a given folder name.
+     *
+     * @param sourcePath path to source directory
+     * @param destName name of destination folder
+     */
+    addFiles(sourcePath: string, destName: string): void;
+    /**
+     * Adds a command that runs before `docker build`.
+     *
+     * @param command command to add
+     */
+    addPreBuildCommand(command: string): void;
+    /**
+     * Adds a command that runs after `docker build` and `docker push`.
+     *
+     * @param command command to add
+     */
+    addPostBuildCommand(command: string): void;
+    /**
+     * Adds a build argument for Docker. See the documentation for the Dockerfile you're using for a list of supported build arguments.
+     *
+     * @param name build argument name
+     * @param value build argument value
+     */
+    setBuildArg(name: string, value: string): void;
+    /**
+     * Add a policy statement to the builder to access resources required to the image build.
+     *
+     * @param statement IAM policy statement
+     */
+    addPolicyStatement(statement: iam.PolicyStatement): void;
+    /**
+     * Add extra trusted certificates. This helps deal with self-signed certificates for GitHub Enterprise Server.
+     *
+     * All first party Dockerfiles support this. Others may not.
+     *
+     * @param path path to directory containing a file called certs.pem containing all the required certificates
+     */
+    addExtraCertificates(path: string): void;
+    /**
+     * Called by IRunnerProvider to finalize settings and create the image builder.
+     */
+    bindDockerImage(): RunnerImage;
+    private getBuildImage;
+    private getBuildSpec;
+    private customResource;
+    /**
+     * Return hash of all settings that can affect the result image so we can trigger the build when it changes.
+     * @private
+     */
+    private hashBuildSettings;
+    private rebuildImageOnSchedule;
+    get connections(): ec2.Connections;
+    bindAmi(): RunnerAmi;
+}