@cloudsnorkel/cdk-github-runners 0.8.0 → 0.8.2

package/lib/lambdas/github.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOctokit = exports.baseUrlFromDomain = void 0;
+/* eslint-disable import/no-extraneous-dependencies */
+const auth_app_1 = require("@octokit/auth-app");
+const rest_1 = require("@octokit/rest");
+const helpers_1 = require("./helpers");
+function baseUrlFromDomain(domain) {
+    if (domain == 'github.com') {
+        return 'https://api.github.com';
+    }
+    return `https://${domain}/api/v3`;
+}
+exports.baseUrlFromDomain = baseUrlFromDomain;
+async function getOctokit(installationId) {
+    if (!process.env.GITHUB_SECRET_ARN || !process.env.GITHUB_PRIVATE_KEY_SECRET_ARN) {
+        throw new Error('Missing environment variables');
+    }
+    const githubSecrets = await helpers_1.getSecretJsonValue(process.env.GITHUB_SECRET_ARN);
+    let baseUrl = baseUrlFromDomain(githubSecrets.domain);
+    let token;
+    if (githubSecrets.personalAuthToken) {
+        token = githubSecrets.personalAuthToken;
+    }
+    else {
+        const privateKey = await helpers_1.getSecretValue(process.env.GITHUB_PRIVATE_KEY_SECRET_ARN);
+        const appOctokit = new rest_1.Octokit({
+            baseUrl,
+            authStrategy: auth_app_1.createAppAuth,
+            auth: {
+                appId: githubSecrets.appId,
+                privateKey: privateKey,
+            },
+        });
+        token = (await appOctokit.auth({
+            type: 'installation',
+            installationId: installationId,
+        })).token;
+    }
+    const octokit = new rest_1.Octokit({
+        baseUrl,
+        auth: token,
+    });
+    return {
+        githubSecrets,
+        octokit,
+    };
+}
+exports.getOctokit = getOctokit;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2l0aHViLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2xhbWJkYXMvZ2l0aHViLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHNEQUFzRDtBQUN0RCxnREFBa0Q7QUFDbEQsd0NBQXdDO0FBQ3hDLHVDQUErRDtBQUUvRCxTQUFnQixpQkFBaUIsQ0FBQyxNQUFjO0lBQzlDLElBQUksTUFBTSxJQUFJLFlBQVksRUFBRTtRQUMxQixPQUFPLHdCQUF3QixDQUFDO0tBQ2pDO0lBQ0QsT0FBTyxXQUFXLE1BQU0sU0FBUyxDQUFDO0FBQ3BDLENBQUM7QUFMRCw4Q0FLQztBQUVNLEtBQUssVUFBVSxVQUFVLENBQUMsY0FBdUI7SUFDdEQsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsaUJBQWlCLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLDZCQUE2QixFQUFFO1FBQ2hGLE1BQU0sSUFBSSxLQUFLLENBQUMsK0JBQStCLENBQUMsQ0FBQztLQUNsRDtJQUVELE1BQU0sYUFBYSxHQUFHLE1BQU0sNEJBQWtCLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0lBRTlFLElBQUksT0FBTyxHQUFHLGlCQUFpQixDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUV0RCxJQUFJLEtBQUssQ0FBQztJQUNWLElBQUksYUFBYSxDQUFDLGlCQUFpQixFQUFFO1FBQ25DLEtBQUssR0FBRyxhQUFhLENBQUMsaUJBQWlCLENBQUM7S0FDekM7U0FBTTtRQUNMLE1BQU0sVUFBVSxHQUFHLE1BQU0sd0JBQWMsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLDZCQUE2QixDQUFDLENBQUM7UUFFbkYsTUFBTSxVQUFVLEdBQUcsSUFBSSxjQUFPLENBQUM7WUFDN0IsT0FBTztZQUNQLFlBQVksRUFBRSx3QkFBYTtZQUMzQixJQUFJLEVBQUU7Z0JBQ0osS0FBSyxFQUFFLGFBQWEsQ0FBQyxLQUFLO2dCQUMxQixVQUFVLEVBQUUsVUFBVTthQUN2QjtTQUNGLENBQUMsQ0FBQztRQUVILEtBQUssR0FBRyxDQUFDLE1BQU0sVUFBVSxDQUFDLElBQUksQ0FBQztZQUM3QixJQUFJLEVBQUUsY0FBYztZQUNwQixjQUFjLEVBQUUsY0FBYztTQUMvQixDQUFTLENBQUEsQ0FBQyxLQUFLLENBQUM7S0FDbEI7SUFFRCxNQUFNLE9BQU8sR0FBRyxJQUFJLGNBQU8sQ0FBQztRQUMxQixPQUFPO1FBQ1AsSUFBSSxFQUFFLEtBQUs7S0FDWixDQUFDLENBQUM7SUFFSCxPQUFPO1FBQ0wsYUFBYTtRQUNiLE9BQU87S0FDUixDQUFDO0FBQ0osQ0FBQztBQXZDRCxnQ0F1Q0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBpbXBvcnQvbm8tZXh0cmFuZW91cy1kZXBlbmRlbmNpZXMgKi9cbmltcG9ydCB7IGNyZWF0ZUFwcEF1dGggfSBmcm9tICdAb2N0b2tpdC9hdXRoLWFwcCc7XG5pbXBvcnQgeyBPY3Rva2l0IH0gZnJvbSAnQG9jdG9raXQvcmVzdCc7XG5pbXBvcnQgeyBnZXRTZWNyZXRWYWx1ZSwgZ2V0U2VjcmV0SnNvblZhbHVlIH0gZnJvbSAnLi9oZWxwZXJzJztcblxuZXhwb3J0IGZ1bmN0aW9uIGJhc2VVcmxGcm9tRG9tYWluKGRvbWFpbjogc3RyaW5nKTogc3RyaW5nIHtcbiAgaWYgKGRvbWFpbiA9PSAnZ2l0aHViLmNvbScpIHtcbiAgICByZXR1cm4gJ2h0dHBzOi8vYXBpLmdpdGh1Yi5jb20nO1xuICB9XG4gIHJldHVybiBgaHR0cHM6Ly8ke2RvbWFpbn0vYXBpL3YzYDtcbn1cblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGdldE9jdG9raXQoaW5zdGFsbGF0aW9uSWQ/OiBzdHJpbmcpIHtcbiAgaWYgKCFwcm9jZXNzLmVudi5HSVRIVUJfU0VDUkVUX0FSTiB8fCAhcHJvY2Vzcy5lbnYuR0lUSFVCX1BSSVZBVEVfS0VZX1NFQ1JFVF9BUk4pIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ01pc3NpbmcgZW52aXJvbm1lbnQgdmFyaWFibGVzJyk7XG4gIH1cblxuICBjb25zdCBnaXRodWJTZWNyZXRzID0gYXdhaXQgZ2V0U2VjcmV0SnNvblZhbHVlKHByb2Nlc3MuZW52LkdJVEhVQl9TRUNSRVRfQVJOKTtcblxuICBsZXQgYmFzZVVybCA9IGJhc2VVcmxGcm9tRG9tYWluKGdpdGh1YlNlY3JldHMuZG9tYWluKTtcblxuICBsZXQgdG9rZW47XG4gIGlmIChnaXRodWJTZWNyZXRzLnBlcnNvbmFsQXV0aFRva2VuKSB7XG4gICAgdG9rZW4gPSBnaXRodWJTZWNyZXRzLnBlcnNvbmFsQXV0aFRva2VuO1xuICB9IGVsc2Uge1xuICAgIGNvbnN0IHByaXZhdGVLZXkgPSBhd2FpdCBnZXRTZWNyZXRWYWx1ZShwcm9jZXNzLmVudi5HSVRIVUJfUFJJVkFURV9LRVlfU0VDUkVUX0FSTik7XG5cbiAgICBjb25zdCBhcHBPY3Rva2l0ID0gbmV3IE9jdG9raXQoe1xuICAgICAgYmFzZVVybCxcbiAgICAgIGF1dGhTdHJhdGVneTogY3JlYXRlQXBwQXV0aCxcbiAgICAgIGF1dGg6IHtcbiAgICAgICAgYXBwSWQ6IGdpdGh1YlNlY3JldHMuYXBwSWQsXG4gICAgICAgIHByaXZhdGVLZXk6IHByaXZhdGVLZXksXG4gICAgICB9LFxuICAgIH0pO1xuXG4gICAgdG9rZW4gPSAoYXdhaXQgYXBwT2N0b2tpdC5hdXRoKHtcbiAgICAgIHR5cGU6ICdpbnN0YWxsYXRpb24nLFxuICAgICAgaW5zdGFsbGF0aW9uSWQ6IGluc3RhbGxhdGlvbklkLFxuICAgIH0pIGFzIGFueSkudG9rZW47XG4gIH1cblxuICBjb25zdCBvY3Rva2l0ID0gbmV3IE9jdG9raXQoe1xuICAgIGJhc2VVcmwsXG4gICAgYXV0aDogdG9rZW4sXG4gIH0pO1xuXG4gIHJldHVybiB7XG4gICAgZ2l0aHViU2VjcmV0cyxcbiAgICBvY3Rva2l0LFxuICB9O1xufVxuIl19

package/lib/lambdas/helpers.d.ts

@@ -0,0 +1,12 @@
+export interface StepFunctionLambdaInput {
+    readonly owner: string;
+    readonly repo: string;
+    readonly runId: string;
+    readonly runnerName: string;
+    readonly installationId: string;
+    readonly labels: string[];
+}
+export declare function getSecretValue(arn: string | undefined): Promise<string>;
+export declare function getSecretJsonValue(arn: string | undefined): Promise<any>;
+export declare function updateSecretValue(arn: string | undefined, value: string): Promise<void>;
+export declare function customResourceRespond(event: AWSLambda.CloudFormationCustomResourceEvent, responseStatus: string, reason: string, physicalResourceId: string, data: any): Promise<unknown>;

package/lib/lambdas/helpers.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customResourceRespond = exports.updateSecretValue = exports.getSecretJsonValue = exports.getSecretValue = void 0;
+/* eslint-disable import/no-extraneous-dependencies */
+const AWS = require("aws-sdk");
+const sm = new AWS.SecretsManager();
+async function getSecretValue(arn) {
+    if (!arn) {
+        throw new Error('Missing secret ARN');
+    }
+    const secret = await sm.getSecretValue({ SecretId: arn }).promise();
+    if (!secret.SecretString) {
+        throw new Error(`No SecretString in ${arn}`);
+    }
+    return secret.SecretString;
+}
+exports.getSecretValue = getSecretValue;
+async function getSecretJsonValue(arn) {
+    return JSON.parse(await getSecretValue(arn));
+}
+exports.getSecretJsonValue = getSecretJsonValue;
+async function updateSecretValue(arn, value) {
+    if (!arn) {
+        throw new Error('Missing secret ARN');
+    }
+    await sm.updateSecret({ SecretId: arn, SecretString: value }).promise();
+}
+exports.updateSecretValue = updateSecretValue;
+async function customResourceRespond(event, responseStatus, reason, physicalResourceId, data) {
+    const responseBody = JSON.stringify({
+        Status: responseStatus,
+        Reason: reason,
+        PhysicalResourceId: physicalResourceId,
+        StackId: event.StackId,
+        RequestId: event.RequestId,
+        LogicalResourceId: event.LogicalResourceId,
+        NoEcho: false,
+        Data: data,
+    });
+    console.log('Responding', responseBody);
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const parsedUrl = require('url').parse(event.ResponseURL);
+    const requestOptions = {
+        hostname: parsedUrl.hostname,
+        path: parsedUrl.path,
+        method: 'PUT',
+        headers: {
+            'content-type': '',
+            'content-length': responseBody.length,
+        },
+    };
+    return new Promise((resolve, reject) => {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const request = require('https').request(requestOptions, resolve);
+            request.on('error', reject);
+            request.write(responseBody);
+            request.end();
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.customResourceRespond = customResourceRespond;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/lambdas/setup-function.d.ts

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

package/lib/lambdas/setup-function.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetupFunction = 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/setup.
+ */
+class SetupFunction extends lambda.Function {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            description: 'src/lambdas/setup.lambda.ts',
+            ...props,
+            runtime: new lambda.Runtime('nodejs14.x', lambda.RuntimeFamily.NODEJS),
+            handler: 'index.handler',
+            code: lambda.Code.fromAsset(path.join(__dirname, '../../assets/lambdas/setup.lambda')),
+        });
+        this.addEnvironment('AWS_NODEJS_CONNECTION_REUSE_ENABLED', '1', { removeInEdge: true });
+    }
+}
+exports.SetupFunction = SetupFunction;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/lambdas/setup.lambda.d.ts

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

package/lib/lambdas/setup.lambda.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+const crypto = require("crypto");
+const fs = require("fs");
+const rest_1 = require("@octokit/rest");
+const github_1 = require("./github");
+const helpers_1 = require("./helpers");
+const nonce = crypto.randomBytes(64).toString('hex');
+function getHtml(baseUrl, token, domain) {
+    return fs.readFileSync('index.html', 'utf-8')
+        .replace(/INSERT_WEBHOOK_URL_HERE/g, process.env.WEBHOOK_URL)
+        .replace(/INSERT_BASE_URL_HERE/g, baseUrl)
+        .replace(/INSERT_TOKEN_HERE/g, token)
+        .replace(/INSERT_SECRET_ARN_HERE/g, process.env.SETUP_SECRET_ARN)
+        .replace(/INSERT_DOMAIN_HERE/g, domain)
+        .replace(/<script/g, `<script nonce="${nonce}"`)
+        .replace(/<style/g, `<style nonce="${nonce}"`);
+}
+function response(code, body) {
+    return {
+        statusCode: code,
+        headers: {
+            'Content-Type': 'text/html',
+            'Content-Security-Policy': `default-src 'unsafe-inline' 'nonce-${nonce}'; img-src data:; connect-src 'self'; form-action https:; frame-ancestors 'none'; object-src 'none'; base-uri 'self'`,
+        },
+        body: body,
+    };
+}
+async function handleRoot(event, setupToken) {
+    const setupBaseUrl = `https://${event.requestContext.domainName}`;
+    const githubSecrets = await helpers_1.getSecretJsonValue(process.env.GITHUB_SECRET_ARN);
+    return response(200, getHtml(setupBaseUrl, setupToken, githubSecrets.domain));
+}
+function decodeBody(event) {
+    let body = event.body;
+    if (!body) {
+        throw new Error('No body found');
+    }
+    if (event.isBase64Encoded) {
+        body = Buffer.from(body, 'base64').toString('utf-8');
+    }
+    return JSON.parse(body);
+}
+async function handleDomain(event) {
+    const body = decodeBody(event);
+    if (!body.domain) {
+        return response(400, 'Invalid domain');
+    }
+    const githubSecrets = await helpers_1.getSecretJsonValue(process.env.GITHUB_SECRET_ARN);
+    githubSecrets.domain = body.domain;
+    await helpers_1.updateSecretValue(process.env.GITHUB_SECRET_ARN, JSON.stringify(githubSecrets));
+    return response(200, 'Domain set');
+}
+async function handlePat(event) {
+    const body = decodeBody(event);
+    if (!body.pat || !body.domain) {
+        return response(400, 'Invalid personal access token');
+    }
+    await helpers_1.updateSecretValue(process.env.GITHUB_SECRET_ARN, JSON.stringify({
+        domain: body.domain,
+        appId: '',
+        personalAuthToken: body.pat,
+    }));
+    await helpers_1.updateSecretValue(process.env.SETUP_SECRET_ARN, JSON.stringify({ token: '' }));
+    return response(200, 'Personal access token set');
+}
+async function handleNewApp(event) {
+    if (!event.queryStringParameters) {
+        return response(400, 'Invalid code');
+    }
+    const code = event.queryStringParameters.code;
+    if (!code) {
+        return response(400, 'Invalid code');
+    }
+    const githubSecrets = await helpers_1.getSecretJsonValue(process.env.GITHUB_SECRET_ARN);
+    const baseUrl = github_1.baseUrlFromDomain(githubSecrets.domain);
+    const newApp = await new rest_1.Octokit({ baseUrl }).rest.apps.createFromManifest({ code });
+    await helpers_1.updateSecretValue(process.env.GITHUB_SECRET_ARN, JSON.stringify({
+        domain: new URL(newApp.data.html_url).host,
+        appId: newApp.data.id,
+        personalAuthToken: '',
+    }));
+    await helpers_1.updateSecretValue(process.env.GITHUB_PRIVATE_KEY_SECRET_ARN, newApp.data.pem);
+    await helpers_1.updateSecretValue(process.env.WEBHOOK_SECRET_ARN, JSON.stringify({
+        webhookSecret: newApp.data.webhook_secret,
+    }));
+    await helpers_1.updateSecretValue(process.env.SETUP_SECRET_ARN, JSON.stringify({ token: '' }));
+    return response(200, `New app set. <a href="${newApp.data.html_url}/installations/new">Install it</a> for your repositories.`);
+}
+async function handleExistingApp(event) {
+    const body = decodeBody(event);
+    if (!body.appid || !body.pk || !body.domain) {
+        return response(400, 'Missing fields');
+    }
+    await helpers_1.updateSecretValue(process.env.GITHUB_SECRET_ARN, JSON.stringify({
+        domain: body.domain,
+        appId: body.appid,
+        personalAuthToken: '',
+    }));
+    await helpers_1.updateSecretValue(process.env.GITHUB_PRIVATE_KEY_SECRET_ARN, body.pk);
+    await helpers_1.updateSecretValue(process.env.SETUP_SECRET_ARN, JSON.stringify({ token: '' }));
+    return response(200, 'Existing app set. Don\'t forget to set up the webhook.');
+}
+exports.handler = async function (event) {
+    // confirm required environment variables
+    if (!process.env.WEBHOOK_URL) {
+        throw new Error('Missing environment variables');
+    }
+    const setupToken = (await helpers_1.getSecretJsonValue(process.env.SETUP_SECRET_ARN)).token;
+    // bail out if setup was already completed
+    if (!setupToken) {
+        return response(200, 'Setup already complete. Put a new token in the setup secret if you want to redo it.');
+    }
+    if (!event.queryStringParameters) {
+        return response(403, 'Wrong setup token.');
+    }
+    // safely confirm url token matches our secret
+    const urlToken = event.queryStringParameters.token || event.queryStringParameters.state || '';
+    if (urlToken.length != setupToken.length || !crypto.timingSafeEqual(Buffer.from(urlToken, 'utf-8'), Buffer.from(setupToken, 'utf-8'))) {
+        return response(403, 'Wrong setup token.');
+    }
+    // handle requests
+    try {
+        if (event.requestContext.http.path == '/') {
+            return await handleRoot(event, setupToken);
+        }
+        else if (event.requestContext.http.path == '/domain' && event.requestContext.http.method == 'POST') {
+            return await handleDomain(event);
+        }
+        else if (event.requestContext.http.path == '/pat' && event.requestContext.http.method == 'POST') {
+            return await handlePat(event);
+        }
+        else if (event.requestContext.http.path == '/complete-new-app' && event.requestContext.http.method == 'GET') {
+            return await handleNewApp(event);
+        }
+        else if (event.requestContext.http.path == '/app' && event.requestContext.http.method == 'POST') {
+            return await handleExistingApp(event);
+        }
+        else {
+            return response(404, 'Not found');
+        }
+    }
+    catch (e) {
+        return response(500, `<b>Error:</b> ${e}`);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"setup.lambda.js","sourceRoot":"","sources":["../../src/lambdas/setup.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport * as crypto from 'crypto';\nimport * as fs from 'fs';\nimport { Octokit } from '@octokit/rest';\n/* eslint-disable-next-line import/no-extraneous-dependencies,import/no-unresolved */\nimport * as AWSLambda from 'aws-lambda';\nimport { baseUrlFromDomain } from './github';\nimport { getSecretJsonValue, updateSecretValue } from './helpers';\n\nconst nonce = crypto.randomBytes(64).toString('hex');\n\nfunction getHtml(baseUrl: string, token: string, domain: string): string {\n  return fs.readFileSync('index.html', 'utf-8')\n    .replace(/INSERT_WEBHOOK_URL_HERE/g, process.env.WEBHOOK_URL!)\n    .replace(/INSERT_BASE_URL_HERE/g, baseUrl)\n    .replace(/INSERT_TOKEN_HERE/g, token)\n    .replace(/INSERT_SECRET_ARN_HERE/g, process.env.SETUP_SECRET_ARN!)\n    .replace(/INSERT_DOMAIN_HERE/g, domain)\n    .replace(/<script/g, `<script nonce=\"${nonce}\"`)\n    .replace(/<style/g, `<style nonce=\"${nonce}\"`);\n}\n\nfunction response(code: number, body: string): AWSLambda.APIGatewayProxyResultV2 {\n  return {\n    statusCode: code,\n    headers: {\n      'Content-Type': 'text/html',\n      'Content-Security-Policy': `default-src 'unsafe-inline' 'nonce-${nonce}'; img-src data:; connect-src 'self'; form-action https:; frame-ancestors 'none'; object-src 'none'; base-uri 'self'`,\n    },\n    body: body,\n  };\n}\n\nasync function handleRoot(event: AWSLambda.APIGatewayProxyEventV2, setupToken: string): Promise<AWSLambda.APIGatewayProxyResultV2> {\n  const setupBaseUrl = `https://${event.requestContext.domainName}`;\n  const githubSecrets = await getSecretJsonValue(process.env.GITHUB_SECRET_ARN);\n\n  return response(200, getHtml(setupBaseUrl, setupToken, githubSecrets.domain));\n}\n\nfunction decodeBody(event: AWSLambda.APIGatewayProxyEventV2) {\n  let body = event.body;\n  if (!body) {\n    throw new Error('No body found');\n  }\n  if (event.isBase64Encoded) {\n    body = Buffer.from(body, 'base64').toString('utf-8');\n  }\n  return JSON.parse(body);\n}\n\nasync function handleDomain(event: AWSLambda.APIGatewayProxyEventV2): Promise<AWSLambda.APIGatewayProxyResultV2> {\n  const body = decodeBody(event);\n  if (!body.domain) {\n    return response(400, 'Invalid domain');\n  }\n\n  const githubSecrets = await getSecretJsonValue(process.env.GITHUB_SECRET_ARN);\n  githubSecrets.domain = body.domain;\n  await updateSecretValue(process.env.GITHUB_SECRET_ARN, JSON.stringify(githubSecrets));\n\n  return response(200, 'Domain set');\n}\n\nasync function handlePat(event: AWSLambda.APIGatewayProxyEventV2): Promise<AWSLambda.APIGatewayProxyResultV2> {\n  const body = decodeBody(event);\n  if (!body.pat || !body.domain) {\n    return response(400, 'Invalid personal access token');\n  }\n\n  await updateSecretValue(process.env.GITHUB_SECRET_ARN, JSON.stringify({\n    domain: body.domain,\n    appId: '',\n    personalAuthToken: body.pat,\n  }));\n  await updateSecretValue(process.env.SETUP_SECRET_ARN, JSON.stringify({ token: '' }));\n\n  return response( 200, 'Personal access token set');\n}\n\nasync function handleNewApp(event: AWSLambda.APIGatewayProxyEventV2): Promise<AWSLambda.APIGatewayProxyResultV2> {\n  if (!event.queryStringParameters) {\n    return response( 400, 'Invalid code');\n  }\n\n  const code = event.queryStringParameters.code;\n\n  if (!code) {\n    return response( 400, 'Invalid code');\n  }\n\n  const githubSecrets = await getSecretJsonValue(process.env.GITHUB_SECRET_ARN);\n  const baseUrl = baseUrlFromDomain(githubSecrets.domain);\n  const newApp = await new Octokit({ baseUrl }).rest.apps.createFromManifest({ code });\n\n  await updateSecretValue(process.env.GITHUB_SECRET_ARN, JSON.stringify({\n    domain: new URL(newApp.data.html_url).host,\n    appId: newApp.data.id,\n    personalAuthToken: '',\n  }));\n  await updateSecretValue(process.env.GITHUB_PRIVATE_KEY_SECRET_ARN, newApp.data.pem);\n  await updateSecretValue(process.env.WEBHOOK_SECRET_ARN, JSON.stringify({\n    webhookSecret: newApp.data.webhook_secret,\n  }));\n  await updateSecretValue(process.env.SETUP_SECRET_ARN, JSON.stringify({ token: '' }));\n\n  return response( 200, `New app set. <a href=\"${newApp.data.html_url}/installations/new\">Install it</a> for your repositories.`);\n}\n\nasync function handleExistingApp(event: AWSLambda.APIGatewayProxyEventV2): Promise<AWSLambda.APIGatewayProxyResultV2> {\n  const body = decodeBody(event);\n\n  if (!body.appid || !body.pk || !body.domain) {\n    return response( 400, 'Missing fields');\n  }\n\n  await updateSecretValue(process.env.GITHUB_SECRET_ARN, JSON.stringify({\n    domain: body.domain,\n    appId: body.appid,\n    personalAuthToken: '',\n  }));\n  await updateSecretValue(process.env.GITHUB_PRIVATE_KEY_SECRET_ARN, body.pk as string);\n  await updateSecretValue(process.env.SETUP_SECRET_ARN, JSON.stringify({ token: '' }));\n\n  return response( 200, 'Existing app set. Don\\'t forget to set up the webhook.');\n}\n\nexports.handler = async function (event: AWSLambda.APIGatewayProxyEventV2): Promise<AWSLambda.APIGatewayProxyResultV2> {\n  // confirm required environment variables\n  if (!process.env.WEBHOOK_URL) {\n    throw new Error('Missing environment variables');\n  }\n\n  const setupToken = (await getSecretJsonValue(process.env.SETUP_SECRET_ARN)).token;\n\n  // bail out if setup was already completed\n  if (!setupToken) {\n    return response(200, 'Setup already complete. Put a new token in the setup secret if you want to redo it.');\n  }\n\n  if (!event.queryStringParameters) {\n    return response(403, 'Wrong setup token.');\n  }\n\n  // safely confirm url token matches our secret\n  const urlToken = event.queryStringParameters.token || event.queryStringParameters.state || '';\n  if (urlToken.length != setupToken.length || !crypto.timingSafeEqual(Buffer.from(urlToken, 'utf-8'), Buffer.from(setupToken, 'utf-8'))) {\n    return response(403, 'Wrong setup token.');\n  }\n\n  // handle requests\n  try {\n    if (event.requestContext.http.path == '/') {\n      return await handleRoot(event, setupToken);\n    } else if (event.requestContext.http.path == '/domain' && event.requestContext.http.method == 'POST') {\n      return await handleDomain(event);\n    } else if (event.requestContext.http.path == '/pat' && event.requestContext.http.method == 'POST') {\n      return await handlePat(event);\n    } else if (event.requestContext.http.path == '/complete-new-app' && event.requestContext.http.method == 'GET') {\n      return await handleNewApp(event);\n    } else if (event.requestContext.http.path == '/app' && event.requestContext.http.method == 'POST') {\n      return await handleExistingApp(event);\n    } else {\n      return response(404, 'Not found');\n    }\n  } catch (e) {\n    return response(500, `<b>Error:</b> ${e}`);\n  }\n};\n"]}

package/lib/lambdas/status-function.d.ts

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

package/lib/lambdas/status-function.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusFunction = 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/status.
+ */
+class StatusFunction extends lambda.Function {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            description: 'src/lambdas/status.lambda.ts',
+            ...props,
+            runtime: new lambda.Runtime('nodejs14.x', lambda.RuntimeFamily.NODEJS),
+            handler: 'index.handler',
+            code: lambda.Code.fromAsset(path.join(__dirname, '../../assets/lambdas/status.lambda')),
+        });
+        this.addEnvironment('AWS_NODEJS_CONNECTION_REUSE_ENABLED', '1', { removeInEdge: true });
+    }
+}
+exports.StatusFunction = StatusFunction;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/lambdas/status.lambda.d.ts

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