@cloudsnorkel/cdk-github-runners 0.9.1 → 0.9.3

package/assets/lambdas/setup.lambda/index.js

@@ -9164,7 +9164,8 @@ function response(code, body) {
   };
 }
 async function handleRoot(event, setupToken) {
-  const setupBaseUrl = `https://${event.requestContext.domainName}`;
+  const stage = event.requestContext.stage == "$default" ? "" : `/${event.requestContext.stage}`;
+  const setupBaseUrl = `https://${event.requestContext.domainName}${stage}`;
   const githubSecrets = await getSecretJsonValue(process.env.GITHUB_SECRET_ARN);
   return response(200, getHtml(setupBaseUrl, setupToken, githubSecrets.domain));
 }
@@ -9254,20 +9255,23 @@ exports.handler = async function(event) {
     return response(403, "Wrong setup token.");
   }
   try {
-    if (event.requestContext.http.path == "/") {
+    const path = event.path ?? event.rawPath;
+    const method = event.httpMethod ?? event.requestContext.http.method;
+    if (path == "/") {
       return await handleRoot(event, setupToken);
-    } else if (event.requestContext.http.path == "/domain" && event.requestContext.http.method == "POST") {
+    } else if (path == "/domain" && method == "POST") {
       return await handleDomain(event);
-    } else if (event.requestContext.http.path == "/pat" && event.requestContext.http.method == "POST") {
+    } else if (path == "/pat" && method == "POST") {
       return await handlePat(event);
-    } else if (event.requestContext.http.path == "/complete-new-app" && event.requestContext.http.method == "GET") {
+    } else if (path == "/complete-new-app" && method == "GET") {
       return await handleNewApp(event);
-    } else if (event.requestContext.http.path == "/app" && event.requestContext.http.method == "POST") {
+    } else if (path == "/app" && method == "POST") {
       return await handleExistingApp(event);
     } else {
       return response(404, "Not found");
     }
   } catch (e) {
+    console.error(e);
     return response(500, `<b>Error:</b> ${e}`);
   }
 };

package/assets/lambdas/status.lambda/index.js

@@ -21184,7 +21184,19 @@ async function generateProvidersStatus(stack, logicalId) {
     return p;
   }));
 }
-exports.handler = async function() {
+function safeReturnValue(event, status) {
+  if (event.path) {
+    return {
+      statusCode: 200,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(status)
+    };
+  }
+  return status;
+}
+exports.handler = async function(event) {
   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");
   }
@@ -21261,14 +21273,14 @@ exports.handler = async function() {
     githubSecrets = await getSecretJsonValue(process.env.GITHUB_SECRET_ARN);
   } catch (e) {
     status.github.auth.status = `Unable to read secret: ${e}`;
-    return status;
+    return safeReturnValue(event, status);
   }
   let privateKey;
   try {
     privateKey = await getSecretValue(process.env.GITHUB_PRIVATE_KEY_SECRET_ARN);
   } catch (e) {
     status.github.auth.status = `Unable to read private key secret: ${e}`;
-    return status;
+    return safeReturnValue(event, status);
   }
   let baseUrl = baseUrlFromDomain(githubSecrets.domain);
   status.github.domain = githubSecrets.domain;
@@ -21280,14 +21292,14 @@ exports.handler = async function() {
       octokit = new import_core.Octokit({ baseUrl, auth: githubSecrets.personalAuthToken });
     } catch (e) {
       status.github.auth.status = `Unable to authenticate using personal auth token: ${e}`;
-      return status;
+      return safeReturnValue(event, 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;
+      return safeReturnValue(event, status);
     }
     status.github.auth.status = "OK";
     status.github.webhook.status = "Unable to verify automatically";
@@ -21306,14 +21318,14 @@ exports.handler = async function() {
       });
     } catch (e) {
       status.github.auth.status = `Unable to authenticate app: ${e}`;
-      return status;
+      return safeReturnValue(event, status);
     }
     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;
+      return safeReturnValue(event, status);
     }
     try {
       const installations = (await appOctokit.request("GET /app/installations")).data;
@@ -21355,7 +21367,7 @@ exports.handler = async function() {
       }
     } catch (e) {
       status.github.auth.status = "Unable to list app installations";
-      return status;
+      return safeReturnValue(event, status);
     }
     status.github.auth.status = "OK";
     try {
@@ -21367,10 +21379,10 @@ exports.handler = async function() {
       }
     } catch (e) {
       status.github.webhook.status = `Unable to check app configuration: ${e}`;
-      return status;
+      return safeReturnValue(event, status);
     }
   }
-  return status;
+  return safeReturnValue(event, status);
 };
 /*! Bundled license information:
 

package/assets/lambdas/webhook-handler.lambda/index.js

@@ -45,8 +45,16 @@ async function getSecretJsonValue(arn) {
 
 // src/lambdas/webhook-handler.lambda.ts
 var sf = new AWS2.StepFunctions();
+function getHeader(event, header) {
+  for (const headerName of Object.keys(event.headers)) {
+    if (headerName.toLowerCase() === header.toLowerCase()) {
+      return event.headers[headerName];
+    }
+  }
+  return void 0;
+}
 function verifyBody(event, secret) {
-  const sig = Buffer.from(event.headers["x-hub-signature-256"] || "", "utf8");
+  const sig = Buffer.from(getHeader(event, "x-hub-signature-256") || "", "utf8");
   if (!event.body) {
     throw new Error("No body");
   }
@@ -81,21 +89,21 @@ exports.handler = async function(event) {
       body: "Bad signature"
     };
   }
-  if (event.headers["content-type"] !== "application/json") {
-    console.error(`This webhook only accepts JSON payloads, got ${event.headers["content-type"]}`);
+  if (getHeader(event, "content-type") !== "application/json") {
+    console.error(`This webhook only accepts JSON payloads, got ${getHeader(event, "content-type")}`);
     return {
       statusCode: 400,
       body: "Expecting JSON payload"
     };
   }
-  if (event.headers["x-github-event"] === "ping") {
+  if (getHeader(event, "x-github-event") === "ping") {
     return {
       statusCode: 200,
       body: "Pong"
     };
   }
-  if (event.headers["x-github-event"] !== "workflow_job") {
-    console.error(`This webhook only accepts workflow_job, got ${event.headers["x-github-event"]}`);
+  if (getHeader(event, "x-github-event") !== "workflow_job") {
+    console.error(`This webhook only accepts workflow_job, got ${getHeader(event, "x-github-event")}`);
     return {
       statusCode: 400,
       body: "Expecting workflow_job"
@@ -118,7 +126,7 @@ exports.handler = async function(event) {
   }
   let labels = {};
   payload.workflow_job.labels.forEach((l) => labels[l.toLowerCase()] = true);
-  let executionName = `${payload.repository.full_name.replace("/", "-")}-${event.headers["x-github-delivery"]}`.slice(0, 64);
+  let executionName = `${payload.repository.full_name.replace("/", "-")}-${getHeader(event, "x-github-delivery")}`.slice(0, 64);
   const execution = await sf.startExecution({
     stateMachineArn: process.env.STEP_FUNCTION_ARN,
     input: JSON.stringify({

package/lib/access.d.ts

@@ -0,0 +1,65 @@
+import { aws_ec2 as ec2, aws_lambda as lambda } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+export interface ApiGatewayAccessProps {
+    /**
+     * List of IP addresses in CIDR notation that are allowed to access the API Gateway.
+     *
+     * If not specified on public API Gateway, all IP addresses are allowed.
+     *
+     * If not specified on private API Gateway, no IP addresses are allowed (but specified security groups are).
+     */
+    readonly allowedIps?: string[];
+    /**
+     * Creates a private API Gateway and allows access from the specified VPC.
+     */
+    readonly allowedVpc?: ec2.IVpc;
+    /**
+     * List of security groups that are allowed to access the API Gateway.
+     *
+     * Only works for private API Gateways with {@link allowedVpc}.
+     */
+    readonly allowedSecurityGroups?: ec2.ISecurityGroup[];
+}
+/**
+ * Access configuration options for Lambda functions like setup and webhook function. Use this to limit access to these functions.
+ */
+export declare abstract class LambdaAccess {
+    /**
+     * Disables access to the configured Lambda function. This is useful for the setup function after setup is done.
+     */
+    static noAccess(): LambdaAccess;
+    /**
+     * Provide access using Lambda URL. This is the default and simplest option. It puts no limits on the requester, but the Lambda functions themselves authenticate every request.
+     */
+    static lambdaUrl(): LambdaAccess;
+    /**
+     * Provide access using API Gateway. This is the most secure option, but requires additional configuration. It allows you to limit access to specific IP addresses and even to a specific VPC.
+     *
+     * To limit access to GitHub.com use:
+     *
+     * ```
+     * LambdaAccess.apiGateway({
+     *   allowedIps: LambdaAccess.githubWebhookIps(),
+     * });
+     * ```
+     *
+     * Alternatively, get and manually update the list manually with:
+     *
+     * ```
+     * curl https://api.github.com/meta | jq .hooks
+     * ```
+     */
+    static apiGateway(props?: ApiGatewayAccessProps): LambdaAccess;
+    /**
+     * Downloads the list of IP addresses used by GitHub.com for webhooks.
+     *
+     * Note that downloading dynamic data during deployment is not recommended in CDK. This is a workaround for the lack of a better solution.
+     */
+    static githubWebhookIps(): string[];
+    /**
+     * Creates all required resources and returns access URL or empty string if disabled.
+     *
+     * @internal
+     */
+    abstract _bind(construct: Construct, id: string, lambdaFunction: lambda.Function): string;
+}

package/lib/access.js

@@ -0,0 +1,160 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaAccess = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const child_process_1 = require("child_process");
+const cdk = require("aws-cdk-lib");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+/**
+ * Access configuration options for Lambda functions like setup and webhook function. Use this to limit access to these functions.
+ */
+class LambdaAccess {
+    /**
+     * Disables access to the configured Lambda function. This is useful for the setup function after setup is done.
+     */
+    static noAccess() {
+        return new NoAccess();
+    }
+    /**
+     * Provide access using Lambda URL. This is the default and simplest option. It puts no limits on the requester, but the Lambda functions themselves authenticate every request.
+     */
+    static lambdaUrl() {
+        return new LambdaUrl();
+    }
+    /**
+     * Provide access using API Gateway. This is the most secure option, but requires additional configuration. It allows you to limit access to specific IP addresses and even to a specific VPC.
+     *
+     * To limit access to GitHub.com use:
+     *
+     * ```
+     * LambdaAccess.apiGateway({
+     *   allowedIps: LambdaAccess.githubWebhookIps(),
+     * });
+     * ```
+     *
+     * Alternatively, get and manually update the list manually with:
+     *
+     * ```
+     * curl https://api.github.com/meta | jq .hooks
+     * ```
+     */
+    static apiGateway(props) {
+        return new ApiGateway(props);
+    }
+    /**
+     * Downloads the list of IP addresses used by GitHub.com for webhooks.
+     *
+     * Note that downloading dynamic data during deployment is not recommended in CDK. This is a workaround for the lack of a better solution.
+     */
+    static githubWebhookIps() {
+        const githubMeta = (0, child_process_1.execFileSync)('curl', ['-fsSL', 'https://api.github.com/meta']).toString();
+        const githubMetaJson = JSON.parse(githubMeta);
+        return githubMetaJson.hooks;
+    }
+}
+_a = JSII_RTTI_SYMBOL_1;
+LambdaAccess[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.LambdaAccess", version: "0.9.3" };
+exports.LambdaAccess = LambdaAccess;
+/**
+ * @internal
+ */
+class NoAccess extends LambdaAccess {
+    _bind(_construct, _id, _lambdaFunction) {
+        return '';
+    }
+}
+/**
+ * @internal
+ */
+class LambdaUrl extends LambdaAccess {
+    _bind(_construct, _id, lambdaFunction) {
+        return lambdaFunction.addFunctionUrl({
+            authType: aws_lambda_1.FunctionUrlAuthType.NONE,
+        }).url;
+    }
+}
+/**
+ * @internal
+ */
+class ApiGateway {
+    constructor(props) {
+        this.props = props;
+    }
+    _bind(scope, id, lambdaFunction) {
+        let policy;
+        let endpointConfig = undefined;
+        if (this.props?.allowedVpc) {
+            // private api gateway
+            const sg = new aws_cdk_lib_1.aws_ec2.SecurityGroup(scope, `${id}/SG`, {
+                vpc: this.props.allowedVpc,
+                allowAllOutbound: true,
+            });
+            for (const otherSg of this.props?.allowedSecurityGroups ?? []) {
+                sg.connections.allowFrom(otherSg, aws_cdk_lib_1.aws_ec2.Port.tcp(443));
+            }
+            const vpcEndpoint = new aws_cdk_lib_1.aws_ec2.InterfaceVpcEndpoint(scope, `${id}/VpcEndpoint`, {
+                vpc: this.props.allowedVpc,
+                service: aws_cdk_lib_1.aws_ec2.InterfaceVpcEndpointAwsService.APIGATEWAY,
+                privateDnsEnabled: true,
+                securityGroups: [sg],
+                open: false,
+            });
+            endpointConfig = {
+                types: [aws_cdk_lib_1.aws_apigateway.EndpointType.PRIVATE],
+                vpcEndpoints: [vpcEndpoint],
+            };
+            policy = aws_iam_1.PolicyDocument.fromJson({
+                Version: '2012-10-17',
+                Statement: [
+                    {
+                        Effect: 'Allow',
+                        Principal: '*',
+                        Action: 'execute-api:Invoke',
+                        Resource: 'execute-api:/*/*/*',
+                        Condition: {
+                            StringEquals: {
+                                'aws:SourceVpce': vpcEndpoint.vpcEndpointId,
+                            },
+                        },
+                    },
+                ],
+            });
+        }
+        else {
+            // public api gateway
+            if (this.props?.allowedSecurityGroups) {
+                cdk.Annotations.of(scope).addWarning('allowedSecurityGroups is ignored when allowedVpc is not specified.');
+            }
+            policy = aws_iam_1.PolicyDocument.fromJson({
+                Version: '2012-10-17',
+                Statement: [
+                    {
+                        Effect: 'Allow',
+                        Principal: '*',
+                        Action: 'execute-api:Invoke',
+                        Resource: 'execute-api:/*/*/*',
+                        Condition: {
+                            IpAddress: {
+                                'aws:SourceIp': this.props?.allowedIps ?? ['0.0.0.0/0'],
+                            },
+                        },
+                    },
+                ],
+            });
+        }
+        const api = new aws_cdk_lib_1.aws_apigateway.LambdaRestApi(scope, id, {
+            handler: lambdaFunction,
+            proxy: true,
+            cloudWatchRole: false,
+            endpointConfiguration: endpointConfig,
+            policy,
+        });
+        // remove CfnOutput
+        api.node.tryRemoveChild('Endpoint');
+        return api.url;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"access.js","sourceRoot":"","sources":["../src/access.ts"],"names":[],"mappings":"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","sourcesContent":["import { execFileSync } from 'child_process';\nimport * as cdk from 'aws-cdk-lib';\nimport { aws_apigateway as apigateway, aws_ec2 as ec2, aws_iam as iam, aws_lambda as lambda } from 'aws-cdk-lib';\nimport { PolicyDocument } from 'aws-cdk-lib/aws-iam';\nimport { FunctionUrlAuthType } from 'aws-cdk-lib/aws-lambda';\nimport { Construct } from 'constructs';\n\n\nexport interface ApiGatewayAccessProps {\n  /**\n   * List of IP addresses in CIDR notation that are allowed to access the API Gateway.\n   *\n   * If not specified on public API Gateway, all IP addresses are allowed.\n   *\n   * If not specified on private API Gateway, no IP addresses are allowed (but specified security groups are).\n   */\n  readonly allowedIps?: string[];\n\n  /**\n   * Creates a private API Gateway and allows access from the specified VPC.\n   */\n  readonly allowedVpc?: ec2.IVpc;\n\n  /**\n   * List of security groups that are allowed to access the API Gateway.\n   *\n   * Only works for private API Gateways with {@link allowedVpc}.\n   */\n  readonly allowedSecurityGroups?: ec2.ISecurityGroup[];\n}\n\n/**\n * Access configuration options for Lambda functions like setup and webhook function. Use this to limit access to these functions.\n */\nexport abstract class LambdaAccess {\n  /**\n   * Disables access to the configured Lambda function. This is useful for the setup function after setup is done.\n   */\n  static noAccess(): LambdaAccess {\n    return new NoAccess();\n  }\n\n  /**\n   * Provide access using Lambda URL. This is the default and simplest option. It puts no limits on the requester, but the Lambda functions themselves authenticate every request.\n   */\n  static lambdaUrl(): LambdaAccess {\n    return new LambdaUrl();\n  }\n\n  /**\n   * Provide access using API Gateway. This is the most secure option, but requires additional configuration. It allows you to limit access to specific IP addresses and even to a specific VPC.\n   *\n   * To limit access to GitHub.com use:\n   *\n   * ```\n   * LambdaAccess.apiGateway({\n   *   allowedIps: LambdaAccess.githubWebhookIps(),\n   * });\n   * ```\n   *\n   * Alternatively, get and manually update the list manually with:\n   *\n   * ```\n   * curl https://api.github.com/meta | jq .hooks\n   * ```\n   */\n  static apiGateway(props?: ApiGatewayAccessProps): LambdaAccess {\n    return new ApiGateway(props);\n  }\n\n  /**\n   * Downloads the list of IP addresses used by GitHub.com for webhooks.\n   *\n   * Note that downloading dynamic data during deployment is not recommended in CDK. This is a workaround for the lack of a better solution.\n   */\n  static githubWebhookIps(): string[] {\n    const githubMeta = execFileSync('curl', ['-fsSL', 'https://api.github.com/meta']).toString();\n    const githubMetaJson = JSON.parse(githubMeta);\n    return githubMetaJson.hooks;\n  }\n\n  /**\n   * Creates all required resources and returns access URL or empty string if disabled.\n   *\n   * @internal\n   */\n  public abstract _bind(construct: Construct, id: string, lambdaFunction: lambda.Function): string;\n}\n\n/**\n * @internal\n */\nclass NoAccess extends LambdaAccess {\n  public _bind(_construct: Construct, _id: string, _lambdaFunction: lambda.Function): string {\n    return '';\n  }\n}\n\n/**\n * @internal\n */\nclass LambdaUrl extends LambdaAccess {\n  public _bind(_construct: Construct, _id: string, lambdaFunction: lambda.Function): string {\n    return lambdaFunction.addFunctionUrl({\n      authType: FunctionUrlAuthType.NONE,\n    }).url;\n  }\n}\n\n/**\n * @internal\n */\nclass ApiGateway {\n  constructor(private readonly props?: ApiGatewayAccessProps) {}\n\n  public _bind(scope: Construct, id: string, lambdaFunction: lambda.Function): string {\n    let policy: iam.PolicyDocument;\n    let endpointConfig: apigateway.EndpointConfiguration | undefined = undefined;\n\n    if (this.props?.allowedVpc) {\n      // private api gateway\n      const sg = new ec2.SecurityGroup(scope, `${id}/SG`, {\n        vpc: this.props.allowedVpc,\n        allowAllOutbound: true,\n      });\n\n      for (const otherSg of this.props?.allowedSecurityGroups ?? []) {\n        sg.connections.allowFrom(otherSg, ec2.Port.tcp(443));\n      }\n\n      const vpcEndpoint = new ec2.InterfaceVpcEndpoint(scope, `${id}/VpcEndpoint`, {\n        vpc: this.props.allowedVpc,\n        service: ec2.InterfaceVpcEndpointAwsService.APIGATEWAY,\n        privateDnsEnabled: true,\n        securityGroups: [sg],\n        open: false,\n      });\n\n      endpointConfig = {\n        types: [apigateway.EndpointType.PRIVATE],\n        vpcEndpoints: [vpcEndpoint],\n      };\n\n      policy = PolicyDocument.fromJson({\n        Version: '2012-10-17',\n        Statement: [\n          {\n            Effect: 'Allow',\n            Principal: '*',\n            Action: 'execute-api:Invoke',\n            Resource: 'execute-api:/*/*/*',\n            Condition: {\n              StringEquals: {\n                'aws:SourceVpce': vpcEndpoint.vpcEndpointId,\n              },\n            },\n          },\n        ],\n      });\n    } else {\n      // public api gateway\n      if (this.props?.allowedSecurityGroups) {\n        cdk.Annotations.of(scope).addWarning('allowedSecurityGroups is ignored when allowedVpc is not specified.');\n      }\n\n      policy = PolicyDocument.fromJson({\n        Version: '2012-10-17',\n        Statement: [\n          {\n            Effect: 'Allow',\n            Principal: '*',\n            Action: 'execute-api:Invoke',\n            Resource: 'execute-api:/*/*/*',\n            Condition: {\n              IpAddress: {\n                'aws:SourceIp': this.props?.allowedIps ?? ['0.0.0.0/0'],\n              },\n            },\n          },\n        ],\n      });\n    }\n\n    const api = new apigateway.LambdaRestApi(scope, id, {\n      handler: lambdaFunction,\n      proxy: true,\n      cloudWatchRole: false,\n      endpointConfiguration: endpointConfig,\n      policy,\n    });\n\n    // remove CfnOutput\n    api.node.tryRemoveChild('Endpoint');\n\n    return api.url;\n  }\n}\n"]}

package/lib/index.d.ts

@@ -1,3 +1,4 @@
+export * from './access';
 export * from './secrets';
 export * from './runner';
 export * from './providers';

package/lib/index.js

@@ -14,7 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./access"), exports);
 __exportStar(require("./secrets"), exports);
 __exportStar(require("./runner"), exports);
 __exportStar(require("./providers"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDRDQUEwQjtBQUMxQiwyQ0FBeUI7QUFDekIsOENBQTRCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zZWNyZXRzJztcbmV4cG9ydCAqIGZyb20gJy4vcnVubmVyJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvdmlkZXJzJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDJDQUF5QjtBQUN6Qiw0Q0FBMEI7QUFDMUIsMkNBQXlCO0FBQ3pCLDhDQUE0QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYWNjZXNzJztcbmV4cG9ydCAqIGZyb20gJy4vc2VjcmV0cyc7XG5leHBvcnQgKiBmcm9tICcuL3J1bm5lcic7XG5leHBvcnQgKiBmcm9tICcuL3Byb3ZpZGVycyc7XG4iXX0=

package/lib/lambdas/setup.lambda.js

@@ -28,7 +28,8 @@ function response(code, body) {
     };
 }
 async function handleRoot(event, setupToken) {
-    const setupBaseUrl = `https://${event.requestContext.domainName}`;
+    const stage = event.requestContext.stage == '$default' ? '' : `/${event.requestContext.stage}`;
+    const setupBaseUrl = `https://${event.requestContext.domainName}${stage}`;
     const githubSecrets = await (0, helpers_1.getSecretJsonValue)(process.env.GITHUB_SECRET_ARN);
     return response(200, getHtml(setupBaseUrl, setupToken, githubSecrets.domain));
 }
@@ -122,19 +123,21 @@ exports.handler = async function (event) {
     }
     // handle requests
     try {
-        if (event.requestContext.http.path == '/') {
+        const path = event.path ?? event.rawPath;
+        const method = event.httpMethod ?? event.requestContext.http.method;
+        if (path == '/') {
             return await handleRoot(event, setupToken);
         }
-        else if (event.requestContext.http.path == '/domain' && event.requestContext.http.method == 'POST') {
+        else if (path == '/domain' && method == 'POST') {
             return await handleDomain(event);
         }
-        else if (event.requestContext.http.path == '/pat' && event.requestContext.http.method == 'POST') {
+        else if (path == '/pat' && method == 'POST') {
             return await handlePat(event);
         }
-        else if (event.requestContext.http.path == '/complete-new-app' && event.requestContext.http.method == 'GET') {
+        else if (path == '/complete-new-app' && method == 'GET') {
             return await handleNewApp(event);
         }
-        else if (event.requestContext.http.path == '/app' && event.requestContext.http.method == 'POST') {
+        else if (path == '/app' && method == 'POST') {
             return await handleExistingApp(event);
         }
         else {
@@ -142,7 +145,8 @@ exports.handler = async function (event) {
         }
     }
     catch (e) {
+        console.error(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"]}
+//# 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\ntype ApiGatewayEvent = AWSLambda.APIGatewayProxyEvent | AWSLambda.APIGatewayProxyEventV2;\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: ApiGatewayEvent, setupToken: string): Promise<AWSLambda.APIGatewayProxyResultV2> {\n  const stage = event.requestContext.stage == '$default' ? '' : `/${event.requestContext.stage}`;\n  const setupBaseUrl = `https://${event.requestContext.domainName}${stage}`;\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: ApiGatewayEvent) {\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: ApiGatewayEvent): 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: ApiGatewayEvent): 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: ApiGatewayEvent): 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: ApiGatewayEvent): 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: ApiGatewayEvent): 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    const path = (event as AWSLambda.APIGatewayProxyEvent).path ?? (event as AWSLambda.APIGatewayProxyEventV2).rawPath;\n    const method = (event as AWSLambda.APIGatewayProxyEvent).httpMethod ?? (event as AWSLambda.APIGatewayProxyEventV2).requestContext.http.method;\n    if (path == '/') {\n      return await handleRoot(event, setupToken);\n    } else if (path == '/domain' && method == 'POST') {\n      return await handleDomain(event);\n    } else if (path == '/pat' && method == 'POST') {\n      return await handlePat(event);\n    } else if (path == '/complete-new-app' && method == 'GET') {\n      return await handleNewApp(event);\n    } else if (path == '/app' && method == 'POST') {\n      return await handleExistingApp(event);\n    } else {\n      return response(404, 'Not found');\n    }\n  } catch (e) {\n    console.error(e);\n    return response(500, `<b>Error:</b> ${e}`);\n  }\n};\n"]}