@cloudsnorkel/cdk-github-runners 0.5.7 → 0.6.0

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

@@ -0,0 +1,156 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinuxUbuntuComponents = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const common_1 = require("../common");
+const common_2 = require("./common");
+/**
+ * Components for Ubuntu Linux that can be used with AWS Image Builder based builders. These cannot be used by {@link CodeBuildImageBuilder}.
+ */
+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 common_2.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 common_2.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',
+            ],
+        });
+    }
+    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 common_2.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 common_2.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 common_2.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 common_2.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',
+            ],
+        });
+    }
+    static docker(scope, id, _architecture) {
+        return new common_2.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',
+            ],
+        });
+    }
+}
+exports.LinuxUbuntuComponents = LinuxUbuntuComponents;
+_a = JSII_RTTI_SYMBOL_1;
+LinuxUbuntuComponents[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.LinuxUbuntuComponents", version: "0.6.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"linux-components.js","sourceRoot":"","sources":["../../../src/providers/image-builders/linux-components.ts"],"names":[],"mappings":";;;;;AACA,sCAAwD;AACxD,qCAAiD;AAEjD;;GAEG;AACH,MAAa,qBAAqB;IACzB,MAAM,CAAC,gBAAgB,CAAC,KAAgB,EAAE,EAAU,EAAE,YAA0B;QACrF,IAAI,OAAO,CAAC;QACZ,IAAI,YAAY,CAAC,EAAE,CAAC,qBAAY,CAAC,MAAM,CAAC,EAAE;YACxC,OAAO,GAAG,OAAO,CAAC;SACnB;aAAM,IAAI,YAAY,CAAC,EAAE,CAAC,qBAAY,CAAC,KAAK,CAAC,EAAE;YAC9C,OAAO,GAAG,OAAO,CAAC;SACnB;aAAM;YACL,MAAM,IAAI,KAAK,CAAC,mDAAmD,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC;SACzF;QAED,OAAO,IAAI,8BAAqB,CAAC,KAAK,EAAE,EAAE,EAAE;YAC1C,QAAQ,EAAE,OAAO;YACjB,WAAW,EAAE,mBAAmB;YAChC,WAAW,EAAE,sEAAsE;YACnF,QAAQ,EAAE;gBACR,SAAS;gBACT,gBAAgB;gBAChB,mDAAmD;gBACnD,mIAAmI;gBACnI,sGAAsG,OAAO,qCAAqC;gBAClJ,6CAA6C;gBAC7C,qCAAqC;aACtC;SACF,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,UAAU,CAAC,KAAgB,EAAE,EAAU,EAAE,aAA2B;QAChF,OAAO,IAAI,8BAAqB,CAAC,KAAK,EAAE,EAAE,EAAE;YAC1C,QAAQ,EAAE,OAAO;YACjB,WAAW,EAAE,oBAAoB;YACjC,WAAW,EAAE,mCAAmC;YAChD,QAAQ,EAAE;gBACR,SAAS;gBACT,iBAAiB;gBACjB,kFAAkF;aACnF;SACF,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,MAAM,CAAC,KAAgB,EAAE,EAAU,EAAE,YAA0B;QAC3E,IAAI,OAAO,CAAC;QACZ,IAAI,YAAY,CAAC,EAAE,CAAC,qBAAY,CAAC,MAAM,CAAC,EAAE;YACxC,OAAO,GAAG,QAAQ,CAAC;SACpB;aAAM,IAAI,YAAY,CAAC,EAAE,CAAC,qBAAY,CAAC,KAAK,CAAC,EAAE;YAC9C,OAAO,GAAG,SAAS,CAAC;SACrB;aAAM;YACL,MAAM,IAAI,KAAK,CAAC,wCAAwC,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC;SAC9E;QAED,OAAO,IAAI,8BAAqB,CAAC,KAAK,EAAE,EAAE,EAAE;YAC1C,QAAQ,EAAE,OAAO;YACjB,WAAW,EAAE,SAAS;YACtB,WAAW,EAAE,mCAAmC;YAChD,QAAQ,EAAE;gBACR,SAAS;gBACT,6DAA6D,OAAO,uBAAuB;gBAC3F,uBAAuB;gBACvB,eAAe;gBACf,yBAAyB;aAC1B;SACF,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,SAAS,CAAC,KAAgB,EAAE,EAAU,EAAE,aAA2B;QAC/E,OAAO,IAAI,8BAAqB,CAAC,KAAK,EAAE,EAAE,EAAE;YAC1C,QAAQ,EAAE,OAAO;YACjB,WAAW,EAAE,YAAY;YACzB,WAAW,EAAE,8BAA8B;YAC3C,QAAQ,EAAE;gBACR,SAAS;gBACT,yIAAyI;gBACzI,4GAA4G;oBAC5G,+GAA+G;gBAC/G,gBAAgB;gBAChB,sDAAsD;aACvD;SACF,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,GAAG,CAAC,KAAgB,EAAE,EAAU,EAAE,aAA2B;QACzE,OAAO,IAAI,8BAAqB,CAAC,KAAK,EAAE,EAAE,EAAE;YAC1C,QAAQ,EAAE,OAAO;YACjB,WAAW,EAAE,KAAK;YAClB,WAAW,EAAE,+BAA+B;YAC5C,QAAQ,EAAE;gBACR,SAAS;gBACT,qCAAqC;gBACrC,gBAAgB;gBAChB,uDAAuD;aACxD;SACF,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,YAAY,CAAC,KAAgB,EAAE,EAAU,EAAE,aAA4B,EAAE,YAA0B;QAC/G,IAAI,cAAsB,CAAC;QAC3B,IAAI,aAAa,CAAC,EAAE,CAAC,sBAAa,CAAC,MAAM,EAAE,CAAC,EAAE;YAC5C,cAAc,GAAG,wHAAwH,CAAC;SAC3I;aAAM;YACL,cAAc,GAAG,mBAAmB,aAAa,CAAC,OAAO,GAAG,CAAC;SAC9D;QAED,IAAI,OAAO,CAAC;QACZ,IAAI,YAAY,CAAC,EAAE,CAAC,qBAAY,CAAC,MAAM,CAAC,EAAE;YACxC,OAAO,GAAG,KAAK,CAAC;SACjB;aAAM,IAAI,YAAY,CAAC,EAAE,CAAC,qBAAY,CAAC,KAAK,CAAC,EAAE;YAC9C,OAAO,GAAG,OAAO,CAAC;SACnB;aAAM;YACL,MAAM,IAAI,KAAK,CAAC,+CAA+C,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC;SACrF;QAED,OAAO,IAAI,8BAAqB,CAAC,KAAK,EAAE,EAAE,EAAE;YAC1C,QAAQ,EAAE,OAAO;YACjB,WAAW,EAAE,uBAAuB;YACpC,WAAW,EAAE,iDAAiD;YAC9D,QAAQ,EAAE;gBACR,SAAS;gBACT,cAAc;gBACd,6GAA6G,OAAO,6BAA6B;gBACjJ,iCAAiC,OAAO,6BAA6B;gBACrE,2BAA2B,OAAO,4BAA4B;gBAC9D,8BAA8B;aAC/B;SACF,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,MAAM,CAAC,KAAgB,EAAE,EAAU,EAAE,aAA2B;QAC5E,OAAO,IAAI,8BAAqB,CAAC,KAAK,EAAE,EAAE,EAAE;YAC1C,QAAQ,EAAE,OAAO;YACjB,WAAW,EAAE,QAAQ;YACrB,WAAW,EAAE,kCAAkC;YAC/C,QAAQ,EAAE;gBACR,SAAS;gBACT,gHAAgH;gBAChH,OAAO;oBACP,+HAA+H;oBAC/H,yFAAyF;gBACzF,gBAAgB;gBAChB,+GAA+G;gBAC/G,2BAA2B;gBAC3B,8EAA8E;aAC/E;SACF,CAAC,CAAC;IACL,CAAC;;AA/IH,sDAgJC","sourcesContent":["import { Construct } from 'constructs';\nimport { Architecture, RunnerVersion } from '../common';\nimport { ImageBuilderComponent } from './common';\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 */\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      ],\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      ],\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"]}

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

@@ -26,6 +26,7 @@ class StaticRunnerImage {
                     imageTag: tag,
                     architecture,
                     os,
+                    runnerVersion: common_1.RunnerVersion.latest(),
                 };
             },
         };
@@ -53,5 +54,5 @@ class StaticRunnerImage {
 }
 exports.StaticRunnerImage = StaticRunnerImage;
 _a = JSII_RTTI_SYMBOL_1;
-StaticRunnerImage[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.StaticRunnerImage", version: "0.5.7" };
-//# sourceMappingURL=data:application/json;base64,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
+StaticRunnerImage[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.StaticRunnerImage", version: "0.6.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/providers/image-builders/windows-components.d.ts

@@ -0,0 +1,14 @@
+import { Construct } from 'constructs';
+import { RunnerVersion } from '../common';
+import { ImageBuilderComponent } from './common';
+/**
+ * Components for Windows that can be used with AWS Image Builder based builders. These cannot be used by {@link CodeBuildImageBuilder}.
+ */
+export declare class WindowsComponents {
+    static cloudwatchAgent(scope: Construct, id: string): ImageBuilderComponent;
+    static awsCli(scope: Construct, id: string): ImageBuilderComponent;
+    static githubCli(scope: Construct, id: string): ImageBuilderComponent;
+    static git(scope: Construct, id: string): ImageBuilderComponent;
+    static githubRunner(scope: Construct, id: string, runnerVersion: RunnerVersion): ImageBuilderComponent;
+    static docker(scope: Construct, id: string): ImageBuilderComponent;
+}

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

@@ -0,0 +1,119 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowsComponents = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const common_1 = require("../common");
+const common_2 = require("./common");
+/**
+ * Components for Windows that can be used with AWS Image Builder based builders. These cannot be used by {@link CodeBuildImageBuilder}.
+ */
+class WindowsComponents {
+    static cloudwatchAgent(scope, id) {
+        return new common_2.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 common_2.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 common_2.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 common_2.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]',
+                '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 common_2.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',
+            ]),
+        });
+    }
+    static docker(scope, id) {
+        return new common_2.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',
+            ],
+        });
+    }
+}
+exports.WindowsComponents = WindowsComponents;
+_a = JSII_RTTI_SYMBOL_1;
+WindowsComponents[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.WindowsComponents", version: "0.6.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"windows-components.js","sourceRoot":"","sources":["../../../src/providers/image-builders/windows-components.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from 'constructs';\nimport { RunnerVersion } from '../common';\nimport { ImageBuilderComponent } from './common';\n\n/**\n * Components for Windows that can be used with AWS Image Builder based builders. These cannot be used by {@link CodeBuildImageBuilder}.\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        '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      ]),\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"]}

package/lib/providers/lambda.d.ts

@@ -1,7 +1,7 @@
 import * as cdk from 'aws-cdk-lib';
 import { aws_ec2 as ec2, aws_iam as iam, aws_lambda as lambda, aws_stepfunctions as stepfunctions } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
-import { BaseProvider, IImageBuilder, IRunnerProvider, RunnerImage, RunnerProviderProps, RunnerRuntimeParameters } from './common';
+import { BaseProvider, IImageBuilder, IRunnerProvider, IRunnerProviderStatus, RunnerImage, RunnerProviderProps, RunnerRuntimeParameters } from './common';
 export interface LambdaRunnerProps extends RunnerProviderProps {
     /**
      * Provider running an image to run inside CodeBuild with GitHub runner pre-configured.
@@ -72,7 +72,7 @@ export interface LambdaRunnerProps extends RunnerProviderProps {
     readonly subnetSelection?: ec2.SubnetSelection;
 }
 /**
- * GitHub Actions runner provider using Lambda to execute the actions.
+ * GitHub Actions runner provider using Lambda to execute jobs.
  *
  * Creates a Docker-based function that gets executed for each job.
  *
@@ -116,7 +116,7 @@ export declare class LambdaRunner extends BaseProvider implements IRunnerProvide
      */
     readonly grantPrincipal: iam.IPrincipal;
     /**
-     * Docker image used to start Lambda function.
+     * Docker image loaded with GitHub Actions Runner and its prerequisites. The image is built by an image builder and is specific to Lambda.
      */
     readonly image: RunnerImage;
     constructor(scope: Construct, id: string, props: LambdaRunnerProps);
@@ -133,5 +133,7 @@ export declare class LambdaRunner extends BaseProvider implements IRunnerProvide
      */
     getStepFunctionTask(parameters: RunnerRuntimeParameters): stepfunctions.IChainable;
     private addImageUpdater;
+    grantStateMachine(_: iam.IGrantable): void;
+    status(statusFunctionRole: iam.IGrantable): IRunnerProviderStatus;
     private imageDigest;
 }

package/lib/providers/lambda.js

@@ -11,7 +11,7 @@ const utils_1 = require("../utils");
 const common_1 = require("./common");
 const codebuild_1 = require("./image-builders/codebuild");
 /**
- * GitHub Actions runner provider using Lambda to execute the actions.
+ * GitHub Actions runner provider using Lambda to execute jobs.
  *
  * Creates a Docker-based function that gets executed for each job.
  *
@@ -131,6 +131,23 @@ class LambdaRunner extends common_1.BaseProvider {
         // the event never triggers without this - not sure why
         rule.node.defaultChild.addDeletionOverride('Properties.EventPattern.resources');
     }
+    grantStateMachine(_) {
+    }
+    status(statusFunctionRole) {
+        this.image.imageRepository.grant(statusFunctionRole, 'ecr:DescribeImages');
+        return {
+            type: this.constructor.name,
+            labels: this.labels,
+            vpcArn: this.vpc?.vpcArn,
+            securityGroup: this.securityGroup?.securityGroupId,
+            roleArn: this.function.role?.roleArn,
+            image: {
+                imageRepository: this.image.imageRepository.repositoryUri,
+                imageTag: this.image.imageTag,
+                imageBuilderLogGroup: this.image.logGroup?.logGroupName,
+            },
+        };
+    }
     imageDigest(image, variableSettings) {
         // describe ECR image to get its digest
         // the physical id is random so the resource always runs and always gets the latest digest, even if a scheduled build replaced the stack image
@@ -189,7 +206,7 @@ class LambdaRunner extends common_1.BaseProvider {
 }
 exports.LambdaRunner = LambdaRunner;
 _a = JSII_RTTI_SYMBOL_1;
-LambdaRunner[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.LambdaRunner", version: "0.5.7" };
+LambdaRunner[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.LambdaRunner", version: "0.6.0" };
 /**
  * Path to Dockerfile for Linux x64 with all the requirement for Lambda runner. Use this Dockerfile unless you need to customize it further than allowed by hooks.
  *
@@ -206,4 +223,4 @@ LambdaRunner.LINUX_X64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images', '
  * * `EXTRA_PACKAGES` can be used to install additional packages.
  */
 LambdaRunner.LINUX_ARM64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images', 'lambda', 'linux-arm64');
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambda.js","sourceRoot":"","sources":["../../src/providers/lambda.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as cdk from 'aws-cdk-lib';\nimport {\n  aws_ec2 as ec2,\n  aws_events as events,\n  aws_events_targets as events_targets,\n  aws_iam as iam,\n  aws_lambda as lambda,\n  aws_stepfunctions as stepfunctions,\n  aws_stepfunctions_tasks as stepfunctions_tasks,\n  custom_resources as cr,\n} from 'aws-cdk-lib';\nimport { RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport { Construct } from 'constructs';\nimport { BundledNodejsFunction } from '../utils';\nimport { Architecture, BaseProvider, IImageBuilder, IRunnerProvider, Os, RunnerImage, RunnerProviderProps, RunnerRuntimeParameters } from './common';\nimport { CodeBuildImageBuilder } from './image-builders/codebuild';\n\nexport interface LambdaRunnerProps extends RunnerProviderProps {\n  /**\n   * Provider running an image to run inside CodeBuild with GitHub runner pre-configured.\n   *\n   * The default command (`CMD`) should be `[\"runner.handler\"]` which points to an included `runner.js` with a function named `handler`. The function should start the GitHub runner.\n   *\n   * @see https://github.com/CloudSnorkel/cdk-github-runners/tree/main/src/providers/docker-images/lambda\n   * @default image builder with LambdaRunner.LINUX_X64_DOCKERFILE_PATH as Dockerfile\n   */\n  readonly imageBuilder?: IImageBuilder;\n\n  /**\n   * GitHub Actions label used for this provider.\n   *\n   * @default undefined\n   * @deprecated use {@link labels} instead\n   */\n  readonly label?: string;\n\n  /**\n   * GitHub Actions labels used for this provider.\n   *\n   * These labels are used to identify which provider should spawn a new on-demand runner. Every job sends a webhook with the labels it's looking for\n   * based on runs-on. We match the labels from the webhook with the labels specified here. If all the labels specified here are present in the\n   * job's labels, this provider will be chosen and spawn a new runner.\n   *\n   * @default ['lambda']\n   */\n  readonly labels?: string[];\n\n  /**\n   * The amount of memory, in MB, that is allocated to your Lambda function.\n   * Lambda uses this value to proportionally allocate the amount of CPU\n   * power. For more information, see Resource Model in the AWS Lambda\n   * Developer Guide.\n   *\n   * @default 2048\n   */\n  readonly memorySize?: number;\n\n  /**\n  * The size of the function’s /tmp directory in MiB.\n  *\n  * @default 10 GiB\n  */\n  readonly ephemeralStorageSize?: cdk.Size;\n\n  /**\n   * The function execution time (in seconds) after which Lambda terminates\n   * the function. Because the execution time affects cost, set this value\n   * based on the function's expected execution time.\n   *\n   * @default Duration.minutes(15)\n   */\n  readonly timeout?: cdk.Duration;\n\n  /**\n  * VPC to launch the runners in.\n  *\n  * @default no VPC\n  */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n  * Security Group to assign to this instance.\n  *\n  * @default public lambda with no security group\n  */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n  * Where to place the network interfaces within the VPC.\n  *\n  * @default no subnet\n  */\n  readonly subnetSelection?: ec2.SubnetSelection;\n}\n\n/**\n * GitHub Actions runner provider using Lambda to execute the actions.\n *\n * Creates a Docker-based function that gets executed for each job.\n *\n * This construct is not meant to be used by itself. It should be passed in the providers property for GitHubRunners.\n */\nexport class LambdaRunner extends BaseProvider implements IRunnerProvider {\n  /**\n   * Path to Dockerfile for Linux x64 with all the requirement for Lambda runner. Use this Dockerfile unless you need to customize it further than allowed by hooks.\n   *\n   * Available build arguments that can be set in the image builder:\n   * * `BASE_IMAGE` sets the `FROM` line. This should be similar to public.ecr.aws/lambda/nodejs:14.\n   * * `EXTRA_PACKAGES` can be used to install additional packages.\n   */\n  public static readonly LINUX_X64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images', 'lambda', 'linux-x64');\n\n  /**\n   * Path to Dockerfile for Linux ARM64 with all the requirement for Lambda runner. Use this Dockerfile unless you need to customize it further than allowed by hooks.\n   *\n   * Available build arguments that can be set in the image builder:\n   * * `BASE_IMAGE` sets the `FROM` line. This should be similar to public.ecr.aws/lambda/nodejs:14.\n   * * `EXTRA_PACKAGES` can be used to install additional packages.\n   */\n  public static readonly LINUX_ARM64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images', 'lambda', 'linux-arm64');\n\n  /**\n   * The function hosting the GitHub runner.\n   */\n  readonly function: lambda.Function;\n\n  /**\n   * Labels associated with this provider.\n   */\n  readonly labels: string[];\n\n  /**\n   * VPC used for hosting the function.\n   */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Security group attached to the function.\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Grant principal used to add permissions to the runner role.\n   */\n  readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * Docker image used to start Lambda function.\n   */\n  readonly image: RunnerImage;\n\n  constructor(scope: Construct, id: string, props: LambdaRunnerProps) {\n    super(scope, id);\n\n    this.labels = this.labelsFromProperties('lambda', props.label, props.labels);\n    this.vpc = props.vpc;\n    this.securityGroup = props.securityGroup;\n\n    const imageBuilder = props.imageBuilder ?? new CodeBuildImageBuilder(this, 'Image Builder', {\n      dockerfilePath: LambdaRunner.LINUX_X64_DOCKERFILE_PATH,\n    });\n    const image = this.image = imageBuilder.bind();\n\n    let architecture: lambda.Architecture | undefined;\n    if (image.os.is(Os.LINUX)) {\n      if (image.architecture.is(Architecture.X86_64)) {\n        architecture = lambda.Architecture.X86_64;\n      }\n      if (image.architecture.is(Architecture.ARM64)) {\n        architecture = lambda.Architecture.ARM_64;\n      }\n    }\n\n    if (!architecture) {\n      throw new Error(`Unable to find support Lambda architecture for ${image.os.name}/${image.architecture.name}`);\n    }\n\n    // get image digest and make sure to get it every time the lambda function might be updated\n    // pass all variables that may change and cause a function update\n    // if we don't get the latest digest, the update may fail as a new image was already built outside the stack on a schedule\n    // we automatically delete old images, so we must always get the latest digest\n    const imageDigest = this.imageDigest(image, {\n      version: 1, // bump this for any non-user changes like description or defaults\n      labels: this.labels,\n      architecture: architecture.name,\n      vpc: this.vpc?.vpcId,\n      securityGroups: this.securityGroup?.securityGroupId,\n      vpcSubnets: props.subnetSelection?.subnets?.map(s => s.subnetId),\n      timeout: props.timeout?.toSeconds(),\n      memorySize: props.memorySize,\n      ephemeralStorageSize: props.ephemeralStorageSize?.toKibibytes(),\n      logRetention: props.logRetention?.toFixed(),\n    });\n\n    this.function = new lambda.DockerImageFunction(\n      this,\n      'Function',\n      {\n        description: `GitHub Actions runner for labels ${this.labels}`,\n        // CDK requires \"sha256:\" literal prefix -- https://github.com/aws/aws-cdk/blob/ba91ca45ad759ab5db6da17a62333e2bc11e1075/packages/%40aws-cdk/aws-ecr/lib/repository.ts#L184\n        code: lambda.DockerImageCode.fromEcr(image.imageRepository, { tagOrDigest: `sha256:${imageDigest}` }),\n        architecture,\n        vpc: this.vpc,\n        securityGroups: this.securityGroup && [this.securityGroup],\n        vpcSubnets: props.subnetSelection,\n        timeout: props.timeout || cdk.Duration.minutes(15),\n        memorySize: props.memorySize || 2048,\n        ephemeralStorageSize: props.ephemeralStorageSize || cdk.Size.gibibytes(10),\n        logRetention: props.logRetention || RetentionDays.ONE_MONTH,\n      },\n    );\n\n    this.grantPrincipal = this.function.grantPrincipal;\n\n    this.addImageUpdater(image);\n  }\n\n  /**\n   * The network connections associated with this resource.\n   */\n  public get connections(): ec2.Connections {\n    return this.function.connections;\n  }\n\n  /**\n   * Generate step function task(s) to start a new runner.\n   *\n   * Called by GithubRunners and shouldn't be called manually.\n   *\n   * @param parameters workflow job details\n   */\n  getStepFunctionTask(parameters: RunnerRuntimeParameters): stepfunctions.IChainable {\n    return new stepfunctions_tasks.LambdaInvoke(\n      this,\n      this.labels.join(', '),\n      {\n        lambdaFunction: this.function,\n        payload: stepfunctions.TaskInput.fromObject({\n          token: parameters.runnerTokenPath,\n          runnerName: parameters.runnerNamePath,\n          label: this.labels.join(','),\n          githubDomain: parameters.githubDomainPath,\n          owner: parameters.ownerPath,\n          repo: parameters.repoPath,\n        }),\n      },\n    );\n  }\n\n  private addImageUpdater(image: RunnerImage) {\n    // Lambda needs to be pointing to a specific image digest and not just a tag.\n    // Whenever we update the tag to a new digest, we need to update the lambda.\n\n    const updater = BundledNodejsFunction.singleton(this, 'update-lambda', {\n      description: 'Function that updates a GitHub Actions runner function with the latest image digest after the image has been rebuilt',\n      timeout: cdk.Duration.minutes(15),\n    });\n\n    updater.addToRolePolicy(new iam.PolicyStatement({\n      actions: ['lambda:UpdateFunctionCode'],\n      resources: [this.function.functionArn],\n    }));\n\n    let lambdaTarget = new events_targets.LambdaFunction(updater, {\n      event: events.RuleTargetInput.fromObject({\n        lambdaName: this.function.functionName,\n        repositoryUri: image.imageRepository.repositoryUri,\n        repositoryTag: image.imageTag,\n      }),\n    });\n\n    const rule = image.imageRepository.onEvent('Push rule', {\n      description: 'Update GitHub Actions runner Lambda on ECR image push',\n      eventPattern: {\n        detailType: ['ECR Image Action'],\n        detail: {\n          'action-type': ['PUSH'],\n          'repository-name': [image.imageRepository.repositoryName],\n          'image-tag': [image.imageTag],\n          'result': ['SUCCESS'],\n        },\n      },\n      target: lambdaTarget,\n    });\n\n    // the event never triggers without this - not sure why\n    (rule.node.defaultChild as events.CfnRule).addDeletionOverride('Properties.EventPattern.resources');\n  }\n\n  private imageDigest(image: RunnerImage, variableSettings: any): string {\n    // describe ECR image to get its digest\n    // the physical id is random so the resource always runs and always gets the latest digest, even if a scheduled build replaced the stack image\n    const reader = new cr.AwsCustomResource(this, 'Image Digest Reader', {\n      onCreate: {\n        service: 'ECR',\n        action: 'describeImages',\n        parameters: {\n          repositoryName: image.imageRepository.repositoryName,\n          imageIds: [\n            {\n              imageTag: image.imageTag,\n            },\n          ],\n        },\n        physicalResourceId: cr.PhysicalResourceId.of('ImageDigest'),\n      },\n      onUpdate: {\n        service: 'ECR',\n        action: 'describeImages',\n        parameters: {\n          repositoryName: image.imageRepository.repositoryName,\n          imageIds: [\n            {\n              imageTag: image.imageTag,\n            },\n          ],\n        },\n        physicalResourceId: cr.PhysicalResourceId.of('ImageDigest'),\n      },\n      onDelete: {\n        // this will NOT be called thanks to RemovalPolicy.RETAIN below\n        // we only use this to force the custom resource to be called again and get a new digest\n        service: 'fake',\n        action: 'fake',\n        parameters: variableSettings,\n      },\n      policy: cr.AwsCustomResourcePolicy.fromSdkCalls({\n        resources: [image.imageRepository.repositoryArn],\n      }),\n      resourceType: 'Custom::EcrImageDigest',\n      installLatestAwsSdk: false, // no need and it takes 60 seconds\n      logRetention: RetentionDays.ONE_MONTH,\n    });\n\n    const res = reader.node.tryFindChild('Resource') as cdk.CustomResource | undefined;\n    if (res) {\n      // don't actually call the fake onDelete above\n      res.applyRemovalPolicy(cdk.RemovalPolicy.RETAIN);\n    } else {\n      throw new Error('Resource not found in AwsCustomResource. Report this bug at https://github.com/CloudSnorkel/cdk-github-runners/issues.');\n    }\n\n    // return only the digest because CDK expects 'sha256:' literal above\n    return cdk.Fn.split(':', reader.getResponseField('imageDetails.0.imageDigest'), 2)[1];\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambda.js","sourceRoot":"","sources":["../../src/providers/lambda.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as cdk from 'aws-cdk-lib';\nimport {\n  aws_ec2 as ec2,\n  aws_events as events,\n  aws_events_targets as events_targets,\n  aws_iam as iam,\n  aws_lambda as lambda,\n  aws_stepfunctions as stepfunctions,\n  aws_stepfunctions_tasks as stepfunctions_tasks,\n  custom_resources as cr,\n} from 'aws-cdk-lib';\nimport { RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport { Construct } from 'constructs';\nimport { BundledNodejsFunction } from '../utils';\nimport {\n  Architecture,\n  BaseProvider,\n  IImageBuilder,\n  IRunnerProvider,\n  IRunnerProviderStatus,\n  Os,\n  RunnerImage,\n  RunnerProviderProps,\n  RunnerRuntimeParameters,\n} from './common';\nimport { CodeBuildImageBuilder } from './image-builders/codebuild';\n\nexport interface LambdaRunnerProps extends RunnerProviderProps {\n  /**\n   * Provider running an image to run inside CodeBuild with GitHub runner pre-configured.\n   *\n   * The default command (`CMD`) should be `[\"runner.handler\"]` which points to an included `runner.js` with a function named `handler`. The function should start the GitHub runner.\n   *\n   * @see https://github.com/CloudSnorkel/cdk-github-runners/tree/main/src/providers/docker-images/lambda\n   * @default image builder with LambdaRunner.LINUX_X64_DOCKERFILE_PATH as Dockerfile\n   */\n  readonly imageBuilder?: IImageBuilder;\n\n  /**\n   * GitHub Actions label used for this provider.\n   *\n   * @default undefined\n   * @deprecated use {@link labels} instead\n   */\n  readonly label?: string;\n\n  /**\n   * GitHub Actions labels used for this provider.\n   *\n   * These labels are used to identify which provider should spawn a new on-demand runner. Every job sends a webhook with the labels it's looking for\n   * based on runs-on. We match the labels from the webhook with the labels specified here. If all the labels specified here are present in the\n   * job's labels, this provider will be chosen and spawn a new runner.\n   *\n   * @default ['lambda']\n   */\n  readonly labels?: string[];\n\n  /**\n   * The amount of memory, in MB, that is allocated to your Lambda function.\n   * Lambda uses this value to proportionally allocate the amount of CPU\n   * power. For more information, see Resource Model in the AWS Lambda\n   * Developer Guide.\n   *\n   * @default 2048\n   */\n  readonly memorySize?: number;\n\n  /**\n  * The size of the function’s /tmp directory in MiB.\n  *\n  * @default 10 GiB\n  */\n  readonly ephemeralStorageSize?: cdk.Size;\n\n  /**\n   * The function execution time (in seconds) after which Lambda terminates\n   * the function. Because the execution time affects cost, set this value\n   * based on the function's expected execution time.\n   *\n   * @default Duration.minutes(15)\n   */\n  readonly timeout?: cdk.Duration;\n\n  /**\n  * VPC to launch the runners in.\n  *\n  * @default no VPC\n  */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n  * Security Group to assign to this instance.\n  *\n  * @default public lambda with no security group\n  */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n  * Where to place the network interfaces within the VPC.\n  *\n  * @default no subnet\n  */\n  readonly subnetSelection?: ec2.SubnetSelection;\n}\n\n/**\n * GitHub Actions runner provider using Lambda to execute jobs.\n *\n * Creates a Docker-based function that gets executed for each job.\n *\n * This construct is not meant to be used by itself. It should be passed in the providers property for GitHubRunners.\n */\nexport class LambdaRunner extends BaseProvider implements IRunnerProvider {\n  /**\n   * Path to Dockerfile for Linux x64 with all the requirement for Lambda runner. Use this Dockerfile unless you need to customize it further than allowed by hooks.\n   *\n   * Available build arguments that can be set in the image builder:\n   * * `BASE_IMAGE` sets the `FROM` line. This should be similar to public.ecr.aws/lambda/nodejs:14.\n   * * `EXTRA_PACKAGES` can be used to install additional packages.\n   */\n  public static readonly LINUX_X64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images', 'lambda', 'linux-x64');\n\n  /**\n   * Path to Dockerfile for Linux ARM64 with all the requirement for Lambda runner. Use this Dockerfile unless you need to customize it further than allowed by hooks.\n   *\n   * Available build arguments that can be set in the image builder:\n   * * `BASE_IMAGE` sets the `FROM` line. This should be similar to public.ecr.aws/lambda/nodejs:14.\n   * * `EXTRA_PACKAGES` can be used to install additional packages.\n   */\n  public static readonly LINUX_ARM64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images', 'lambda', 'linux-arm64');\n\n  /**\n   * The function hosting the GitHub runner.\n   */\n  readonly function: lambda.Function;\n\n  /**\n   * Labels associated with this provider.\n   */\n  readonly labels: string[];\n\n  /**\n   * VPC used for hosting the function.\n   */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Security group attached to the function.\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Grant principal used to add permissions to the runner role.\n   */\n  readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * Docker image loaded with GitHub Actions Runner and its prerequisites. The image is built by an image builder and is specific to Lambda.\n   */\n  readonly image: RunnerImage;\n\n  constructor(scope: Construct, id: string, props: LambdaRunnerProps) {\n    super(scope, id);\n\n    this.labels = this.labelsFromProperties('lambda', props.label, props.labels);\n    this.vpc = props.vpc;\n    this.securityGroup = props.securityGroup;\n\n    const imageBuilder = props.imageBuilder ?? new CodeBuildImageBuilder(this, 'Image Builder', {\n      dockerfilePath: LambdaRunner.LINUX_X64_DOCKERFILE_PATH,\n    });\n    const image = this.image = imageBuilder.bind();\n\n    let architecture: lambda.Architecture | undefined;\n    if (image.os.is(Os.LINUX)) {\n      if (image.architecture.is(Architecture.X86_64)) {\n        architecture = lambda.Architecture.X86_64;\n      }\n      if (image.architecture.is(Architecture.ARM64)) {\n        architecture = lambda.Architecture.ARM_64;\n      }\n    }\n\n    if (!architecture) {\n      throw new Error(`Unable to find support Lambda architecture for ${image.os.name}/${image.architecture.name}`);\n    }\n\n    // get image digest and make sure to get it every time the lambda function might be updated\n    // pass all variables that may change and cause a function update\n    // if we don't get the latest digest, the update may fail as a new image was already built outside the stack on a schedule\n    // we automatically delete old images, so we must always get the latest digest\n    const imageDigest = this.imageDigest(image, {\n      version: 1, // bump this for any non-user changes like description or defaults\n      labels: this.labels,\n      architecture: architecture.name,\n      vpc: this.vpc?.vpcId,\n      securityGroups: this.securityGroup?.securityGroupId,\n      vpcSubnets: props.subnetSelection?.subnets?.map(s => s.subnetId),\n      timeout: props.timeout?.toSeconds(),\n      memorySize: props.memorySize,\n      ephemeralStorageSize: props.ephemeralStorageSize?.toKibibytes(),\n      logRetention: props.logRetention?.toFixed(),\n    });\n\n    this.function = new lambda.DockerImageFunction(\n      this,\n      'Function',\n      {\n        description: `GitHub Actions runner for labels ${this.labels}`,\n        // CDK requires \"sha256:\" literal prefix -- https://github.com/aws/aws-cdk/blob/ba91ca45ad759ab5db6da17a62333e2bc11e1075/packages/%40aws-cdk/aws-ecr/lib/repository.ts#L184\n        code: lambda.DockerImageCode.fromEcr(image.imageRepository, { tagOrDigest: `sha256:${imageDigest}` }),\n        architecture,\n        vpc: this.vpc,\n        securityGroups: this.securityGroup && [this.securityGroup],\n        vpcSubnets: props.subnetSelection,\n        timeout: props.timeout || cdk.Duration.minutes(15),\n        memorySize: props.memorySize || 2048,\n        ephemeralStorageSize: props.ephemeralStorageSize || cdk.Size.gibibytes(10),\n        logRetention: props.logRetention || RetentionDays.ONE_MONTH,\n      },\n    );\n\n    this.grantPrincipal = this.function.grantPrincipal;\n\n    this.addImageUpdater(image);\n  }\n\n  /**\n   * The network connections associated with this resource.\n   */\n  public get connections(): ec2.Connections {\n    return this.function.connections;\n  }\n\n  /**\n   * Generate step function task(s) to start a new runner.\n   *\n   * Called by GithubRunners and shouldn't be called manually.\n   *\n   * @param parameters workflow job details\n   */\n  getStepFunctionTask(parameters: RunnerRuntimeParameters): stepfunctions.IChainable {\n    return new stepfunctions_tasks.LambdaInvoke(\n      this,\n      this.labels.join(', '),\n      {\n        lambdaFunction: this.function,\n        payload: stepfunctions.TaskInput.fromObject({\n          token: parameters.runnerTokenPath,\n          runnerName: parameters.runnerNamePath,\n          label: this.labels.join(','),\n          githubDomain: parameters.githubDomainPath,\n          owner: parameters.ownerPath,\n          repo: parameters.repoPath,\n        }),\n      },\n    );\n  }\n\n  private addImageUpdater(image: RunnerImage) {\n    // Lambda needs to be pointing to a specific image digest and not just a tag.\n    // Whenever we update the tag to a new digest, we need to update the lambda.\n\n    const updater = BundledNodejsFunction.singleton(this, 'update-lambda', {\n      description: 'Function that updates a GitHub Actions runner function with the latest image digest after the image has been rebuilt',\n      timeout: cdk.Duration.minutes(15),\n    });\n\n    updater.addToRolePolicy(new iam.PolicyStatement({\n      actions: ['lambda:UpdateFunctionCode'],\n      resources: [this.function.functionArn],\n    }));\n\n    let lambdaTarget = new events_targets.LambdaFunction(updater, {\n      event: events.RuleTargetInput.fromObject({\n        lambdaName: this.function.functionName,\n        repositoryUri: image.imageRepository.repositoryUri,\n        repositoryTag: image.imageTag,\n      }),\n    });\n\n    const rule = image.imageRepository.onEvent('Push rule', {\n      description: 'Update GitHub Actions runner Lambda on ECR image push',\n      eventPattern: {\n        detailType: ['ECR Image Action'],\n        detail: {\n          'action-type': ['PUSH'],\n          'repository-name': [image.imageRepository.repositoryName],\n          'image-tag': [image.imageTag],\n          'result': ['SUCCESS'],\n        },\n      },\n      target: lambdaTarget,\n    });\n\n    // the event never triggers without this - not sure why\n    (rule.node.defaultChild as events.CfnRule).addDeletionOverride('Properties.EventPattern.resources');\n  }\n\n  grantStateMachine(_: iam.IGrantable) {\n  }\n\n  status(statusFunctionRole: iam.IGrantable): IRunnerProviderStatus {\n    this.image.imageRepository.grant(statusFunctionRole, 'ecr:DescribeImages');\n\n    return {\n      type: this.constructor.name,\n      labels: this.labels,\n      vpcArn: this.vpc?.vpcArn,\n      securityGroup: this.securityGroup?.securityGroupId,\n      roleArn: this.function.role?.roleArn,\n      image: {\n        imageRepository: this.image.imageRepository.repositoryUri,\n        imageTag: this.image.imageTag,\n        imageBuilderLogGroup: this.image.logGroup?.logGroupName,\n      },\n    };\n  }\n\n  private imageDigest(image: RunnerImage, variableSettings: any): string {\n    // describe ECR image to get its digest\n    // the physical id is random so the resource always runs and always gets the latest digest, even if a scheduled build replaced the stack image\n    const reader = new cr.AwsCustomResource(this, 'Image Digest Reader', {\n      onCreate: {\n        service: 'ECR',\n        action: 'describeImages',\n        parameters: {\n          repositoryName: image.imageRepository.repositoryName,\n          imageIds: [\n            {\n              imageTag: image.imageTag,\n            },\n          ],\n        },\n        physicalResourceId: cr.PhysicalResourceId.of('ImageDigest'),\n      },\n      onUpdate: {\n        service: 'ECR',\n        action: 'describeImages',\n        parameters: {\n          repositoryName: image.imageRepository.repositoryName,\n          imageIds: [\n            {\n              imageTag: image.imageTag,\n            },\n          ],\n        },\n        physicalResourceId: cr.PhysicalResourceId.of('ImageDigest'),\n      },\n      onDelete: {\n        // this will NOT be called thanks to RemovalPolicy.RETAIN below\n        // we only use this to force the custom resource to be called again and get a new digest\n        service: 'fake',\n        action: 'fake',\n        parameters: variableSettings,\n      },\n      policy: cr.AwsCustomResourcePolicy.fromSdkCalls({\n        resources: [image.imageRepository.repositoryArn],\n      }),\n      resourceType: 'Custom::EcrImageDigest',\n      installLatestAwsSdk: false, // no need and it takes 60 seconds\n      logRetention: RetentionDays.ONE_MONTH,\n    });\n\n    const res = reader.node.tryFindChild('Resource') as cdk.CustomResource | undefined;\n    if (res) {\n      // don't actually call the fake onDelete above\n      res.applyRemovalPolicy(cdk.RemovalPolicy.RETAIN);\n    } else {\n      throw new Error('Resource not found in AwsCustomResource. Report this bug at https://github.com/CloudSnorkel/cdk-github-runners/issues.');\n    }\n\n    // return only the digest because CDK expects 'sha256:' literal above\n    return cdk.Fn.split(':', reader.getResponseField('imageDetails.0.imageDigest'), 2)[1];\n  }\n}\n"]}