@cloudsnorkel/cdk-github-runners 0.14.24 → 0.15.0

package/lib/warm-runner.d.ts

@@ -0,0 +1,147 @@
+import * as cdk from 'aws-cdk-lib';
+import { aws_events as events } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { ICompositeProvider, IRunnerProvider } from './providers';
+import { GitHubRunners } from './runner';
+import { WarmRunnerFillPayload } from './warm-runner-manager.lambda';
+/**
+ * Common properties for warm runner constructs.
+ *
+ * @internal
+ */
+export interface WarmRunnerBaseProps {
+    /**
+     * The GitHubRunners construct that owns the shared warm runner infrastructure.
+     */
+    readonly runners: GitHubRunners;
+    /**
+     * Provider to use. Warm runners bypass the provider selector — they always use
+     * this provider, regardless of job characteristics. Labels cannot be modified.
+     */
+    readonly provider: IRunnerProvider | ICompositeProvider;
+    /**
+     * Number of warm runners to maintain.
+     */
+    readonly count: number;
+    /**
+     * GitHub owner where runners will be registered (org or user login).
+     */
+    readonly owner: string;
+    /**
+     * Registration level — must match how your runners are set up in GitHub. Choose
+     * 'org' for org-wide runners, 'repo' for repo-level. See the setup wizard or
+     * {@link SETUP_GITHUB.md} for choosing repo vs org.
+     *
+     * @default 'repo'
+     */
+    readonly registrationLevel?: 'org' | 'repo';
+    /**
+     * Repository name (without owner) where runners will be registered. Required when `registrationLevel` is 'repo'.
+     */
+    readonly repo?: string;
+}
+/**
+ * Properties for always on warm runners.
+ */
+export interface AlwaysOnWarmRunnerProps extends WarmRunnerBaseProps {
+}
+/**
+ * Properties for scheduled warm runners.
+ */
+export interface ScheduledWarmRunnerProps extends WarmRunnerBaseProps {
+    /**
+     * When to start filling the pool (e.g. start of business hours).
+     */
+    readonly schedule: events.Schedule;
+    /**
+     * How long the warm runners should be maintained from the fill time (schedule). Defines the end of the
+     * window (schedule time + duration).
+     */
+    readonly duration: cdk.Duration;
+}
+/**
+ * Warm runners that run 24/7. Fills at midnight UTC and each runner stays alive for 24 hours.
+ *
+ * Runners will be provisioned using the specified provider and registered in the specified repository or organization.
+ *
+ * Registration level must match the one selected during setup. See {@link SETUP_GITHUB.md} for more information on the selection.
+ *
+ * ## Limitations
+ *
+ * - Jobs will still trigger provisioning of on-demand runners, even if a warm runner ends up being used.
+ * - You may briefly see more than `count` runners when changing config or at rotation.
+ * - To remove: set `count` to 0, deploy, wait for warm runners to stop, then remove and deploy again.
+ *   If you don't follow this procedure, warm runners may linger until they expire.
+ * - Provider failures or timeouts (like Lambda provider timing out after 15 minutes) will result in a
+ *   gap in coverage until the retry succeeds. Current retry mechanism has built-in back-off rate and
+ *   can be tweaked using `retryOptions`. This will be improved in the future.
+ *
+ * @example
+ * new AlwaysOnWarmRunner(stack, 'AlwaysOnLinux', {
+ *   runners,
+ *   provider: myProvider,
+ *   count: 3,
+ *   owner: 'my-org',
+ *   repo: 'my-repo',
+ * });
+ */
+export declare class AlwaysOnWarmRunner extends Construct {
+    /**
+     * The fill payload for this warm runner configuration.
+     * @internal
+     */
+    readonly _fillPayload: WarmRunnerFillPayload;
+    constructor(scope: Construct, id: string, props: AlwaysOnWarmRunnerProps);
+}
+/**
+ * Warm runners active during a time window specified by start time (`schedule`) and duration (`duration`).
+ *
+ * Runners will be provisioned using the specified provider and registered in the specified repository or organization.
+ *
+ * Registration level must match the one selected during setup. See {@link SETUP_GITHUB.md} for more information on the selection.
+ *
+ * ## Limitations
+ *
+ * - **No deployment-fill**: Unlike `AlwaysOnWarmRunner`, scheduled warm runners do not get an initial
+ *   fill on deploy. The first fill happens at the next schedule occurrence. If you deploy at 1pm for
+ *   a 2pm schedule, runners will not appear until 2pm.
+ * - Jobs will still trigger provisioning of on-demand runners, even if a warm runner ends up being used.
+ * - You may briefly see more than `count` runners when changing config or at rotation.
+ * - To remove: set `count` to 0, deploy, wait for warm runners to stop, then remove and deploy again.
+ *   If you don't follow this procedure, warm runners may linger until they expire.
+ * - Provider failures or timeouts (like Lambda provider timing out after 15 minutes) will result in a
+ *   gap in coverage until the retry succeeds. Current retry mechanism has built-in back-off rate and
+ *   can be tweaked using `retryOptions`. This will be improved in the future.
+ *
+ * @example
+ * // Cron: fill at 1pm on weekdays
+ * new ScheduledWarmRunner(stack, 'Business Hours', {
+ *   runners,
+ *   provider: myProvider,
+ *   count: 3,
+ *   owner: 'my-org',
+ *   repo: 'my-repo',
+ *   schedule: events.Schedule.cron({ hour: '13', minute: '0', weekDay: 'MON-FRI' }),
+ *   duration: cdk.Duration.hours(2),
+ * });
+ *
+ * @example
+ * // Rate: fill every 12 hours
+ * new ScheduledWarmRunner(stack, 'Every 12 Hours', {
+ *   runners,
+ *   provider: myProvider,
+ *   count: 2,
+ *   owner: 'my-org',
+ *   repo: 'my-repo',
+ *   schedule: events.Schedule.rate(cdk.Duration.hours(5)),
+ *   duration: cdk.Duration.hours(12),
+ * });
+ */
+export declare class ScheduledWarmRunner extends Construct {
+    /**
+     * The fill payload for this warm runner configuration.
+     * @internal
+     */
+    readonly _fillPayload: WarmRunnerFillPayload;
+    constructor(scope: Construct, id: string, props: ScheduledWarmRunnerProps);
+}

package/lib/warm-runner.js

@@ -0,0 +1,210 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduledWarmRunner = exports.AlwaysOnWarmRunner = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const crypto = require("crypto");
+const cdk = require("aws-cdk-lib");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const constructs_1 = require("constructs");
+const cron_parser_1 = require("cron-parser");
+function buildWarmRunner(scope, props, schedule, duration, createInitialFill) {
+    const registrationLevel = props.registrationLevel ?? 'repo';
+    if (registrationLevel === 'org' && props.repo) {
+        throw new Error('Do not specify repo when registrationLevel is \'org\'');
+    }
+    if (registrationLevel === 'repo' && !props.repo) {
+        throw new Error('repo is required when registrationLevel is \'repo\'');
+    }
+    const providerPath = props.provider.node.path;
+    if (!props.runners.providers.some(p => p.node.path === providerPath)) {
+        throw new Error(`Provider ${providerPath} is not in the providers list of the GitHubRunners construct`);
+    }
+    const labels = props.provider.labels;
+    const repo = registrationLevel === 'repo' ? props.repo : '';
+    const configHash = crypto.createHash('sha256')
+        .update(JSON.stringify({ providerPath, providerLabels: labels, count: props.count, duration, owner: props.owner, repo }))
+        .digest('hex')
+        .slice(0, 16);
+    const fillPayload = {
+        action: 'fill',
+        providerPath,
+        providerLabels: labels,
+        count: props.count,
+        duration,
+        owner: props.owner,
+        repo,
+        configHash,
+    };
+    const { lambda: managerFn, queue } = props.runners._ensureWarmRunnerInfra();
+    props.runners._registerWarmConfigHash(configHash);
+    // Schedule to fill the warm pool (usually daily). Sends to SQS so we get stable messageId for idempotent fills.
+    new aws_cdk_lib_1.aws_events.Rule(scope, 'Schedule', {
+        schedule,
+        targets: [new aws_cdk_lib_1.aws_events_targets.SqsQueue(queue, {
+                message: aws_cdk_lib_1.aws_events.RuleTargetInput.fromObject(fillPayload),
+            })],
+    });
+    // Fill the warm pool immediately on deploy (AlwaysOnWarmRunner only).
+    // ScheduledWarmRunner does not get deployment-fill. First fill happens at the next schedule fire.
+    if (createInitialFill) {
+        new cdk.CustomResource(scope, 'Initial Fill', {
+            serviceToken: managerFn.functionArn,
+            resourceType: 'Custom::WarmRunnerFill',
+            properties: fillPayload,
+        });
+    }
+    return fillPayload;
+}
+/**
+ * Warm runners that run 24/7. Fills at midnight UTC and each runner stays alive for 24 hours.
+ *
+ * Runners will be provisioned using the specified provider and registered in the specified repository or organization.
+ *
+ * Registration level must match the one selected during setup. See {@link SETUP_GITHUB.md} for more information on the selection.
+ *
+ * ## Limitations
+ *
+ * - Jobs will still trigger provisioning of on-demand runners, even if a warm runner ends up being used.
+ * - You may briefly see more than `count` runners when changing config or at rotation.
+ * - To remove: set `count` to 0, deploy, wait for warm runners to stop, then remove and deploy again.
+ *   If you don't follow this procedure, warm runners may linger until they expire.
+ * - Provider failures or timeouts (like Lambda provider timing out after 15 minutes) will result in a
+ *   gap in coverage until the retry succeeds. Current retry mechanism has built-in back-off rate and
+ *   can be tweaked using `retryOptions`. This will be improved in the future.
+ *
+ * @example
+ * new AlwaysOnWarmRunner(stack, 'AlwaysOnLinux', {
+ *   runners,
+ *   provider: myProvider,
+ *   count: 3,
+ *   owner: 'my-org',
+ *   repo: 'my-repo',
+ * });
+ */
+class AlwaysOnWarmRunner extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this._fillPayload = buildWarmRunner(this, props, aws_cdk_lib_1.aws_events.Schedule.cron({ hour: '0', minute: '0' }), cdk.Duration.days(1).toSeconds(), true);
+    }
+}
+exports.AlwaysOnWarmRunner = AlwaysOnWarmRunner;
+_a = JSII_RTTI_SYMBOL_1;
+AlwaysOnWarmRunner[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.AlwaysOnWarmRunner", version: "0.15.0" };
+/**
+ * Convert AWS EventBridge cron format to cron-parser format.
+ * AWS: cron(min hour dom month dow year), cron-parser: sec min hour dom month dow
+ */
+function awsCronToParserFormat(expressionString) {
+    const match = expressionString.match(/^cron\((.+)\)$/);
+    if (!match)
+        return expressionString;
+    const [, inner] = match;
+    const parts = inner.trim().split(/\s+/);
+    if (parts.length !== 6)
+        return expressionString;
+    const [minute, hour, dom, month, dow] = parts;
+    return `0 ${minute} ${hour} ${dom} ${month} ${dow}`;
+}
+/**
+ * Parse AWS EventBridge rate expression and return interval in seconds.
+ * Format: rate(value unit) e.g. rate(2 hours), rate(5 minutes), rate(1 day)
+ */
+function parseRateInterval(expressionString) {
+    const match = expressionString.match(/^rate\((\d+)\s+(minute|minutes|hour|hours|day|days)\)$/i);
+    if (!match)
+        return undefined;
+    const value = parseInt(match[1], 10);
+    const unit = match[2].toLowerCase();
+    if (value <= 0)
+        return undefined;
+    const secondsPerUnit = {
+        minute: 60,
+        minutes: 60,
+        hour: 3600,
+        hours: 3600,
+        day: 86400,
+        days: 86400,
+    };
+    return value * secondsPerUnit[unit];
+}
+/**
+ * Get the interval between schedule occurrences in seconds.
+ * Supports both cron and rate expressions.
+ */
+function getScheduleIntervalSeconds(expressionString) {
+    const rateInterval = parseRateInterval(expressionString);
+    if (rateInterval !== undefined)
+        return rateInterval;
+    try {
+        const cronExpression = cron_parser_1.CronExpressionParser.parse(awsCronToParserFormat(expressionString));
+        const next = cronExpression.take(2);
+        return (next[1].getTime() - next[0].getTime()) / 1000;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Warm runners active during a time window specified by start time (`schedule`) and duration (`duration`).
+ *
+ * Runners will be provisioned using the specified provider and registered in the specified repository or organization.
+ *
+ * Registration level must match the one selected during setup. See {@link SETUP_GITHUB.md} for more information on the selection.
+ *
+ * ## Limitations
+ *
+ * - **No deployment-fill**: Unlike `AlwaysOnWarmRunner`, scheduled warm runners do not get an initial
+ *   fill on deploy. The first fill happens at the next schedule occurrence. If you deploy at 1pm for
+ *   a 2pm schedule, runners will not appear until 2pm.
+ * - Jobs will still trigger provisioning of on-demand runners, even if a warm runner ends up being used.
+ * - You may briefly see more than `count` runners when changing config or at rotation.
+ * - To remove: set `count` to 0, deploy, wait for warm runners to stop, then remove and deploy again.
+ *   If you don't follow this procedure, warm runners may linger until they expire.
+ * - Provider failures or timeouts (like Lambda provider timing out after 15 minutes) will result in a
+ *   gap in coverage until the retry succeeds. Current retry mechanism has built-in back-off rate and
+ *   can be tweaked using `retryOptions`. This will be improved in the future.
+ *
+ * @example
+ * // Cron: fill at 1pm on weekdays
+ * new ScheduledWarmRunner(stack, 'Business Hours', {
+ *   runners,
+ *   provider: myProvider,
+ *   count: 3,
+ *   owner: 'my-org',
+ *   repo: 'my-repo',
+ *   schedule: events.Schedule.cron({ hour: '13', minute: '0', weekDay: 'MON-FRI' }),
+ *   duration: cdk.Duration.hours(2),
+ * });
+ *
+ * @example
+ * // Rate: fill every 12 hours
+ * new ScheduledWarmRunner(stack, 'Every 12 Hours', {
+ *   runners,
+ *   provider: myProvider,
+ *   count: 2,
+ *   owner: 'my-org',
+ *   repo: 'my-repo',
+ *   schedule: events.Schedule.rate(cdk.Duration.hours(5)),
+ *   duration: cdk.Duration.hours(12),
+ * });
+ */
+class ScheduledWarmRunner extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        // make sure the duration is not longer than the interval between next two schedule occurrences
+        const interval = getScheduleIntervalSeconds(props.schedule.expressionString);
+        if (interval !== undefined && interval < props.duration.toSeconds()) {
+            cdk.Annotations.of(this).addError(`ScheduledWarmRunner duration ${props.duration.toHumanString()} is longer than the interval ${cdk.Duration.seconds(interval).toHumanString()} between next two schedule occurrences. This will result in overlapping warm runners at the start of the next schedule occurrence.`);
+        }
+        // warn for short interval
+        if (interval !== undefined && interval < cdk.Duration.hours(1).toSeconds()) {
+            cdk.Annotations.of(this).addWarningV2('@cloudsnorkel/cdk-github-runners:ScheduledWarmRunner.intervalTooShort', `ScheduledWarmRunner interval ${cdk.Duration.seconds(interval).toHumanString()} is less than 1 hour, which may result in more warm runners than expected`);
+        }
+        this._fillPayload = buildWarmRunner(this, props, props.schedule, props.duration.toSeconds(), false);
+    }
+}
+exports.ScheduledWarmRunner = ScheduledWarmRunner;
+_b = JSII_RTTI_SYMBOL_1;
+ScheduledWarmRunner[_b] = { fqn: "@cloudsnorkel/cdk-github-runners.ScheduledWarmRunner", version: "0.15.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"warm-runner.js","sourceRoot":"","sources":["../src/warm-runner.ts"],"names":[],"mappings":"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","sourcesContent":["import * as crypto from 'crypto';\nimport * as cdk from 'aws-cdk-lib';\nimport {\n  aws_events as events,\n  aws_events_targets as events_targets,\n} from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { CronExpressionParser } from 'cron-parser';\nimport { ICompositeProvider, IRunnerProvider } from './providers';\nimport { GitHubRunners } from './runner';\nimport { WarmRunnerFillPayload } from './warm-runner-manager.lambda';\n\n/**\n * Common properties for warm runner constructs.\n *\n * @internal\n */\nexport interface WarmRunnerBaseProps {\n  /**\n   * The GitHubRunners construct that owns the shared warm runner infrastructure.\n   */\n  readonly runners: GitHubRunners;\n\n  /**\n   * Provider to use. Warm runners bypass the provider selector — they always use\n   * this provider, regardless of job characteristics. Labels cannot be modified.\n   */\n  readonly provider: IRunnerProvider | ICompositeProvider;\n\n  /**\n   * Number of warm runners to maintain.\n   */\n  readonly count: number;\n\n  /**\n   * GitHub owner where runners will be registered (org or user login).\n   */\n  readonly owner: string;\n\n  /**\n   * Registration level — must match how your runners are set up in GitHub. Choose\n   * 'org' for org-wide runners, 'repo' for repo-level. See the setup wizard or\n   * {@link SETUP_GITHUB.md} for choosing repo vs org.\n   *\n   * @default 'repo'\n   */\n  readonly registrationLevel?: 'org' | 'repo';\n\n  /**\n   * Repository name (without owner) where runners will be registered. Required when `registrationLevel` is 'repo'.\n   */\n  readonly repo?: string;\n}\n\n/**\n * Properties for always on warm runners.\n */\nexport interface AlwaysOnWarmRunnerProps extends WarmRunnerBaseProps { }\n\n/**\n * Properties for scheduled warm runners.\n */\nexport interface ScheduledWarmRunnerProps extends WarmRunnerBaseProps {\n  /**\n   * When to start filling the pool (e.g. start of business hours).\n   */\n  readonly schedule: events.Schedule;\n\n  /**\n   * How long the warm runners should be maintained from the fill time (schedule). Defines the end of the\n   * window (schedule time + duration).\n   */\n  readonly duration: cdk.Duration;\n}\n\nfunction buildWarmRunner(scope: Construct, props: WarmRunnerBaseProps, schedule: events.Schedule, duration: number, createInitialFill: boolean) {\n  const registrationLevel = props.registrationLevel ?? 'repo';\n  if (registrationLevel === 'org' && props.repo) {\n    throw new Error('Do not specify repo when registrationLevel is \\'org\\'');\n  }\n  if (registrationLevel === 'repo' && !props.repo) {\n    throw new Error('repo is required when registrationLevel is \\'repo\\'');\n  }\n\n  const providerPath = props.provider.node.path;\n  if (!props.runners.providers.some(p => p.node.path === providerPath)) {\n    throw new Error(`Provider ${providerPath} is not in the providers list of the GitHubRunners construct`);\n  }\n\n  const labels = props.provider.labels;\n\n  const repo = registrationLevel === 'repo' ? props.repo! : '';\n  const configHash = crypto.createHash('sha256')\n    .update(JSON.stringify({ providerPath, providerLabels: labels, count: props.count, duration, owner: props.owner, repo }))\n    .digest('hex')\n    .slice(0, 16);\n\n  const fillPayload: WarmRunnerFillPayload = {\n    action: 'fill' as const,\n    providerPath,\n    providerLabels: labels,\n    count: props.count,\n    duration,\n    owner: props.owner,\n    repo,\n    configHash,\n  };\n\n  const { lambda: managerFn, queue } = props.runners._ensureWarmRunnerInfra();\n  props.runners._registerWarmConfigHash(configHash);\n\n  // Schedule to fill the warm pool (usually daily). Sends to SQS so we get stable messageId for idempotent fills.\n  new events.Rule(scope, 'Schedule', {\n    schedule,\n    targets: [new events_targets.SqsQueue(queue, {\n      message: events.RuleTargetInput.fromObject(fillPayload),\n    })],\n  });\n\n  // Fill the warm pool immediately on deploy (AlwaysOnWarmRunner only).\n  // ScheduledWarmRunner does not get deployment-fill. First fill happens at the next schedule fire.\n  if (createInitialFill) {\n    new cdk.CustomResource(scope, 'Initial Fill', {\n      serviceToken: managerFn.functionArn,\n      resourceType: 'Custom::WarmRunnerFill',\n      properties: fillPayload,\n    });\n  }\n\n  return fillPayload;\n}\n\n/**\n * Warm runners that run 24/7. Fills at midnight UTC and each runner stays alive for 24 hours.\n *\n * Runners will be provisioned using the specified provider and registered in the specified repository or organization.\n *\n * Registration level must match the one selected during setup. See {@link SETUP_GITHUB.md} for more information on the selection.\n *\n * ## Limitations\n *\n * - Jobs will still trigger provisioning of on-demand runners, even if a warm runner ends up being used.\n * - You may briefly see more than `count` runners when changing config or at rotation.\n * - To remove: set `count` to 0, deploy, wait for warm runners to stop, then remove and deploy again.\n *   If you don't follow this procedure, warm runners may linger until they expire.\n * - Provider failures or timeouts (like Lambda provider timing out after 15 minutes) will result in a\n *   gap in coverage until the retry succeeds. Current retry mechanism has built-in back-off rate and\n *   can be tweaked using `retryOptions`. This will be improved in the future.\n *\n * @example\n * new AlwaysOnWarmRunner(stack, 'AlwaysOnLinux', {\n *   runners,\n *   provider: myProvider,\n *   count: 3,\n *   owner: 'my-org',\n *   repo: 'my-repo',\n * });\n */\nexport class AlwaysOnWarmRunner extends Construct {\n  /**\n   * The fill payload for this warm runner configuration.\n   * @internal\n   */\n  public readonly _fillPayload: WarmRunnerFillPayload;\n\n  constructor(scope: Construct, id: string, props: AlwaysOnWarmRunnerProps) {\n    super(scope, id);\n    this._fillPayload = buildWarmRunner(this, props, events.Schedule.cron({ hour: '0', minute: '0' }), cdk.Duration.days(1).toSeconds(), true);\n  }\n}\n\n/**\n * Convert AWS EventBridge cron format to cron-parser format.\n * AWS: cron(min hour dom month dow year), cron-parser: sec min hour dom month dow\n */\nfunction awsCronToParserFormat(expressionString: string): string {\n  const match = expressionString.match(/^cron\\((.+)\\)$/);\n  if (!match) return expressionString;\n  const [, inner] = match;\n  const parts = inner.trim().split(/\\s+/);\n  if (parts.length !== 6) return expressionString;\n  const [minute, hour, dom, month, dow] = parts;\n  return `0 ${minute} ${hour} ${dom} ${month} ${dow}`;\n}\n\n/**\n * Parse AWS EventBridge rate expression and return interval in seconds.\n * Format: rate(value unit) e.g. rate(2 hours), rate(5 minutes), rate(1 day)\n */\nfunction parseRateInterval(expressionString: string): number | undefined {\n  const match = expressionString.match(/^rate\\((\\d+)\\s+(minute|minutes|hour|hours|day|days)\\)$/i);\n  if (!match) return undefined;\n  const value = parseInt(match[1], 10);\n  const unit = match[2].toLowerCase();\n  if (value <= 0) return undefined;\n  const secondsPerUnit: Record<string, number> = {\n    minute: 60,\n    minutes: 60,\n    hour: 3600,\n    hours: 3600,\n    day: 86400,\n    days: 86400,\n  };\n  return value * secondsPerUnit[unit];\n}\n\n/**\n * Get the interval between schedule occurrences in seconds.\n * Supports both cron and rate expressions.\n */\nfunction getScheduleIntervalSeconds(expressionString: string): number | undefined {\n  const rateInterval = parseRateInterval(expressionString);\n  if (rateInterval !== undefined) return rateInterval;\n\n  try {\n    const cronExpression = CronExpressionParser.parse(awsCronToParserFormat(expressionString));\n    const next = cronExpression.take(2);\n    return (next[1].getTime() - next[0].getTime()) / 1000;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Warm runners active during a time window specified by start time (`schedule`) and duration (`duration`).\n *\n * Runners will be provisioned using the specified provider and registered in the specified repository or organization.\n *\n * Registration level must match the one selected during setup. See {@link SETUP_GITHUB.md} for more information on the selection.\n *\n * ## Limitations\n *\n * - **No deployment-fill**: Unlike `AlwaysOnWarmRunner`, scheduled warm runners do not get an initial\n *   fill on deploy. The first fill happens at the next schedule occurrence. If you deploy at 1pm for\n *   a 2pm schedule, runners will not appear until 2pm.\n * - Jobs will still trigger provisioning of on-demand runners, even if a warm runner ends up being used.\n * - You may briefly see more than `count` runners when changing config or at rotation.\n * - To remove: set `count` to 0, deploy, wait for warm runners to stop, then remove and deploy again.\n *   If you don't follow this procedure, warm runners may linger until they expire.\n * - Provider failures or timeouts (like Lambda provider timing out after 15 minutes) will result in a\n *   gap in coverage until the retry succeeds. Current retry mechanism has built-in back-off rate and\n *   can be tweaked using `retryOptions`. This will be improved in the future.\n *\n * @example\n * // Cron: fill at 1pm on weekdays\n * new ScheduledWarmRunner(stack, 'Business Hours', {\n *   runners,\n *   provider: myProvider,\n *   count: 3,\n *   owner: 'my-org',\n *   repo: 'my-repo',\n *   schedule: events.Schedule.cron({ hour: '13', minute: '0', weekDay: 'MON-FRI' }),\n *   duration: cdk.Duration.hours(2),\n * });\n *\n * @example\n * // Rate: fill every 12 hours\n * new ScheduledWarmRunner(stack, 'Every 12 Hours', {\n *   runners,\n *   provider: myProvider,\n *   count: 2,\n *   owner: 'my-org',\n *   repo: 'my-repo',\n *   schedule: events.Schedule.rate(cdk.Duration.hours(5)),\n *   duration: cdk.Duration.hours(12),\n * });\n */\nexport class ScheduledWarmRunner extends Construct {\n  /**\n   * The fill payload for this warm runner configuration.\n   * @internal\n   */\n  public readonly _fillPayload: WarmRunnerFillPayload;\n\n  constructor(scope: Construct, id: string, props: ScheduledWarmRunnerProps) {\n    super(scope, id);\n\n    // make sure the duration is not longer than the interval between next two schedule occurrences\n    const interval = getScheduleIntervalSeconds(props.schedule.expressionString);\n    if (interval !== undefined && interval < props.duration.toSeconds()) {\n      cdk.Annotations.of(this).addError(`ScheduledWarmRunner duration ${props.duration.toHumanString()} is longer than the interval ${cdk.Duration.seconds(interval).toHumanString()} between next two schedule occurrences. This will result in overlapping warm runners at the start of the next schedule occurrence.`);\n    }\n\n    // warn for short interval\n    if (interval !== undefined && interval < cdk.Duration.hours(1).toSeconds()) {\n      cdk.Annotations.of(this).addWarningV2(\n        '@cloudsnorkel/cdk-github-runners:ScheduledWarmRunner.intervalTooShort',\n        `ScheduledWarmRunner interval ${cdk.Duration.seconds(interval).toHumanString()} is less than 1 hour, which may result in more warm runners than expected`,\n      );\n    }\n\n    this._fillPayload = buildWarmRunner(this, props, props.schedule, props.duration.toSeconds(), false);\n  }\n}\n"]}

package/lib/webhook-handler.lambda.js

@@ -63,7 +63,7 @@ async function isDeploymentPending(payload) {
     catch (e) {
         console.error({
             notice: 'Unable to check deployment. Try adding deployment read permission.',
-            error: `${e}`,
+            error: e,
         });
         return false;
     }
@@ -178,7 +178,7 @@ async function handler(event) {
     catch (e) {
         console.error({
             notice: 'Bad signature',
-            error: `${e}`,
+            error: e,
         });
         return {
             statusCode: 403,
@@ -259,6 +259,7 @@ async function handler(event) {
     }
     // start execution
     const executionName = generateExecutionName(event, payload);
+    const idleTimeoutSeconds = process.env.IDLE_TIMEOUT_SECONDS ? parseInt(process.env.IDLE_TIMEOUT_SECONDS, 10) : 300; // default 5 minutes
     const input = {
         owner: payload.repository.owner.login,
         repo: payload.repository.name,
@@ -268,6 +269,7 @@ async function handler(event) {
         jobLabels: payload.workflow_job.labels.join(','), // original labels requested by the job
         provider: selection.provider,
         labels: selection.labels.join(','), // labels to use when registering runner
+        maxIdleSeconds: idleTimeoutSeconds,
     };
     const execution = await sf.send(new client_sfn_1.StartExecutionCommand({
         stateMachineArn: process.env.STEP_FUNCTION_ARN,
@@ -286,4 +288,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 { InvokeCommand, LambdaClient } from '@aws-sdk/client-lambda';\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 { ProviderSelectorInput, ProviderSelectorResult } from './webhook';\n\nconst sf = new SFNClient();\nconst lambdaClient = new LambdaClient();\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({\n    notice: 'Calculated signature',\n    signature: expectedSig.toString(),\n  });\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({\n      notice: 'Unable to check deployment. Try adding deployment read permission.',\n      error: `${e}`,\n    });\n    return false;\n  }\n}\n\n/**\n * Match job labels to a provider using default label matching logic.\n */\nfunction matchLabelsToProvider(jobLabels: string[], providers: Record<string, string[]>): string | undefined {\n  const jobLabelLowerCase = jobLabels.map((label) => label.toLowerCase());\n\n  // is every label the job requires available in the runner provider?\n  for (const provider of Object.keys(providers)) {\n    const providerLabelsLowerCase = providers[provider].map((label) => label.toLowerCase());\n    if (jobLabelLowerCase.every(label => label == 'self-hosted' || providerLabelsLowerCase.includes(label))) {\n      return provider;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Call the provider selector Lambda function if configured.\n * @internal\n */\nexport async function callProviderSelector(\n  payload: any,\n  providers: Record<string, string[]>,\n  defaultSelection: ProviderSelectorResult,\n): Promise<ProviderSelectorResult | undefined> {\n  if (!process.env.PROVIDER_SELECTOR_ARN) {\n    return undefined;\n  }\n\n  const selectorInput: ProviderSelectorInput = {\n    payload: payload,\n    providers: providers,\n    defaultProvider: defaultSelection.provider,\n    defaultLabels: defaultSelection.labels,\n  };\n\n  // don't catch errors -- the whole webhook handler will be retried on unhandled errors\n  const result = await lambdaClient.send(new InvokeCommand({\n    FunctionName: process.env.PROVIDER_SELECTOR_ARN,\n    Payload: JSON.stringify(selectorInput),\n  }));\n\n  if (result.FunctionError) {\n    const selectorResponsePayload = result.Payload ? Buffer.from(result.Payload).toString() : undefined;\n    console.error({\n      notice: 'Provider selector failed',\n      functionError: result.FunctionError,\n      payload: selectorResponsePayload,\n    });\n    throw new Error('Provider selector failed');\n  }\n\n  if (!result.Payload) {\n    throw new Error('Provider selector returned no payload');\n  }\n\n  return JSON.parse(Buffer.from(result.Payload).toString()) as ProviderSelectorResult;\n}\n\n/**\n * Exported for unit testing.\n * @internal\n */\nexport async function selectProvider(payload: any, jobLabels: string[], hook = callProviderSelector): Promise<ProviderSelectorResult> {\n  const providers = JSON.parse(process.env.PROVIDERS!);\n  const defaultProvider = matchLabelsToProvider(jobLabels, providers);\n  const defaultLabels = defaultProvider ? providers[defaultProvider] : undefined;\n  const defaultSelection = { provider: defaultProvider, labels: defaultLabels };\n  const selectorResult = await hook(payload, providers, defaultSelection);\n\n  if (selectorResult === undefined) {\n    return defaultSelection;\n  }\n\n  console.log({\n    notice: 'Before provider selector',\n    provider: defaultProvider,\n    labels: defaultLabels,\n    jobLabels: jobLabels,\n  });\n  console.log({\n    notice: 'After provider selector',\n    provider: selectorResult.provider,\n    labels: selectorResult.labels,\n    jobLabels: jobLabels,\n  });\n\n  // any error here will fail the webhook and cause a retry so the selector has another chance to get it right\n  if (selectorResult.provider !== undefined) {\n    if (selectorResult.provider === '') {\n      throw new Error('Provider selector returned empty provider');\n    }\n    if (!providers[selectorResult.provider]) {\n      throw new Error(`Provider selector returned unknown provider ${selectorResult.provider}`);\n    }\n    if (selectorResult.labels === undefined || selectorResult.labels.length === 0) {\n      throw new Error('Provider selector must return non-empty labels when provider is set');\n    }\n  }\n\n  return selectorResult;\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.PROVIDERS || !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({\n      notice: 'Bad signature',\n      error: `${e}`,\n    });\n    return {\n      statusCode: 403,\n      body: 'Bad signature',\n    };\n  }\n\n  if (getHeader(event, 'content-type') !== 'application/json') {\n    console.error({\n      notice: 'This webhook only accepts JSON payloads',\n      contentType: getHeader(event, 'content-type'),\n    });\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({\n      notice: 'This webhook only accepts workflow_job',\n      githubEvent: getHeader(event, 'x-github-event'),\n    });\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  // Select provider and labels\n  const selection = await selectProvider(payload, payload.workflow_job.labels);\n  if (!selection.provider || !selection.labels) {\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    jobLabels: payload.workflow_job.labels.join(','), // original labels requested by the job\n    provider: selection.provider,\n    labels: selection.labels.join(','), // labels to use when registering runner\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 { InvokeCommand, LambdaClient } from '@aws-sdk/client-lambda';\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 { ProviderSelectorInput, ProviderSelectorResult } from './webhook';\n\nconst sf = new SFNClient();\nconst lambdaClient = new LambdaClient();\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({\n    notice: 'Calculated signature',\n    signature: expectedSig.toString(),\n  });\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({\n      notice: 'Unable to check deployment. Try adding deployment read permission.',\n      error: e,\n    });\n    return false;\n  }\n}\n\n/**\n * Match job labels to a provider using default label matching logic.\n */\nfunction matchLabelsToProvider(jobLabels: string[], providers: Record<string, string[]>): string | undefined {\n  const jobLabelLowerCase = jobLabels.map((label) => label.toLowerCase());\n\n  // is every label the job requires available in the runner provider?\n  for (const provider of Object.keys(providers)) {\n    const providerLabelsLowerCase = providers[provider].map((label) => label.toLowerCase());\n    if (jobLabelLowerCase.every(label => label == 'self-hosted' || providerLabelsLowerCase.includes(label))) {\n      return provider;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Call the provider selector Lambda function if configured.\n * @internal\n */\nexport async function callProviderSelector(\n  payload: any,\n  providers: Record<string, string[]>,\n  defaultSelection: ProviderSelectorResult,\n): Promise<ProviderSelectorResult | undefined> {\n  if (!process.env.PROVIDER_SELECTOR_ARN) {\n    return undefined;\n  }\n\n  const selectorInput: ProviderSelectorInput = {\n    payload: payload,\n    providers: providers,\n    defaultProvider: defaultSelection.provider,\n    defaultLabels: defaultSelection.labels,\n  };\n\n  // don't catch errors -- the whole webhook handler will be retried on unhandled errors\n  const result = await lambdaClient.send(new InvokeCommand({\n    FunctionName: process.env.PROVIDER_SELECTOR_ARN,\n    Payload: JSON.stringify(selectorInput),\n  }));\n\n  if (result.FunctionError) {\n    const selectorResponsePayload = result.Payload ? Buffer.from(result.Payload).toString() : undefined;\n    console.error({\n      notice: 'Provider selector failed',\n      functionError: result.FunctionError,\n      payload: selectorResponsePayload,\n    });\n    throw new Error('Provider selector failed');\n  }\n\n  if (!result.Payload) {\n    throw new Error('Provider selector returned no payload');\n  }\n\n  return JSON.parse(Buffer.from(result.Payload).toString()) as ProviderSelectorResult;\n}\n\n/**\n * Exported for unit testing.\n * @internal\n */\nexport async function selectProvider(payload: any, jobLabels: string[], hook = callProviderSelector): Promise<ProviderSelectorResult> {\n  const providers = JSON.parse(process.env.PROVIDERS!);\n  const defaultProvider = matchLabelsToProvider(jobLabels, providers);\n  const defaultLabels = defaultProvider ? providers[defaultProvider] : undefined;\n  const defaultSelection = { provider: defaultProvider, labels: defaultLabels };\n  const selectorResult = await hook(payload, providers, defaultSelection);\n\n  if (selectorResult === undefined) {\n    return defaultSelection;\n  }\n\n  console.log({\n    notice: 'Before provider selector',\n    provider: defaultProvider,\n    labels: defaultLabels,\n    jobLabels: jobLabels,\n  });\n  console.log({\n    notice: 'After provider selector',\n    provider: selectorResult.provider,\n    labels: selectorResult.labels,\n    jobLabels: jobLabels,\n  });\n\n  // any error here will fail the webhook and cause a retry so the selector has another chance to get it right\n  if (selectorResult.provider !== undefined) {\n    if (selectorResult.provider === '') {\n      throw new Error('Provider selector returned empty provider');\n    }\n    if (!providers[selectorResult.provider]) {\n      throw new Error(`Provider selector returned unknown provider ${selectorResult.provider}`);\n    }\n    if (selectorResult.labels === undefined || selectorResult.labels.length === 0) {\n      throw new Error('Provider selector must return non-empty labels when provider is set');\n    }\n  }\n\n  return selectorResult;\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.PROVIDERS || !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({\n      notice: 'Bad signature',\n      error: e,\n    });\n    return {\n      statusCode: 403,\n      body: 'Bad signature',\n    };\n  }\n\n  if (getHeader(event, 'content-type') !== 'application/json') {\n    console.error({\n      notice: 'This webhook only accepts JSON payloads',\n      contentType: getHeader(event, 'content-type'),\n    });\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({\n      notice: 'This webhook only accepts workflow_job',\n      githubEvent: getHeader(event, 'x-github-event'),\n    });\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  // Select provider and labels\n  const selection = await selectProvider(payload, payload.workflow_job.labels);\n  if (!selection.provider || !selection.labels) {\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 idleTimeoutSeconds = process.env.IDLE_TIMEOUT_SECONDS ? parseInt(process.env.IDLE_TIMEOUT_SECONDS, 10) : 300; // default 5 minutes\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    jobLabels: payload.workflow_job.labels.join(','), // original labels requested by the job\n    provider: selection.provider,\n    labels: selection.labels.join(','), // labels to use when registering runner\n    maxIdleSeconds: idleTimeoutSeconds,\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"]}