@cloudsnorkel/cdk-github-runners 0.8.0 → 0.8.2

package/lib/lambdas/status.lambda.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+const auth_app_1 = require("@octokit/auth-app");
+const core_1 = require("@octokit/core");
+const AWS = require("aws-sdk");
+const github_1 = require("./github");
+const helpers_1 = require("./helpers");
+const cfn = new AWS.CloudFormation();
+const ec2 = new AWS.EC2();
+const ecr = new AWS.ECR();
+const sf = new AWS.StepFunctions();
+function secretArnToUrl(arn) {
+    const parts = arn.split(':'); // arn:aws:secretsmanager:us-east-1:12345678:secret:secret-name-REVISION
+    const region = parts[3];
+    const fullName = parts[6];
+    const name = fullName.slice(0, fullName.lastIndexOf('-'));
+    return `https://${region}.console.aws.amazon.com/secretsmanager/home?region=${region}#!/secret?name=${name}`;
+}
+function lambdaArnToUrl(arn) {
+    const parts = arn.split(':'); // arn:aws:lambda:us-east-1:12345678:function:name-XYZ
+    const region = parts[3];
+    const name = parts[6];
+    return `https://${region}.console.aws.amazon.com/lambda/home?region=${region}#/functions/${name}?tab=monitoring`;
+}
+function stepFunctionArnToUrl(arn) {
+    const parts = arn.split(':'); // arn:aws:states:us-east-1:12345678:stateMachine:name-XYZ
+    const region = parts[3];
+    return `https://${region}.console.aws.amazon.com/states/home?region=${region}#/statemachines/view/${arn}`;
+}
+async function generateProvidersStatus(stack, logicalId) {
+    const resource = await cfn.describeStackResource({ StackName: stack, LogicalResourceId: logicalId }).promise();
+    const providers = JSON.parse(resource.StackResourceDetail?.Metadata ?? '{}').providers;
+    if (!providers) {
+        return {};
+    }
+    return Promise.all(providers.map(async (p) => {
+        // add ECR data, if image is from ECR
+        if (p.image?.imageRepository?.match(/[0-9]+\.dkr\.ecr\.[a-z0-9\-]+\.amazonaws\.com\/.+/)) {
+            const tags = await ecr.describeImages({
+                repositoryName: p.image.imageRepository.split('/')[1],
+                filter: {
+                    tagStatus: 'TAGGED',
+                },
+                maxResults: 1,
+            }).promise();
+            if (tags.imageDetails && tags.imageDetails?.length >= 1) {
+                p.image.latestImage = {
+                    tags: tags.imageDetails[0].imageTags,
+                    digest: tags.imageDetails[0].imageDigest,
+                    date: tags.imageDetails[0].imagePushedAt,
+                };
+            }
+        }
+        // add AMI data, if image is AMI
+        if (p.ami?.launchTemplate) {
+            const versions = await ec2.describeLaunchTemplateVersions({
+                LaunchTemplateId: p.ami.launchTemplate,
+                Versions: ['$Default'],
+            }).promise();
+            if (versions.LaunchTemplateVersions && versions.LaunchTemplateVersions.length >= 1) {
+                p.ami.latestAmi = versions.LaunchTemplateVersions[0].LaunchTemplateData?.ImageId;
+            }
+        }
+        return p;
+    }));
+}
+exports.handler = async function () {
+    // confirm required environment variables
+    if (!process.env.WEBHOOK_SECRET_ARN || !process.env.GITHUB_SECRET_ARN || !process.env.GITHUB_PRIVATE_KEY_SECRET_ARN || !process.env.LOGICAL_ID ||
+        !process.env.WEBHOOK_HANDLER_ARN || !process.env.STEP_FUNCTION_ARN || !process.env.SETUP_SECRET_ARN || !process.env.SETUP_FUNCTION_URL ||
+        !process.env.STACK_NAME) {
+        throw new Error('Missing environment variables');
+    }
+    // base status
+    const status = {
+        github: {
+            setup: {
+                status: 'Unknown',
+                url: '',
+                secretArn: process.env.SETUP_SECRET_ARN,
+                secretUrl: secretArnToUrl(process.env.SETUP_SECRET_ARN),
+            },
+            domain: 'Unknown',
+            webhook: {
+                url: process.env.WEBHOOK_URL,
+                status: 'Unable to check',
+                secretArn: process.env.WEBHOOK_SECRET_ARN,
+                secretUrl: secretArnToUrl(process.env.WEBHOOK_SECRET_ARN),
+            },
+            auth: {
+                type: 'Unknown',
+                status: 'Unknown',
+                secretArn: process.env.GITHUB_SECRET_ARN,
+                secretUrl: secretArnToUrl(process.env.GITHUB_SECRET_ARN),
+                privateKeySecretArn: process.env.GITHUB_PRIVATE_KEY_SECRET_ARN,
+                privateKeySecretUrl: secretArnToUrl(process.env.GITHUB_PRIVATE_KEY_SECRET_ARN),
+                app: {
+                    id: '',
+                    url: '',
+                    installations: [],
+                },
+                personalAuthToken: '',
+            },
+        },
+        providers: await generateProvidersStatus(process.env.STACK_NAME, process.env.LOGICAL_ID),
+        troubleshooting: {
+            webhookHandlerArn: process.env.WEBHOOK_HANDLER_ARN,
+            webhookHandlerUrl: lambdaArnToUrl(process.env.WEBHOOK_HANDLER_ARN),
+            stepFunctionArn: process.env.STEP_FUNCTION_ARN,
+            stepFunctionUrl: stepFunctionArnToUrl(process.env.STEP_FUNCTION_ARN),
+            stepFunctionLogGroup: process.env.STEP_FUNCTION_LOG_GROUP,
+            recentRuns: [],
+        },
+    };
+    // setup url
+    const setupToken = (await helpers_1.getSecretJsonValue(process.env.SETUP_SECRET_ARN)).token;
+    if (setupToken) {
+        status.github.setup.status = 'Pending';
+        status.github.setup.url = `${process.env.SETUP_FUNCTION_URL}?token=${setupToken}`;
+    }
+    else {
+        status.github.setup.status = 'Complete';
+    }
+    // list last 10 executions and their status
+    try {
+        const executions = await sf.listExecutions({
+            stateMachineArn: process.env.STEP_FUNCTION_ARN,
+            maxResults: 10,
+        }).promise();
+        for (const execution of executions.executions) {
+            const executionDetails = await sf.describeExecution({
+                executionArn: execution.executionArn,
+            }).promise();
+            const input = JSON.parse(executionDetails.input || '{}');
+            status.troubleshooting.recentRuns.push({
+                executionArn: execution.executionArn,
+                status: execution.status,
+                owner: input.owner,
+                repo: input.repo,
+                runId: input.runId,
+            });
+        }
+    }
+    catch (e) {
+        status.troubleshooting.recentRuns.push({ status: `Error getting executions: ${e}` });
+    }
+    // get secrets
+    let githubSecrets;
+    try {
+        githubSecrets = await helpers_1.getSecretJsonValue(process.env.GITHUB_SECRET_ARN);
+    }
+    catch (e) {
+        status.github.auth.status = `Unable to read secret: ${e}`;
+        return status;
+    }
+    let privateKey;
+    try {
+        privateKey = await helpers_1.getSecretValue(process.env.GITHUB_PRIVATE_KEY_SECRET_ARN);
+    }
+    catch (e) {
+        status.github.auth.status = `Unable to read private key secret: ${e}`;
+        return status;
+    }
+    // calculate base url
+    let baseUrl = github_1.baseUrlFromDomain(githubSecrets.domain);
+    status.github.domain = githubSecrets.domain;
+    if (githubSecrets.personalAuthToken) {
+        // try authenticating with personal authentication token
+        status.github.auth.type = 'Personal Auth Token';
+        status.github.auth.personalAuthToken = '*redacted*';
+        let octokit;
+        try {
+            octokit = new core_1.Octokit({ baseUrl, auth: githubSecrets.personalAuthToken });
+        }
+        catch (e) {
+            status.github.auth.status = `Unable to authenticate using personal auth token: ${e}`;
+            return status;
+        }
+        try {
+            const user = await octokit.request('GET /user');
+            status.github.auth.personalAuthToken = `username: ${user.data.login}`;
+        }
+        catch (e) {
+            status.github.auth.status = `Unable to call /user with personal auth token: ${e}`;
+            return status;
+        }
+        status.github.auth.status = 'OK';
+        status.github.webhook.status = 'Unable to verify automatically';
+    }
+    else {
+        // try authenticating with GitHub app
+        status.github.auth.type = 'GitHub App';
+        status.github.auth.app.id = githubSecrets.appId;
+        let appOctokit;
+        try {
+            appOctokit = new core_1.Octokit({
+                baseUrl,
+                authStrategy: auth_app_1.createAppAuth,
+                auth: {
+                    appId: githubSecrets.appId,
+                    privateKey: privateKey,
+                },
+            });
+        }
+        catch (e) {
+            status.github.auth.status = `Unable to authenticate app: ${e}`;
+            return status;
+        }
+        // get app url
+        try {
+            const app = (await appOctokit.request('GET /app')).data;
+            status.github.auth.app.url = app.html_url;
+        }
+        catch (e) {
+            status.github.auth.status = `Unable to get app details: ${e}`;
+            return status;
+        }
+        // list all app installations
+        try {
+            const installations = (await appOctokit.request('GET /app/installations')).data;
+            for (const installation of installations) {
+                let installationDetails = {
+                    id: installation.id,
+                    url: installation.html_url,
+                    status: 'Unable to query',
+                    repositories: [],
+                };
+                let token;
+                try {
+                    token = (await appOctokit.auth({
+                        type: 'installation',
+                        installationId: installation.id,
+                    })).token;
+                }
+                catch (e) {
+                    installationDetails.status = `Unable to authenticate app installation: ${e}`;
+                    continue;
+                }
+                let octokit;
+                try {
+                    octokit = new core_1.Octokit({ baseUrl, auth: token });
+                }
+                catch (e) {
+                    installationDetails.status = `Unable to authenticate using app: ${e}`;
+                    continue;
+                }
+                try {
+                    const repositories = (await octokit.request('GET /installation/repositories')).data.repositories;
+                    for (const repo of repositories) {
+                        installationDetails.repositories.push(repo.full_name);
+                    }
+                }
+                catch (e) {
+                    installationDetails.status = `Unable to authenticate using installation token: ${e}`;
+                    continue;
+                }
+                installationDetails.status = 'OK';
+                status.github.auth.app.installations.push(installationDetails);
+            }
+        }
+        catch (e) {
+            status.github.auth.status = 'Unable to list app installations';
+            return status;
+        }
+        status.github.auth.status = 'OK';
+        // check webhook config
+        try {
+            const response = await appOctokit.request('GET /app/hook/config', {});
+            if (response.data.url !== process.env.WEBHOOK_URL) {
+                status.github.webhook.status = 'GitHub has wrong webhook URL configured';
+            }
+            else {
+                // TODO check secret by doing a dummy delivery? force apply secret?
+                status.github.webhook.status = 'OK (note that secret cannot be checked automatically)';
+            }
+        }
+        catch (e) {
+            status.github.webhook.status = `Unable to check app configuration: ${e}`;
+            return status;
+        }
+    }
+    return status;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"status.lambda.js","sourceRoot":"","sources":["../../src/lambdas/status.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { createAppAuth } from '@octokit/auth-app';\nimport { Octokit } from '@octokit/core';\nimport * as AWS from 'aws-sdk';\nimport { baseUrlFromDomain } from './github';\nimport { getSecretJsonValue, getSecretValue } from './helpers';\n\nconst cfn = new AWS.CloudFormation();\nconst ec2 = new AWS.EC2();\nconst ecr = new AWS.ECR();\nconst sf = new AWS.StepFunctions();\n\nfunction secretArnToUrl(arn: string) {\n  const parts = arn.split(':'); // arn:aws:secretsmanager:us-east-1:12345678:secret:secret-name-REVISION\n  const region = parts[3];\n  const fullName = parts[6];\n  const name = fullName.slice(0, fullName.lastIndexOf('-'));\n\n  return `https://${region}.console.aws.amazon.com/secretsmanager/home?region=${region}#!/secret?name=${name}`;\n}\n\nfunction lambdaArnToUrl(arn: string) {\n  const parts = arn.split(':'); // arn:aws:lambda:us-east-1:12345678:function:name-XYZ\n  const region = parts[3];\n  const name = parts[6];\n\n  return `https://${region}.console.aws.amazon.com/lambda/home?region=${region}#/functions/${name}?tab=monitoring`;\n}\n\nfunction stepFunctionArnToUrl(arn: string) {\n  const parts = arn.split(':'); // arn:aws:states:us-east-1:12345678:stateMachine:name-XYZ\n  const region = parts[3];\n\n  return `https://${region}.console.aws.amazon.com/states/home?region=${region}#/statemachines/view/${arn}`;\n}\n\nasync function generateProvidersStatus(stack: string, logicalId: string) {\n  const resource = await cfn.describeStackResource({ StackName: stack, LogicalResourceId: logicalId }).promise();\n  const providers = JSON.parse(resource.StackResourceDetail?.Metadata ?? '{}').providers as any[] | undefined;\n\n  if (!providers) {\n    return {};\n  }\n\n  return Promise.all(providers.map(async (p) => {\n    // add ECR data, if image is from ECR\n    if (p.image?.imageRepository?.match(/[0-9]+\\.dkr\\.ecr\\.[a-z0-9\\-]+\\.amazonaws\\.com\\/.+/)) {\n      const tags = await ecr.describeImages({\n        repositoryName: p.image.imageRepository.split('/')[1],\n        filter: {\n          tagStatus: 'TAGGED',\n        },\n        maxResults: 1,\n      }).promise();\n      if (tags.imageDetails && tags.imageDetails?.length >= 1) {\n        p.image.latestImage = {\n          tags: tags.imageDetails[0].imageTags,\n          digest: tags.imageDetails[0].imageDigest,\n          date: tags.imageDetails[0].imagePushedAt,\n        };\n      }\n    }\n    // add AMI data, if image is AMI\n    if (p.ami?.launchTemplate) {\n      const versions = await ec2.describeLaunchTemplateVersions({\n        LaunchTemplateId: p.ami.launchTemplate,\n        Versions: ['$Default'],\n      }).promise();\n      if (versions.LaunchTemplateVersions && versions.LaunchTemplateVersions.length >= 1) {\n        p.ami.latestAmi = versions.LaunchTemplateVersions[0].LaunchTemplateData?.ImageId;\n      }\n    }\n    return p;\n  }));\n}\n\ninterface AppInstallation {\n  readonly id: number;\n  readonly url: string;\n  readonly status: string;\n  readonly repositories: string[];\n}\n\ninterface RecentRun {\n  readonly owner?: string;\n  readonly repo?: string;\n  readonly runId?: string;\n  readonly executionArn?: string;\n  readonly status: string;\n}\n\nexports.handler = async function () {\n  // confirm required environment variables\n  if (!process.env.WEBHOOK_SECRET_ARN || !process.env.GITHUB_SECRET_ARN || !process.env.GITHUB_PRIVATE_KEY_SECRET_ARN || !process.env.LOGICAL_ID ||\n      !process.env.WEBHOOK_HANDLER_ARN || !process.env.STEP_FUNCTION_ARN || !process.env.SETUP_SECRET_ARN || !process.env.SETUP_FUNCTION_URL ||\n      !process.env.STACK_NAME) {\n    throw new Error('Missing environment variables');\n  }\n\n  // base status\n  const status = {\n    github: {\n      setup: {\n        status: 'Unknown',\n        url: '',\n        secretArn: process.env.SETUP_SECRET_ARN,\n        secretUrl: secretArnToUrl(process.env.SETUP_SECRET_ARN),\n      },\n      domain: 'Unknown',\n      webhook: {\n        url: process.env.WEBHOOK_URL,\n        status: 'Unable to check',\n        secretArn: process.env.WEBHOOK_SECRET_ARN,\n        secretUrl: secretArnToUrl(process.env.WEBHOOK_SECRET_ARN),\n      },\n      auth: {\n        type: 'Unknown',\n        status: 'Unknown',\n        secretArn: process.env.GITHUB_SECRET_ARN,\n        secretUrl: secretArnToUrl(process.env.GITHUB_SECRET_ARN),\n        privateKeySecretArn: process.env.GITHUB_PRIVATE_KEY_SECRET_ARN,\n        privateKeySecretUrl: secretArnToUrl(process.env.GITHUB_PRIVATE_KEY_SECRET_ARN),\n        app: {\n          id: '',\n          url: '',\n          installations: [] as AppInstallation[],\n        },\n        personalAuthToken: '',\n      },\n    },\n    providers: await generateProvidersStatus(process.env.STACK_NAME, process.env.LOGICAL_ID),\n    troubleshooting: {\n      webhookHandlerArn: process.env.WEBHOOK_HANDLER_ARN,\n      webhookHandlerUrl: lambdaArnToUrl(process.env.WEBHOOK_HANDLER_ARN),\n      stepFunctionArn: process.env.STEP_FUNCTION_ARN,\n      stepFunctionUrl: stepFunctionArnToUrl(process.env.STEP_FUNCTION_ARN),\n      stepFunctionLogGroup: process.env.STEP_FUNCTION_LOG_GROUP,\n      recentRuns: [] as RecentRun[],\n    },\n  };\n\n  // setup url\n  const setupToken = (await getSecretJsonValue(process.env.SETUP_SECRET_ARN)).token;\n  if (setupToken) {\n    status.github.setup.status = 'Pending';\n    status.github.setup.url = `${process.env.SETUP_FUNCTION_URL}?token=${setupToken}`;\n  } else {\n    status.github.setup.status = 'Complete';\n  }\n\n  // list last 10 executions and their status\n  try {\n    const executions = await sf.listExecutions({\n      stateMachineArn: process.env.STEP_FUNCTION_ARN,\n      maxResults: 10,\n    }).promise();\n    for (const execution of executions.executions) {\n      const executionDetails = await sf.describeExecution({\n        executionArn: execution.executionArn,\n      }).promise();\n      const input = JSON.parse(executionDetails.input || '{}');\n\n      status.troubleshooting.recentRuns.push({\n        executionArn: execution.executionArn,\n        status: execution.status,\n        owner: input.owner,\n        repo: input.repo,\n        runId: input.runId,\n      });\n    }\n  } catch (e) {\n    status.troubleshooting.recentRuns.push({ status: `Error getting executions: ${e}` });\n  }\n\n  // get secrets\n  let githubSecrets;\n  try {\n    githubSecrets = await getSecretJsonValue(process.env.GITHUB_SECRET_ARN);\n  } catch (e) {\n    status.github.auth.status = `Unable to read secret: ${e}`;\n    return status;\n  }\n\n  let privateKey;\n  try {\n    privateKey = await getSecretValue(process.env.GITHUB_PRIVATE_KEY_SECRET_ARN);\n  } catch (e) {\n    status.github.auth.status = `Unable to read private key secret: ${e}`;\n    return status;\n  }\n\n  // calculate base url\n  let baseUrl = baseUrlFromDomain(githubSecrets.domain);\n  status.github.domain = githubSecrets.domain;\n\n  if (githubSecrets.personalAuthToken) {\n    // try authenticating with personal authentication token\n    status.github.auth.type = 'Personal Auth Token';\n    status.github.auth.personalAuthToken = '*redacted*';\n\n    let octokit;\n    try {\n      octokit = new Octokit({ baseUrl, auth: githubSecrets.personalAuthToken });\n    } catch (e) {\n      status.github.auth.status = `Unable to authenticate using personal auth token: ${e}`;\n      return status;\n    }\n\n    try {\n      const user = await octokit.request('GET /user');\n      status.github.auth.personalAuthToken = `username: ${user.data.login}`;\n    } catch (e) {\n      status.github.auth.status = `Unable to call /user with personal auth token: ${e}`;\n      return status;\n    }\n\n    status.github.auth.status = 'OK';\n    status.github.webhook.status = 'Unable to verify automatically';\n  } else {\n    // try authenticating with GitHub app\n    status.github.auth.type = 'GitHub App';\n    status.github.auth.app.id = githubSecrets.appId;\n\n    let appOctokit;\n    try {\n      appOctokit = new Octokit({\n        baseUrl,\n        authStrategy: createAppAuth,\n        auth: {\n          appId: githubSecrets.appId,\n          privateKey: privateKey,\n        },\n      });\n    } catch (e) {\n      status.github.auth.status = `Unable to authenticate app: ${e}`;\n      return status;\n    }\n\n    // get app url\n    try {\n      const app = (await appOctokit.request('GET /app')).data;\n      status.github.auth.app.url = app.html_url;\n    } catch (e) {\n      status.github.auth.status = `Unable to get app details: ${e}`;\n      return status;\n    }\n\n    // list all app installations\n    try {\n      const installations = (await appOctokit.request('GET /app/installations')).data;\n      for (const installation of installations) {\n        let installationDetails = {\n          id: installation.id,\n          url: installation.html_url,\n          status: 'Unable to query',\n          repositories: [] as string[],\n        };\n\n        let token;\n        try {\n          token = (await appOctokit.auth({\n            type: 'installation',\n            installationId: installation.id,\n          }) as any).token;\n        } catch (e) {\n          installationDetails.status = `Unable to authenticate app installation: ${e}`;\n          continue;\n        }\n\n        let octokit;\n        try {\n          octokit = new Octokit({ baseUrl, auth: token });\n        } catch (e) {\n          installationDetails.status = `Unable to authenticate using app: ${e}`;\n          continue;\n        }\n\n        try {\n          const repositories = (await octokit.request('GET /installation/repositories')).data.repositories;\n          for (const repo of repositories) {\n            installationDetails.repositories.push(repo.full_name as string);\n          }\n        } catch (e) {\n          installationDetails.status = `Unable to authenticate using installation token: ${e}`;\n          continue;\n        }\n\n        installationDetails.status = 'OK';\n        status.github.auth.app.installations.push(installationDetails);\n      }\n    } catch (e) {\n      status.github.auth.status = 'Unable to list app installations';\n      return status;\n    }\n\n    status.github.auth.status = 'OK';\n\n    // check webhook config\n    try {\n      const response = await appOctokit.request('GET /app/hook/config', {});\n\n      if (response.data.url !== process.env.WEBHOOK_URL) {\n        status.github.webhook.status = 'GitHub has wrong webhook URL configured';\n      } else {\n        // TODO check secret by doing a dummy delivery? force apply secret?\n        status.github.webhook.status = 'OK (note that secret cannot be checked automatically)';\n      }\n    } catch (e) {\n      status.github.webhook.status = `Unable to check app configuration: ${e}`;\n      return status;\n    }\n  }\n\n  return status;\n};\n"]}

package/lib/lambdas/token-retriever-function.d.ts

@@ -0,0 +1,13 @@
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+/**
+ * Props for TokenRetrieverFunction
+ */
+export interface TokenRetrieverFunctionProps extends lambda.FunctionOptions {
+}
+/**
+ * An AWS Lambda function which executes src/lambdas/token-retriever.
+ */
+export declare class TokenRetrieverFunction extends lambda.Function {
+    constructor(scope: Construct, id: string, props?: TokenRetrieverFunctionProps);
+}

package/lib/lambdas/token-retriever-function.js

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

package/lib/lambdas/token-retriever.lambda.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/lambdas/token-retriever.lambda.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const github_1 = require("./github");
+exports.handler = async function (event) {
+    const { githubSecrets, octokit } = await github_1.getOctokit(event.installationId);
+    const response = await octokit.rest.actions.createRegistrationTokenForRepo({
+        owner: event.owner,
+        repo: event.repo,
+    });
+    return {
+        domain: githubSecrets.domain,
+        token: response.data.token,
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW4tcmV0cmlldmVyLmxhbWJkYS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9sYW1iZGFzL3Rva2VuLXJldHJpZXZlci5sYW1iZGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxxQ0FBc0M7QUFHdEMsT0FBTyxDQUFDLE9BQU8sR0FBRyxLQUFLLFdBQVcsS0FBOEI7SUFDOUQsTUFBTSxFQUFFLGFBQWEsRUFBRSxPQUFPLEVBQUUsR0FBRyxNQUFNLG1CQUFVLENBQUMsS0FBSyxDQUFDLGNBQWMsQ0FBQyxDQUFDO0lBRTFFLE1BQU0sUUFBUSxHQUFHLE1BQU0sT0FBTyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsOEJBQThCLENBQUM7UUFDekUsS0FBSyxFQUFFLEtBQUssQ0FBQyxLQUFLO1FBQ2xCLElBQUksRUFBRSxLQUFLLENBQUMsSUFBSTtLQUNqQixDQUFDLENBQUM7SUFFSCxPQUFPO1FBQ0wsTUFBTSxFQUFFLGFBQWEsQ0FBQyxNQUFNO1FBQzVCLEtBQUssRUFBRSxRQUFRLENBQUMsSUFBSSxDQUFDLEtBQUs7S0FDM0IsQ0FBQztBQUNKLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGdldE9jdG9raXQgfSBmcm9tICcuL2dpdGh1Yic7XG5pbXBvcnQgeyBTdGVwRnVuY3Rpb25MYW1iZGFJbnB1dCB9IGZyb20gJy4vaGVscGVycyc7XG5cbmV4cG9ydHMuaGFuZGxlciA9IGFzeW5jIGZ1bmN0aW9uIChldmVudDogU3RlcEZ1bmN0aW9uTGFtYmRhSW5wdXQpIHtcbiAgY29uc3QgeyBnaXRodWJTZWNyZXRzLCBvY3Rva2l0IH0gPSBhd2FpdCBnZXRPY3Rva2l0KGV2ZW50Lmluc3RhbGxhdGlvbklkKTtcblxuICBjb25zdCByZXNwb25zZSA9IGF3YWl0IG9jdG9raXQucmVzdC5hY3Rpb25zLmNyZWF0ZVJlZ2lzdHJhdGlvblRva2VuRm9yUmVwbyh7XG4gICAgb3duZXI6IGV2ZW50Lm93bmVyLFxuICAgIHJlcG86IGV2ZW50LnJlcG8sXG4gIH0pO1xuXG4gIHJldHVybiB7XG4gICAgZG9tYWluOiBnaXRodWJTZWNyZXRzLmRvbWFpbixcbiAgICB0b2tlbjogcmVzcG9uc2UuZGF0YS50b2tlbixcbiAgfTtcbn07XG4iXX0=

package/lib/lambdas/update-lambda-function.d.ts

@@ -0,0 +1,13 @@
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+/**
+ * Props for UpdateLambdaFunction
+ */
+export interface UpdateLambdaFunctionProps extends lambda.FunctionOptions {
+}
+/**
+ * An AWS Lambda function which executes src/lambdas/update-lambda.
+ */
+export declare class UpdateLambdaFunction extends lambda.Function {
+    constructor(scope: Construct, id: string, props?: UpdateLambdaFunctionProps);
+}

package/lib/lambdas/update-lambda-function.js

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

package/lib/lambdas/update-lambda.lambda.d.ts

@@ -0,0 +1,7 @@
+interface Input {
+    readonly lambdaName: string;
+    readonly repositoryUri: string;
+    readonly repositoryTag: string;
+}
+export declare function handler(event: Input): Promise<void>;
+export {};

package/lib/lambdas/update-lambda.lambda.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+/* eslint-disable-next-line import/no-extraneous-dependencies */
+const AWS = require("aws-sdk");
+const lambda = new AWS.Lambda();
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function handler(event) {
+    console.log(JSON.stringify(event));
+    while (true) {
+        try {
+            await lambda.updateFunctionCode({
+                FunctionName: event.lambdaName,
+                ImageUri: `${event.repositoryUri}:${event.repositoryTag}`,
+                Publish: true,
+            }).promise();
+            break;
+        }
+        catch (e) {
+            if (e.code == 'ResourceConflictException') {
+                // keep trying if function is already being updated by CloudFormation
+                // this can happen if we update some settings on the function and the image code at the same time
+                await sleep(10000);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+}
+exports.handler = handler;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/lambdas/webhook-handler-function.d.ts

@@ -0,0 +1,13 @@
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+/**
+ * Props for WebhookHandlerFunction
+ */
+export interface WebhookHandlerFunctionProps extends lambda.FunctionOptions {
+}
+/**
+ * An AWS Lambda function which executes src/lambdas/webhook-handler.
+ */
+export declare class WebhookHandlerFunction extends lambda.Function {
+    constructor(scope: Construct, id: string, props?: WebhookHandlerFunctionProps);
+}

package/lib/lambdas/webhook-handler-function.js

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

package/lib/lambdas/webhook-handler.lambda.d.ts

@@ -0,0 +1 @@
+export {};