@cloudsnorkel/cdk-github-runners 0.14.9 → 0.14.11

package/lib/webhook-handler.lambda.js

@@ -77,8 +77,8 @@ function matchLabelsToProvider(labels) {
  *
  * @internal
  */
-function generateExecutionName(payload) {
-    const deliveryId = payload.workflow_job?.id || `${Math.random()}`;
+function generateExecutionName(event, payload) {
+    const deliveryId = getHeader(event, 'x-github-delivery') ?? `${Math.random()}`;
     const repoNameTruncated = payload.repository.name.slice(0, 64 - deliveryId.length - 1);
     return `${repoNameTruncated}-${deliveryId}`;
 }
@@ -116,7 +116,7 @@ async function handler(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,
+            statusCode: 200,
             body: 'Expecting workflow_job',
         };
     }
@@ -165,7 +165,7 @@ async function handler(event) {
         };
     }
     // start execution
-    const executionName = generateExecutionName(payload);
+    const executionName = generateExecutionName(event, payload);
     const input = {
         owner: payload.repository.owner.login,
         repo: payload.repository.name,
@@ -192,4 +192,4 @@ async function handler(event) {
         body: executionName,
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webhook-handler.lambda.js","sourceRoot":"","sources":["../src/webhook-handler.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["import * as crypto from 'crypto';\nimport { SFNClient, StartExecutionCommand } from '@aws-sdk/client-sfn';\nimport * as AWSLambda from 'aws-lambda';\nimport { getOctokit } from './lambda-github';\nimport { getSecretJsonValue } from './lambda-helpers';\nimport { SupportedLabels } from './webhook';\n\nconst sf = new SFNClient();\n\n// TODO use @octokit/webhooks?\n\nfunction getHeader(event: AWSLambda.APIGatewayProxyEventV2, header: string): string | undefined {\n  // API Gateway doesn't lowercase headers (V1 event) but Lambda URLs do (V2 event) :(\n  for (const headerName of Object.keys(event.headers)) {\n    if (headerName.toLowerCase() === header.toLowerCase()) {\n      return event.headers[headerName];\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Exported for unit testing.\n * @internal\n */\nexport function verifyBody(event: AWSLambda.APIGatewayProxyEventV2, secret: any): string {\n  const sig = Buffer.from(getHeader(event, 'x-hub-signature-256') || '', 'utf8');\n\n  if (!event.body) {\n    throw new Error('No body');\n  }\n\n  let body: Buffer;\n  if (event.isBase64Encoded) {\n    body = Buffer.from(event.body, 'base64');\n  } else {\n    body = Buffer.from(event.body || '', 'utf8');\n  }\n\n  const hmac = crypto.createHmac('sha256', secret);\n  hmac.update(body);\n  const expectedSig = Buffer.from(`sha256=${hmac.digest('hex')}`, 'utf8');\n\n  console.log('Calculated signature: ', expectedSig.toString());\n\n  if (sig.length !== expectedSig.length || !crypto.timingSafeEqual(sig, expectedSig)) {\n    throw new Error(`Signature mismatch. Expected ${expectedSig.toString()} but got ${sig.toString()}`);\n  }\n\n  return body.toString();\n}\n\nasync function isDeploymentPending(payload: any) {\n  const statusesUrl = payload.deployment?.statuses_url;\n  if (statusesUrl === undefined) {\n    return false;\n  }\n\n  try {\n    const { octokit } = await getOctokit(payload.installation?.id);\n    const statuses = await octokit.request(statusesUrl);\n\n    return statuses.data[0]?.state === 'waiting';\n  } catch (e) {\n    console.error('Unable to check deployment. Try adding deployment read permission.', e);\n    return false;\n  }\n}\n\nfunction matchLabelsToProvider(labels: string[]) {\n  const jobLabelSet = labels.map((label) => label.toLowerCase());\n  const supportedLabels: SupportedLabels[] = JSON.parse(process.env.SUPPORTED_LABELS!);\n\n  // is every label the job requires available in the runner provider?\n  for (const supportedLabelSet of supportedLabels) {\n    const lowerCasedSupportedLabelSet = supportedLabelSet.labels.map((label) => label.toLowerCase());\n    if (jobLabelSet.every(label => label == 'self-hosted' || lowerCasedSupportedLabelSet.includes(label))) {\n      return supportedLabelSet.provider;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Generate a unique execution name which is limited to 64 characters (also used as runner name).\n *\n * Exported for unit testing.\n *\n * @internal\n */\nexport function generateExecutionName(payload: any): string {\n  const deliveryId = payload.workflow_job?.id || `${Math.random()}`;\n  const repoNameTruncated = payload.repository.name.slice(0, 64 - deliveryId.length - 1);\n  return `${repoNameTruncated}-${deliveryId}`;\n}\n\nexport async function handler(event: AWSLambda.APIGatewayProxyEventV2): Promise<AWSLambda.APIGatewayProxyResultV2> {\n  if (!process.env.WEBHOOK_SECRET_ARN || !process.env.STEP_FUNCTION_ARN || !process.env.SUPPORTED_LABELS || !process.env.REQUIRE_SELF_HOSTED_LABEL) {\n    throw new Error('Missing environment variables');\n  }\n\n  const webhookSecret = (await getSecretJsonValue(process.env.WEBHOOK_SECRET_ARN)).webhookSecret;\n\n  let body;\n  try {\n    body = verifyBody(event, webhookSecret);\n  } catch (e) {\n    console.error(e);\n    return {\n      statusCode: 403,\n      body: 'Bad signature',\n    };\n  }\n\n  if (getHeader(event, 'content-type') !== 'application/json') {\n    console.error(`This webhook only accepts JSON payloads, got ${getHeader(event, 'content-type')}`);\n    return {\n      statusCode: 400,\n      body: 'Expecting JSON payload',\n    };\n  }\n\n  if (getHeader(event, 'x-github-event') === 'ping') {\n    return {\n      statusCode: 200,\n      body: 'Pong',\n    };\n  }\n\n  // if (getHeader(event, 'x-github-event') !== 'workflow_job' && getHeader(event, 'x-github-event') !== 'workflow_run') {\n  //     console.error(`This webhook only accepts workflow_job and workflow_run, got ${getHeader(event, 'x-github-event')}`);\n  if (getHeader(event, 'x-github-event') !== 'workflow_job') {\n    console.error(`This webhook only accepts workflow_job, got ${getHeader(event, 'x-github-event')}`);\n    return {\n      statusCode: 400,\n      body: 'Expecting workflow_job',\n    };\n  }\n\n  const payload = JSON.parse(body);\n\n  if (payload.action !== 'queued') {\n    console.log({\n      notice: `Ignoring action \"${payload.action}\", expecting \"queued\"`,\n      job: payload.workflow_job,\n    });\n    return {\n      statusCode: 200,\n      body: 'OK. No runner started (action is not \"queued\").',\n    };\n  }\n\n  if (process.env.REQUIRE_SELF_HOSTED_LABEL === '1' && !payload.workflow_job.labels.includes('self-hosted')) {\n    console.log({\n      notice: `Ignoring labels \"${payload.workflow_job.labels}\", expecting \"self-hosted\"`,\n      job: payload.workflow_job,\n    });\n    return {\n      statusCode: 200,\n      body: 'OK. No runner started (no \"self-hosted\" label).',\n    };\n  }\n\n  // don't start step function unless labels match a runner provider\n  const provider = matchLabelsToProvider(payload.workflow_job.labels);\n  if (!provider) {\n    console.log({\n      notice: `Ignoring labels \"${payload.workflow_job.labels}\", as they don't match a supported runner provider`,\n      job: payload.workflow_job,\n    });\n    return {\n      statusCode: 200,\n      body: 'OK. No runner started (no provider with matching labels).',\n    };\n  }\n\n  // don't start runners for a deployment that's still pending as GitHub will send another event when it's ready\n  if (await isDeploymentPending(payload)) {\n    console.log({\n      notice: 'Ignoring job as its deployment is still pending',\n      job: payload.workflow_job,\n    });\n    return {\n      statusCode: 200,\n      body: 'OK. No runner started (deployment pending).',\n    };\n  }\n\n  // start execution\n  const executionName = generateExecutionName(payload);\n  const input = {\n    owner: payload.repository.owner.login,\n    repo: payload.repository.name,\n    jobId: payload.workflow_job.id,\n    jobUrl: payload.workflow_job.html_url,\n    installationId: payload.installation?.id ?? -1, // always pass value because step function can't handle missing input\n    labels: payload.workflow_job.labels.join(','),\n    provider: provider,\n  };\n  const execution = await sf.send(new StartExecutionCommand({\n    stateMachineArn: process.env.STEP_FUNCTION_ARN,\n    input: JSON.stringify(input),\n    // name is not random so multiple execution of this webhook won't cause multiple builders to start\n    name: executionName,\n  }));\n\n  console.log({\n    notice: 'Started orchestrator',\n    execution: execution.executionArn,\n    sfnInput: input,\n    job: payload.workflow_job,\n  });\n\n  return {\n    statusCode: 202,\n    body: executionName,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webhook-handler.lambda.js","sourceRoot":"","sources":["../src/webhook-handler.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["import * as crypto from 'crypto';\nimport { SFNClient, StartExecutionCommand } from '@aws-sdk/client-sfn';\nimport * as AWSLambda from 'aws-lambda';\nimport { getOctokit } from './lambda-github';\nimport { getSecretJsonValue } from './lambda-helpers';\nimport { SupportedLabels } from './webhook';\n\nconst sf = new SFNClient();\n\n// TODO use @octokit/webhooks?\n\nfunction getHeader(event: AWSLambda.APIGatewayProxyEventV2, header: string): string | undefined {\n  // API Gateway doesn't lowercase headers (V1 event) but Lambda URLs do (V2 event) :(\n  for (const headerName of Object.keys(event.headers)) {\n    if (headerName.toLowerCase() === header.toLowerCase()) {\n      return event.headers[headerName];\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Exported for unit testing.\n * @internal\n */\nexport function verifyBody(event: AWSLambda.APIGatewayProxyEventV2, secret: any): string {\n  const sig = Buffer.from(getHeader(event, 'x-hub-signature-256') || '', 'utf8');\n\n  if (!event.body) {\n    throw new Error('No body');\n  }\n\n  let body: Buffer;\n  if (event.isBase64Encoded) {\n    body = Buffer.from(event.body, 'base64');\n  } else {\n    body = Buffer.from(event.body || '', 'utf8');\n  }\n\n  const hmac = crypto.createHmac('sha256', secret);\n  hmac.update(body);\n  const expectedSig = Buffer.from(`sha256=${hmac.digest('hex')}`, 'utf8');\n\n  console.log('Calculated signature: ', expectedSig.toString());\n\n  if (sig.length !== expectedSig.length || !crypto.timingSafeEqual(sig, expectedSig)) {\n    throw new Error(`Signature mismatch. Expected ${expectedSig.toString()} but got ${sig.toString()}`);\n  }\n\n  return body.toString();\n}\n\nasync function isDeploymentPending(payload: any) {\n  const statusesUrl = payload.deployment?.statuses_url;\n  if (statusesUrl === undefined) {\n    return false;\n  }\n\n  try {\n    const { octokit } = await getOctokit(payload.installation?.id);\n    const statuses = await octokit.request(statusesUrl);\n\n    return statuses.data[0]?.state === 'waiting';\n  } catch (e) {\n    console.error('Unable to check deployment. Try adding deployment read permission.', e);\n    return false;\n  }\n}\n\nfunction matchLabelsToProvider(labels: string[]) {\n  const jobLabelSet = labels.map((label) => label.toLowerCase());\n  const supportedLabels: SupportedLabels[] = JSON.parse(process.env.SUPPORTED_LABELS!);\n\n  // is every label the job requires available in the runner provider?\n  for (const supportedLabelSet of supportedLabels) {\n    const lowerCasedSupportedLabelSet = supportedLabelSet.labels.map((label) => label.toLowerCase());\n    if (jobLabelSet.every(label => label == 'self-hosted' || lowerCasedSupportedLabelSet.includes(label))) {\n      return supportedLabelSet.provider;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Generate a unique execution name which is limited to 64 characters (also used as runner name).\n *\n * Exported for unit testing.\n *\n * @internal\n */\nexport function generateExecutionName(event: any, payload: any): string {\n  const deliveryId = getHeader(event, 'x-github-delivery') ?? `${Math.random()}`;\n  const repoNameTruncated = payload.repository.name.slice(0, 64 - deliveryId.length - 1);\n  return `${repoNameTruncated}-${deliveryId}`;\n}\n\nexport async function handler(event: AWSLambda.APIGatewayProxyEventV2): Promise<AWSLambda.APIGatewayProxyResultV2> {\n  if (!process.env.WEBHOOK_SECRET_ARN || !process.env.STEP_FUNCTION_ARN || !process.env.SUPPORTED_LABELS || !process.env.REQUIRE_SELF_HOSTED_LABEL) {\n    throw new Error('Missing environment variables');\n  }\n\n  const webhookSecret = (await getSecretJsonValue(process.env.WEBHOOK_SECRET_ARN)).webhookSecret;\n\n  let body;\n  try {\n    body = verifyBody(event, webhookSecret);\n  } catch (e) {\n    console.error(e);\n    return {\n      statusCode: 403,\n      body: 'Bad signature',\n    };\n  }\n\n  if (getHeader(event, 'content-type') !== 'application/json') {\n    console.error(`This webhook only accepts JSON payloads, got ${getHeader(event, 'content-type')}`);\n    return {\n      statusCode: 400,\n      body: 'Expecting JSON payload',\n    };\n  }\n\n  if (getHeader(event, 'x-github-event') === 'ping') {\n    return {\n      statusCode: 200,\n      body: 'Pong',\n    };\n  }\n\n  // if (getHeader(event, 'x-github-event') !== 'workflow_job' && getHeader(event, 'x-github-event') !== 'workflow_run') {\n  //     console.error(`This webhook only accepts workflow_job and workflow_run, got ${getHeader(event, 'x-github-event')}`);\n  if (getHeader(event, 'x-github-event') !== 'workflow_job') {\n    console.error(`This webhook only accepts workflow_job, got ${getHeader(event, 'x-github-event')}`);\n    return {\n      statusCode: 200,\n      body: 'Expecting workflow_job',\n    };\n  }\n\n  const payload = JSON.parse(body);\n\n  if (payload.action !== 'queued') {\n    console.log({\n      notice: `Ignoring action \"${payload.action}\", expecting \"queued\"`,\n      job: payload.workflow_job,\n    });\n    return {\n      statusCode: 200,\n      body: 'OK. No runner started (action is not \"queued\").',\n    };\n  }\n\n  if (process.env.REQUIRE_SELF_HOSTED_LABEL === '1' && !payload.workflow_job.labels.includes('self-hosted')) {\n    console.log({\n      notice: `Ignoring labels \"${payload.workflow_job.labels}\", expecting \"self-hosted\"`,\n      job: payload.workflow_job,\n    });\n    return {\n      statusCode: 200,\n      body: 'OK. No runner started (no \"self-hosted\" label).',\n    };\n  }\n\n  // don't start step function unless labels match a runner provider\n  const provider = matchLabelsToProvider(payload.workflow_job.labels);\n  if (!provider) {\n    console.log({\n      notice: `Ignoring labels \"${payload.workflow_job.labels}\", as they don't match a supported runner provider`,\n      job: payload.workflow_job,\n    });\n    return {\n      statusCode: 200,\n      body: 'OK. No runner started (no provider with matching labels).',\n    };\n  }\n\n  // don't start runners for a deployment that's still pending as GitHub will send another event when it's ready\n  if (await isDeploymentPending(payload)) {\n    console.log({\n      notice: 'Ignoring job as its deployment is still pending',\n      job: payload.workflow_job,\n    });\n    return {\n      statusCode: 200,\n      body: 'OK. No runner started (deployment pending).',\n    };\n  }\n\n  // start execution\n  const executionName = generateExecutionName(event, payload);\n  const input = {\n    owner: payload.repository.owner.login,\n    repo: payload.repository.name,\n    jobId: payload.workflow_job.id,\n    jobUrl: payload.workflow_job.html_url,\n    installationId: payload.installation?.id ?? -1, // always pass value because step function can't handle missing input\n    labels: payload.workflow_job.labels.join(','),\n    provider: provider,\n  };\n  const execution = await sf.send(new StartExecutionCommand({\n    stateMachineArn: process.env.STEP_FUNCTION_ARN,\n    input: JSON.stringify(input),\n    // name is not random so multiple execution of this webhook won't cause multiple builders to start\n    name: executionName,\n  }));\n\n  console.log({\n    notice: 'Started orchestrator',\n    execution: execution.executionArn,\n    sfnInput: input,\n    job: payload.workflow_job,\n  });\n\n  return {\n    statusCode: 202,\n    body: executionName,\n  };\n}\n"]}

package/lib/webhook-redelivery-function.d.ts

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

package/lib/webhook-redelivery-function.js

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

package/lib/webhook-redelivery.d.ts

@@ -0,0 +1,26 @@
+import { Construct } from 'constructs';
+import { Secrets } from './secrets';
+import { WebhookRedeliveryFunction } from './webhook-redelivery-function';
+/**
+ * Properties for GithubWebhookRedelivery
+ *
+ * @internal
+ */
+export interface GithubWebhookRedeliveryProps {
+    /**
+     * Secrets used to communicate with GitHub.
+     */
+    readonly secrets: Secrets;
+}
+/**
+ * Create a Lambda that runs every 5 minutes to check for Github webhook delivery failures and retry them.
+ *
+ * @internal
+ */
+export declare class GithubWebhookRedelivery extends Construct {
+    /**
+     * Webhook redelivery lambda function.
+     */
+    readonly handler: WebhookRedeliveryFunction;
+    constructor(scope: Construct, id: string, props: GithubWebhookRedeliveryProps);
+}

package/lib/webhook-redelivery.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GithubWebhookRedelivery = void 0;
+const cdk = require("aws-cdk-lib");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const constructs_1 = require("constructs");
+const utils_1 = require("./utils");
+const webhook_redelivery_function_1 = require("./webhook-redelivery-function");
+/**
+ * Create a Lambda that runs every 5 minutes to check for Github webhook delivery failures and retry them.
+ *
+ * @internal
+ */
+class GithubWebhookRedelivery extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.handler = new webhook_redelivery_function_1.WebhookRedeliveryFunction(this, 'Lambda', {
+            description: 'Check for GitHub webhook delivery failures and redeliver them',
+            environment: {
+                GITHUB_SECRET_ARN: props.secrets.github.secretArn,
+                GITHUB_PRIVATE_KEY_SECRET_ARN: props.secrets.githubPrivateKey.secretArn,
+            },
+            reservedConcurrentExecutions: 1, // avoid concurrent executions
+            timeout: cdk.Duration.seconds(4.5 * 60), // 4.5 minutes
+            logGroup: (0, utils_1.singletonLogGroup)(this, utils_1.SingletonLogType.ORCHESTRATOR),
+            loggingFormat: aws_cdk_lib_1.aws_lambda.LoggingFormat.JSON,
+            // applicationLogLevelV2: ApplicationLogLevel.DEBUG,
+        });
+        props.secrets.github.grantRead(this.handler);
+        props.secrets.githubPrivateKey.grantRead(this.handler);
+        new aws_cdk_lib_1.aws_events.Rule(this, 'Schedule', {
+            schedule: aws_cdk_lib_1.aws_events.Schedule.rate(cdk.Duration.minutes(5)),
+            description: 'Schedule to run the webhook redelivery lambda every 5 minutes',
+            targets: [
+                new aws_cdk_lib_1.aws_events_targets.LambdaFunction(this.handler, {
+                    retryAttempts: 0,
+                }),
+            ],
+        });
+    }
+}
+exports.GithubWebhookRedelivery = GithubWebhookRedelivery;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/webhook-redelivery.lambda.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Clear the cache of webhook delivery failures.
+ *
+ * For unit testing purposes only.
+ *
+ * @internal
+ */
+export declare function clearFailuresCache(): void;
+export declare function handler(): Promise<void>;

package/lib/webhook-redelivery.lambda.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearFailuresCache = clearFailuresCache;
+exports.handler = handler;
+const lambda_github_1 = require("./lambda-github");
+/**
+ * Get webhook delivery failures since the last processed delivery ID.
+ *
+ * @internal
+ */
+async function newDeliveryFailures(octokit, sinceId) {
+    const deliveries = new Map();
+    const successfulDeliveries = new Set();
+    const timeLimitMs = 1000 * 60 * 30; // don't look at deliveries over 30 minutes old
+    let lastId = 0;
+    let processedCount = 0;
+    for await (const response of octokit.paginate.iterator('GET /app/hook/deliveries')) {
+        if (response.status !== 200) {
+            throw new Error('Failed to fetch webhook deliveries');
+        }
+        for (const delivery of response.data) {
+            const deliveredAt = new Date(delivery.delivered_at);
+            const success = delivery.status === 'OK';
+            if (delivery.id <= sinceId) {
+                // stop processing if we reach the last processed delivery ID
+                console.info({
+                    notice: 'Reached last processed delivery ID',
+                    sinceId: sinceId,
+                    deliveryId: delivery.id,
+                    guid: delivery.guid,
+                    processedCount,
+                });
+                return { deliveries, lastId };
+            }
+            lastId = Math.max(lastId, delivery.id);
+            if (deliveredAt.getTime() < Date.now() - timeLimitMs) {
+                // stop processing if the delivery is too old (for first iteration and performance of further iterations)
+                console.info({
+                    notice: 'Stopping at old delivery',
+                    deliveryId: delivery.id,
+                    guid: delivery.guid,
+                    deliveredAt: deliveredAt,
+                    processedCount,
+                });
+                return { deliveries, lastId };
+            }
+            console.debug({
+                notice: 'Processing webhook delivery',
+                deliveryId: delivery.id,
+                guid: delivery.guid,
+                status: delivery.status,
+                deliveredAt: delivery.delivered_at,
+                redelivery: delivery.redelivery,
+            });
+            processedCount++;
+            if (success) {
+                successfulDeliveries.add(delivery.guid);
+                continue;
+            }
+            if (successfulDeliveries.has(delivery.guid)) {
+                // do not redeliver deliveries that were already successful
+                continue;
+            }
+            deliveries.set(delivery.guid, { id: delivery.id, deliveredAt, redelivery: delivery.redelivery });
+        }
+    }
+    console.info({
+        notice: 'No more webhook deliveries to process',
+        deliveryId: 'DONE',
+        guid: 'DONE',
+        deliveredAt: 'DONE',
+        processedCount,
+    });
+    return { deliveries, lastId };
+}
+let lastDeliveryIdProcessed = 0;
+const failures = new Map();
+/**
+ * Clear the cache of webhook delivery failures.
+ *
+ * For unit testing purposes only.
+ *
+ * @internal
+ */
+function clearFailuresCache() {
+    lastDeliveryIdProcessed = 0;
+    failures.clear();
+}
+async function handler() {
+    const octokit = await (0, lambda_github_1.getAppOctokit)();
+    if (!octokit) {
+        console.info({
+            notice: 'Skipping webhook redelivery',
+            reason: 'App installation might not be configured or the app is not installed.',
+        });
+        return;
+    }
+    // fetch deliveries since the last processed delivery ID
+    // for any failures:
+    //  1. if this is not a redelivery, save the delivery ID and time, and finally retry
+    //  2. if this is a redelivery, check if the original delivery is still within the time limit and retry if it is
+    const { deliveries, lastId } = await newDeliveryFailures(octokit, lastDeliveryIdProcessed);
+    lastDeliveryIdProcessed = Math.max(lastDeliveryIdProcessed, lastId);
+    const timeLimitMs = 1000 * 60 * 60 * 3; // retry for up to 3 hours
+    for (const [guid, details] of deliveries) {
+        if (!details.redelivery) {
+            failures.set(guid, { id: details.id, firstDeliveredAt: details.deliveredAt });
+            console.log({
+                notice: 'Redelivering failed delivery',
+                deliveryId: details.id,
+                guid: guid,
+                firstDeliveredAt: details.deliveredAt,
+            });
+            await (0, lambda_github_1.redeliver)(octokit, details.id);
+        }
+        else {
+            // if this is a redelivery, check if the original delivery is still within the time limit
+            const originalFailure = failures.get(guid);
+            if (originalFailure) {
+                if (new Date().getTime() - originalFailure.firstDeliveredAt.getTime() < timeLimitMs) {
+                    console.log({
+                        notice: 'Redelivering failed delivery',
+                        deliveryId: details.id,
+                        guid: guid,
+                        firstDeliveredAt: originalFailure.firstDeliveredAt,
+                    });
+                    await (0, lambda_github_1.redeliver)(octokit, details.id);
+                }
+                else {
+                    failures.delete(guid); // no need to keep track of this anymore
+                    console.log({
+                        notice: 'Skipping redelivery of old failed delivery',
+                        deliveryId: details.id,
+                        guid: guid,
+                        firstDeliveredAt: originalFailure?.firstDeliveredAt,
+                    });
+                }
+            }
+            else {
+                console.log({
+                    notice: 'Skipping redelivery of old failed delivery',
+                    deliveryId: details.id,
+                    guid: guid,
+                });
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webhook-redelivery.lambda.js","sourceRoot":"","sources":["../src/webhook-redelivery.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["import { Octokit } from '@octokit/rest';\nimport { getAppOctokit, redeliver } from './lambda-github';\n\n/**\n * Get webhook delivery failures since the last processed delivery ID.\n *\n * @internal\n */\nasync function newDeliveryFailures(octokit: Octokit, sinceId: number) {\n  const deliveries: Map<string, { id: number; deliveredAt: Date; redelivery: boolean }> = new Map();\n  const successfulDeliveries: Set<string> = new Set();\n  const timeLimitMs = 1000 * 60 * 30; // don't look at deliveries over 30 minutes old\n  let lastId = 0;\n  let processedCount = 0;\n\n  for await (const response of octokit.paginate.iterator('GET /app/hook/deliveries')) {\n    if (response.status !== 200) {\n      throw new Error('Failed to fetch webhook deliveries');\n    }\n\n    for (const delivery of response.data) {\n      const deliveredAt = new Date(delivery.delivered_at);\n      const success = delivery.status === 'OK';\n\n      if (delivery.id <= sinceId) {\n        // stop processing if we reach the last processed delivery ID\n        console.info({\n          notice: 'Reached last processed delivery ID',\n          sinceId: sinceId,\n          deliveryId: delivery.id,\n          guid: delivery.guid,\n          processedCount,\n        });\n        return { deliveries, lastId };\n      }\n\n      lastId = Math.max(lastId, delivery.id);\n\n      if (deliveredAt.getTime() < Date.now() - timeLimitMs) {\n        // stop processing if the delivery is too old (for first iteration and performance of further iterations)\n        console.info({\n          notice: 'Stopping at old delivery',\n          deliveryId: delivery.id,\n          guid: delivery.guid,\n          deliveredAt: deliveredAt,\n          processedCount,\n        });\n        return { deliveries, lastId };\n      }\n\n      console.debug({\n        notice: 'Processing webhook delivery',\n        deliveryId: delivery.id,\n        guid: delivery.guid,\n        status: delivery.status,\n        deliveredAt: delivery.delivered_at,\n        redelivery: delivery.redelivery,\n      });\n      processedCount++;\n\n      if (success) {\n        successfulDeliveries.add(delivery.guid);\n        continue;\n      }\n\n      if (successfulDeliveries.has(delivery.guid)) {\n        // do not redeliver deliveries that were already successful\n        continue;\n      }\n\n      deliveries.set(delivery.guid, { id: delivery.id, deliveredAt, redelivery: delivery.redelivery });\n    }\n  }\n\n  console.info({\n    notice: 'No more webhook deliveries to process',\n    deliveryId: 'DONE',\n    guid: 'DONE',\n    deliveredAt: 'DONE',\n    processedCount,\n  });\n\n  return { deliveries, lastId };\n}\n\nlet lastDeliveryIdProcessed = 0;\nconst failures: Map<string, { id: number; firstDeliveredAt: Date }> = new Map();\n\n/**\n * Clear the cache of webhook delivery failures.\n *\n * For unit testing purposes only.\n *\n * @internal\n */\nexport function clearFailuresCache() {\n  lastDeliveryIdProcessed = 0;\n  failures.clear();\n}\n\nexport async function handler() {\n  const octokit = await getAppOctokit();\n  if (!octokit) {\n    console.info({\n      notice: 'Skipping webhook redelivery',\n      reason: 'App installation might not be configured or the app is not installed.',\n    });\n    return;\n  }\n\n  // fetch deliveries since the last processed delivery ID\n  // for any failures:\n  //  1. if this is not a redelivery, save the delivery ID and time, and finally retry\n  //  2. if this is a redelivery, check if the original delivery is still within the time limit and retry if it is\n  const { deliveries, lastId } = await newDeliveryFailures(octokit, lastDeliveryIdProcessed);\n  lastDeliveryIdProcessed = Math.max(lastDeliveryIdProcessed, lastId);\n  const timeLimitMs = 1000 * 60 * 60 * 3; // retry for up to 3 hours\n  for (const [guid, details] of deliveries) {\n    if (!details.redelivery) {\n      failures.set(guid, { id: details.id, firstDeliveredAt: details.deliveredAt });\n      console.log({\n        notice: 'Redelivering failed delivery',\n        deliveryId: details.id,\n        guid: guid,\n        firstDeliveredAt: details.deliveredAt,\n      });\n      await redeliver(octokit, details.id);\n    } else {\n      // if this is a redelivery, check if the original delivery is still within the time limit\n      const originalFailure = failures.get(guid);\n      if (originalFailure) {\n        if (new Date().getTime() - originalFailure.firstDeliveredAt.getTime() < timeLimitMs) {\n          console.log({\n            notice: 'Redelivering failed delivery',\n            deliveryId: details.id,\n            guid: guid,\n            firstDeliveredAt: originalFailure.firstDeliveredAt,\n          });\n          await redeliver(octokit, details.id);\n        } else {\n          failures.delete(guid); // no need to keep track of this anymore\n          console.log({\n            notice: 'Skipping redelivery of old failed delivery',\n            deliveryId: details.id,\n            guid: guid,\n            firstDeliveredAt: originalFailure?.firstDeliveredAt,\n          });\n        }\n      } else {\n        console.log({\n          notice: 'Skipping redelivery of old failed delivery',\n          deliveryId: details.id,\n          guid: guid,\n        });\n      }\n    }\n  }\n}\n"]}

package/package.json

@@ -33,6 +33,8 @@
     "bundle:token-retriever.lambda:watch": "npx projen bundle:token-retriever.lambda:watch",
     "bundle:webhook-handler.lambda": "npx projen bundle:webhook-handler.lambda",
     "bundle:webhook-handler.lambda:watch": "npx projen bundle:webhook-handler.lambda:watch",
+    "bundle:webhook-redelivery.lambda": "npx projen bundle:webhook-redelivery.lambda",
+    "bundle:webhook-redelivery.lambda:watch": "npx projen bundle:webhook-redelivery.lambda:watch",
     "clobber": "npx projen clobber",
     "compat": "npx projen compat",
     "compile": "npx projen compile",
@@ -70,16 +72,16 @@
     "organization": false
   },
   "devDependencies": {
-    "@aws-sdk/client-cloudformation": "^3.839.0",
-    "@aws-sdk/client-codebuild": "^3.839.0",
-    "@aws-sdk/client-ec2": "^3.839.0",
-    "@aws-sdk/client-ecr": "^3.839.0",
-    "@aws-sdk/client-imagebuilder": "^3.839.0",
-    "@aws-sdk/client-lambda": "^3.839.0",
-    "@aws-sdk/client-secrets-manager": "^3.839.0",
-    "@aws-sdk/client-sfn": "^3.839.0",
-    "@aws-sdk/client-sns": "^3.839.0",
-    "@aws-sdk/client-ssm": "^3.839.0",
+    "@aws-sdk/client-cloudformation": "^3.848.0",
+    "@aws-sdk/client-codebuild": "^3.848.0",
+    "@aws-sdk/client-ec2": "^3.848.0",
+    "@aws-sdk/client-ecr": "^3.848.0",
+    "@aws-sdk/client-imagebuilder": "^3.848.0",
+    "@aws-sdk/client-lambda": "^3.848.0",
+    "@aws-sdk/client-secrets-manager": "^3.848.0",
+    "@aws-sdk/client-sfn": "^3.848.0",
+    "@aws-sdk/client-sns": "^3.848.0",
+    "@aws-sdk/client-ssm": "^3.849.0",
     "@octokit/auth-app": "^4.0.13",
     "@octokit/core": "^4.2.4",
     "@octokit/request-error": "^3.0.3",
@@ -87,7 +89,7 @@
     "@stylistic/eslint-plugin": "^2",
     "@sveltejs/vite-plugin-svelte": "^4",
     "@tsconfig/svelte": "^5",
-    "@types/aws-lambda": "^8.10.150",
+    "@types/aws-lambda": "^8.10.152",
     "@types/jest": "^29",
     "@types/node": "ts5.6",
     "@types/semver": "^7.7.0",
@@ -98,7 +100,7 @@
     "bootstrap": "^5.2.0",
     "commit-and-tag-version": "^12",
     "constructs": "10.0.5",
-    "esbuild": "^0.25.5",
+    "esbuild": "^0.25.8",
     "eslint": "^9",
     "eslint-import-resolver-typescript": "^2.7.1",
     "eslint-plugin-import": "^2.32.0",
@@ -110,7 +112,7 @@
     "jsii-docgen": "^10.5.0",
     "jsii-pacmak": "^1.112.0",
     "jsii-rosetta": "5.8.x",
-    "projen": "^0.94.0",
+    "projen": "^0.94.2",
     "sass": "^1.54.0",
     "semver": "^7.7.2",
     "svelte": "^5",
@@ -143,7 +145,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.14.9",
+  "version": "0.14.11",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [