@cloudsnorkel/cdk-github-runners 0.14.24 → 0.15.0

package/lib/warm-runner-manager.lambda.js

@@ -0,0 +1,487 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = handler;
+/**
+ * Warm Runner Manager Lambda
+ *
+ * Maintains a pool of pre-provisioned ("warm") GitHub self-hosted runners so jobs
+ * start with near-zero latency instead of waiting for a fresh runner to provision.
+ *
+ * ## Lifecycle
+ *
+ * 1. **Fill** — An EventBridge cron rule (midnight UTC for always-on, or window
+ *    start for scheduled) sends a fill payload to the shared SQS queue. For
+ *    AlwaysOnWarmRunner only, a CloudFormation custom resource (on deploy)
+ *    invokes this Lambda directly to fill immediately; the deadline is set to
+ *    the next midnight UTC (not full 24h) so runners last until the next cron
+ *    fill. ScheduledWarmRunner has no deployment-fill — first fill is at the
+ *    next schedule occurrence.
+ *
+ * 2. **Keeper** — Each keeper message tracks one runner. The SQS queue delivers the
+ *    message, this Lambda inspects the runner, and one of the following happens:
+ *    - Runner is past its deadline → the keeper stops the Step Function and deletes
+ *      the runner. No replacement is created.
+ *    - Runner is idle and within deadline → message is returned to the queue
+ *      (via batch item failure) to be checked again after the visibility timeout.
+ *    - Runner is busy or its Step Function finished → a replacement runner is
+ *      started with the same deadline, and a new keeper message is enqueued.
+ *    - Config hash mismatch (config was changed/removed since this runner was
+ *      created) → the runner is stopped and deleted. No replacement is created.
+ *      This is how old runners are cleaned up quickly on config changes.
+ *
+ * 3. **Shutdown mechanisms** — The keeper is the primary mechanism for enforcing the
+ *    absolute deadline: when a runner is past its deadline, the keeper stops the
+ *    Step Function and deletes the runner. Fallbacks:
+ *    - **Idle reaper**: Measures idle time from runner *registration* (cdkghr:started
+ *      label), not step function start. So it fires at deadline + provisioning delay.
+ *      It's a fallback if the keeper misses a message; it does not enforce the
+ *      absolute deadline precisely.
+ *    - **Step Function idle timeout**: Each runner is started with `maxIdleSeconds`
+ *      matching the deadline. If both keeper and idle reaper miss it, the Step
+ *      Function will self-terminate when its idle timeout fires.
+ *
+ * ## Config hash
+ *
+ * Each warm runner config (provider, count, labels, owner, repo, duration) is
+ * hashed at CDK synth time. All current hashes are stored in the WARM_CONFIG_HASHES
+ * environment variable. Fill payloads and keeper messages carry the hash. When the
+ * keeper processes a message whose hash is not in the current set, it knows the
+ * config was changed or removed and stops the runner immediately. This helps quickly
+ * get rid of stale runners while keeping over-provisioning to a minimum.
+ *
+ * ## Gotchas
+ *
+ * - Keeper messages rely on SQS redelivery (batch item failure) for periodic
+ *   checking. The visibility timeout (1 min) determines how often runners are
+ *   polled. Failed messages are retried until they succeed or the runner
+ *   self-terminates at its idle timeout.
+ * - Each fill unconditionally starts `count` runners — it does not check how many
+ *   are already running. On cron fire, this creates a brief overlap with the
+ *   previous cycle's runners (which are near their deadline).
+ * - Removing all warm runners configurations may result in warm runners staying
+ *   around until they expire. To remove all warm runners quickly, set count to 0
+ *   and deploy. Only once all the warm runners are stopped, you can remove all
+ *   configurations and deploy again.
+ * - **Gaps in coverage**: The Step Function that provisions each warm runner uses
+ *   increasing timeouts between retries for provider failures (CodeBuild timeout,
+ *   Lambda timeout, capacity errors, etc.). While a warm runner slot is retrying,
+ *   that slot has no runner. This may create gaps in coverage. An idle warm runner
+ *   that fails to provision (or whose replacement fails) will be unavailable 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.
+ */
+const crypto = require("crypto");
+const client_sfn_1 = require("@aws-sdk/client-sfn");
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+const lambda_github_1 = require("./lambda-github");
+const lambda_helpers_1 = require("./lambda-helpers");
+const sfn = new client_sfn_1.SFNClient();
+const sqs = new client_sqs_1.SQSClient();
+const SFN_EXECUTION_NAME_MAX_LENGTH = 80;
+function isSqsEvent(event) {
+    return Array.isArray(event.Records);
+}
+function isFillInput(event) {
+    return typeof event === 'object' && event !== null && event.action === 'fill';
+}
+function isCustomResourceEvent(event) {
+    const e = event;
+    return typeof e?.RequestType === 'string' && typeof e?.ResponseURL === 'string';
+}
+function requireEnv(name) {
+    const value = process.env[name];
+    if (!value) {
+        throw new Error(`Missing environment variable ${name}`);
+    }
+    return value;
+}
+/**
+ * Deterministic execution name for idempotent fills. Same seed → same name, so retries
+ * (custom resource, SQS redelivery) don't create duplicate runners.
+ */
+function deterministicExecutionName(providerPath, seed) {
+    const pathWithoutStack = providerPath.split('/').slice(1).join('/') || providerPath;
+    const sanitized = `warm-${pathWithoutStack.replace(/[^a-zA-Z0-9-]/g, '-')}`;
+    const hash = crypto.createHash('sha256').update(seed).digest('hex').slice(0, 16);
+    const maxPrefixLen = SFN_EXECUTION_NAME_MAX_LENGTH - hash.length - 1;
+    return `${sanitized.slice(0, maxPrefixLen)}-${hash}`;
+}
+/** Returns Unix ms of the next midnight UTC. Used for AlwaysOn deployment-fill deadline. */
+function getNextMidnightUtcMs() {
+    const now = new Date();
+    const nextMidnight = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1, 0, 0, 0, 0));
+    return nextMidnight.getTime();
+}
+/** Find installation id for our app. Normal code path gets this from the webhook payload, but we schedule these ourselves. */
+async function resolveInstallationId(owner, repo) {
+    const appOctokit = await (0, lambda_github_1.getAppOctokit)();
+    if (!appOctokit) {
+        return undefined; // PAT authentication
+    }
+    if (repo) {
+        const { data } = await appOctokit.rest.apps.getRepoInstallation({ owner, repo });
+        return data.id;
+    }
+    else {
+        const { data } = await appOctokit.rest.apps.getOrgInstallation({ org: owner });
+        return data.id;
+    }
+}
+/** Start a warm runner and enqueue a keeper message using SQS. */
+async function startWarmRunnerAndEnqueueKeeper(input) {
+    const stepFunctionArn = requireEnv('STEP_FUNCTION_ARN');
+    const queueUrl = requireEnv('WARM_RUNNER_QUEUE_URL');
+    const remainingSeconds = Math.floor((input.absoluteDeadline - Date.now()) / 1000);
+    if (remainingSeconds <= 0) {
+        console.log({
+            notice: 'Absolute deadline already passed; not starting replacement',
+            configHash: input.configHash,
+            runnerName: input.executionName,
+            input,
+        });
+        return;
+    }
+    let executionArn;
+    try {
+        const result = await sfn.send(new client_sfn_1.StartExecutionCommand({
+            stateMachineArn: stepFunctionArn,
+            name: input.executionName,
+            input: JSON.stringify({
+                owner: input.owner,
+                repo: input.repo || '',
+                jobId: -1,
+                jobUrl: '',
+                installationId: input.installationId ?? -1,
+                jobLabels: input.providerLabels.join(','),
+                provider: input.providerPath,
+                labels: [...input.providerLabels, 'cdkghr:warm'].join(','),
+                maxIdleSeconds: remainingSeconds,
+            }),
+        }));
+        executionArn = result.executionArn;
+    }
+    catch (e) {
+        if (e instanceof client_sfn_1.ExecutionAlreadyExists) {
+            // Idempotent retry: execution was already started (e.g. Lambda timed out mid-fill).
+            // Don't enqueue. The first attempt already did, so duplicate keeper messages would cause duplicate replacements.
+            console.log({
+                notice: 'ExecutionAlreadyExists — idempotent retry, skipping enqueue',
+                configHash: input.configHash,
+                slot: input.slot,
+                runnerName: input.executionName,
+            });
+            return;
+        }
+        else {
+            throw e;
+        }
+    }
+    const message = {
+        executionArn,
+        runnerName: input.executionName,
+        owner: input.owner,
+        repo: input.repo,
+        installationId: input.installationId,
+        providerPath: input.providerPath,
+        providerLabels: input.providerLabels,
+        absoluteDeadline: input.absoluteDeadline,
+        configHash: input.configHash,
+    };
+    await sqs.send(new client_sqs_1.SendMessageCommand({
+        QueueUrl: queueUrl,
+        MessageBody: JSON.stringify(message),
+    }));
+    console.log({
+        notice: 'Started warm runner and enqueued keeper message',
+        configHash: input.configHash,
+        slot: input.slot,
+        runnerName: input.executionName,
+        executionArn,
+        remainingSeconds,
+    });
+}
+/**
+ * Unconditionally starts `count` warm runners for the given config and enqueues keeper messages.
+ *
+ * @param input the fill payload
+ * @param getNameForSlot a function to generate a unique and stable execution name for each slot
+ * @param source the source of the fill for debugging purposes
+ * @param absoluteDeadlineOverride if provided, use this instead of now + duration (for AlwaysOn deployment-fill)
+ */
+async function runFiller(input, getNameForSlot, source, absoluteDeadlineOverride) {
+    const installationId = await resolveInstallationId(input.owner, input.repo);
+    const absoluteDeadline = absoluteDeadlineOverride ?? Date.now() + input.duration * 1000;
+    for (let i = 0; i < input.count; i++) {
+        await startWarmRunnerAndEnqueueKeeper({
+            providerPath: input.providerPath,
+            providerLabels: input.providerLabels,
+            owner: input.owner,
+            repo: input.repo,
+            installationId,
+            absoluteDeadline,
+            configHash: input.configHash,
+            executionName: getNameForSlot(i),
+            slot: i,
+        });
+    }
+    console.log({
+        notice: 'Fill complete - started warm runners',
+        source,
+        configHash: input.configHash,
+        providerPath: input.providerPath,
+        started: input.count,
+    });
+}
+/** Stop the step function and delete the runner from GitHub. */
+async function stopAndDeleteRunner(input, octokit, secrets, reason) {
+    try {
+        await sfn.send(new client_sfn_1.StopExecutionCommand({
+            executionArn: input.executionArn,
+            error: reason,
+            cause: 'Warm runner stopped by keeper',
+        }));
+    }
+    catch (e) {
+        console.error({
+            notice: 'Failed to stop step function',
+            configHash: input.configHash,
+            runnerName: input.runnerName,
+            executionArn: input.executionArn,
+            error: e,
+            input,
+        });
+    }
+    const runner = await (0, lambda_github_1.getRunner)(octokit, secrets.runnerLevel, input.owner, input.repo, input.runnerName);
+    if (runner) {
+        try {
+            await (0, lambda_github_1.deleteRunner)(octokit, secrets.runnerLevel, input.owner, input.repo, runner.id);
+        }
+        catch (e) {
+            console.error({
+                notice: 'Failed to delete runner',
+                configHash: input.configHash,
+                runnerName: input.runnerName,
+                runnerId: runner.id,
+                error: e,
+                input,
+            });
+        }
+    }
+}
+/**
+ * Warm runner manager Lambda - handles three invocation modes:
+ *
+ * 1. CloudFormation Custom Resource - triggered on stack deploy (Create/Update) for AlwaysOnWarmRunner only. Runs
+ *    runFiller with deadline = next midnight UTC so runners last until the next cron fill. Delete is a no-op.
+ * 2. SQS messages - fill or keeper
+ *    - Fill - from EventBridge cron. Uses messageId for deterministic execution names (idempotent on redelivery).
+ *    - Keeper - tracks one runner. Uses SQS message cycling for periodic checks.
+ *      Each message tracks one warm runner. The keeper checks:
+ *      - Past deadline - stop the Step Function and delete the runner.
+ *      - Config hash - if the message's `configHash` doesn't match the current `WARM_CONFIG_HASHES` env var, the runner is from a stale config - stop it and discard the message without replacement.
+ *      - Busy/finished - if the Step Function ended or the GitHub runner is busy (took a job), start a replacement runner (inheriting the same deadline and config hash).
+ *      - Not found yet (runner/infrastructure still starting) - retry later (message goes back to queue).
+ *      - Still idle - retry later to check again.
+ */
+async function handler(event) {
+    if (isCustomResourceEvent(event)) {
+        const physicalId = ('PhysicalResourceId' in event ? event.PhysicalResourceId : undefined) ?? event.LogicalResourceId;
+        try {
+            const props = event.ResourceProperties;
+            console.log({
+                notice: 'Custom resource fill',
+                requestType: event.RequestType,
+                logicalResourceId: event.LogicalResourceId,
+                configHash: props.configHash,
+                providerPath: props.providerPath,
+                count: props.count,
+            });
+            if (event.RequestType === 'Create' || event.RequestType === 'Update') {
+                const getNameForSlot = (slot) => deterministicExecutionName(props.providerPath, `${event.LogicalResourceId}:${event.RequestType}:${props.configHash}:${slot}`);
+                const deadline = getNextMidnightUtcMs();
+                await runFiller(props, getNameForSlot, 'customResource', deadline);
+            }
+            await (0, lambda_helpers_1.customResourceRespond)(event, 'SUCCESS', 'OK', physicalId, {});
+        }
+        catch (e) {
+            console.error({ notice: 'Custom resource handler failed', error: e });
+            await (0, lambda_helpers_1.customResourceRespond)(event, 'FAILED', e.message || 'Internal Error', physicalId, {});
+        }
+        return;
+    }
+    if (!isSqsEvent(event)) {
+        console.error({ notice: 'Unknown event type; ignoring', event });
+        return;
+    }
+    const validHashes = new Set((process.env.WARM_CONFIG_HASHES ?? '').split(',').filter(Boolean));
+    const result = { batchItemFailures: [] };
+    const octokitCache = new Map();
+    for (const record of event.Records) {
+        let body;
+        try {
+            body = JSON.parse(record.body);
+        }
+        catch (e) {
+            console.error({
+                notice: 'Failed to parse message body',
+                requestId: record.messageId,
+                error: e,
+            });
+            continue;
+        }
+        const retryLater = () => result.batchItemFailures.push({ itemIdentifier: record.messageId });
+        const isFill = isFillInput(body);
+        const configHash = body.configHash;
+        const runnerName = isFill ? undefined : body.runnerName;
+        console.log({
+            notice: 'Processing SQS message',
+            messageId: record.messageId,
+            configHash,
+            runnerName,
+        });
+        // scheduled fill from EventBridge via SQS
+        if (isFill) {
+            const fillPayload = body;
+            try {
+                console.log({
+                    notice: 'Scheduled fill',
+                    configHash,
+                    providerPath: fillPayload.providerPath,
+                    count: fillPayload.count,
+                });
+                const getNameForSlot = (slot) => deterministicExecutionName(fillPayload.providerPath, `${record.messageId}:${slot}`);
+                await runFiller(fillPayload, getNameForSlot, 'scheduled', undefined);
+            }
+            catch (e) {
+                console.error({
+                    notice: 'Fill failed',
+                    messageId: record.messageId,
+                    configHash: fillPayload.configHash,
+                    error: e,
+                });
+                retryLater();
+            }
+            continue;
+        }
+        // keeper message
+        const input = body;
+        console.log({
+            notice: 'Checking warm runner',
+            configHash: input.configHash,
+            runnerName: input.runnerName,
+        });
+        // get github access (cached per installationId to avoid re-reading the secrets manager and Github API every time)
+        let octokit;
+        let secrets;
+        const cached = octokitCache.get(input.installationId);
+        if (cached) {
+            octokit = cached.octokit;
+            secrets = cached.secrets;
+        }
+        else {
+            const got = await (0, lambda_github_1.getOctokit)(input.installationId);
+            octokit = got.octokit;
+            secrets = got.githubSecrets;
+            octokitCache.set(input.installationId, { octokit, secrets });
+        }
+        // stale config - best-effort stop, then discard message (runner will self-terminate at its idle timeout)
+        if (!validHashes.has(input.configHash)) {
+            console.log({
+                notice: 'Config hash mismatch (new CDK deployment, old runner) - stopping stale warm runner',
+                configHash: input.configHash,
+                runnerName: input.runnerName,
+                validHashes: validHashes,
+            });
+            try {
+                await stopAndDeleteRunner(input, octokit, secrets, 'StaleWarmRunner');
+            }
+            catch (e) {
+                console.error({
+                    notice: 'Best-effort cleanup of stale warm runner failed; it will self-terminate at idle timeout',
+                    configHash: input.configHash,
+                    runnerName: input.runnerName,
+                    error: e,
+                });
+            }
+            continue;
+        }
+        // past deadline - keeper must stop and delete the runner
+        if (Date.now() >= input.absoluteDeadline) {
+            console.log({
+                notice: 'Warm runner past deadline, stopping and deleting',
+                configHash: input.configHash,
+                runnerName: input.runnerName,
+            });
+            try {
+                await stopAndDeleteRunner(input, octokit, secrets, 'WarmRunnerExpired');
+            }
+            catch (e) {
+                console.error({
+                    notice: 'Failed to stop expired warm runner',
+                    configHash: input.configHash,
+                    runnerName: input.runnerName,
+                    error: e,
+                });
+                // don't retry to not accidentally create a new runner
+                // idle reaper will take care of it soon enough
+            }
+            continue;
+        }
+        // check if step function is still running
+        const execution = await sfn.send(new client_sfn_1.DescribeExecutionCommand({ executionArn: input.executionArn }));
+        const stillRunning = execution.status === 'RUNNING';
+        // find runner
+        const runner = await (0, lambda_github_1.getRunner)(octokit, secrets.runnerLevel, input.owner, input.repo, input.runnerName);
+        // need replacement: step function finished (not running) or runner took a job (busy)
+        if (!stillRunning || runner?.busy) {
+            console.log({
+                notice: 'Warm runner finished or busy; starting replacement',
+                configHash: input.configHash,
+                runnerName: input.runnerName,
+                stillRunning,
+                runnerBusy: runner?.busy ?? false,
+            });
+            try {
+                await startWarmRunnerAndEnqueueKeeper({
+                    providerPath: input.providerPath,
+                    providerLabels: input.providerLabels,
+                    owner: input.owner,
+                    repo: input.repo,
+                    installationId: input.installationId,
+                    absoluteDeadline: input.absoluteDeadline,
+                    configHash: input.configHash,
+                    executionName: deterministicExecutionName(input.providerPath, record.messageId),
+                });
+            }
+            catch (e) {
+                console.error({
+                    notice: 'Failed to start replacement warm runner',
+                    configHash: input.configHash,
+                    runnerName: input.runnerName,
+                    error: e,
+                });
+                retryLater();
+            }
+            continue;
+        }
+        // step function still running but runner not found yet
+        if (!runner) {
+            console.log({
+                notice: 'Runner not running yet',
+                configHash: input.configHash,
+                runnerName: input.runnerName,
+            });
+            retryLater();
+            continue;
+        }
+        // still idle - check again later
+        console.log({
+            notice: 'Runner still idle - will check again later',
+            configHash: input.configHash,
+            runnerName: input.runnerName,
+        });
+        retryLater();
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"warm-runner-manager.lambda.js","sourceRoot":"","sources":["../src/warm-runner-manager.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Warm Runner Manager Lambda\n *\n * Maintains a pool of pre-provisioned (\"warm\") GitHub self-hosted runners so jobs\n * start with near-zero latency instead of waiting for a fresh runner to provision.\n *\n * ## Lifecycle\n *\n * 1. **Fill** — An EventBridge cron rule (midnight UTC for always-on, or window\n *    start for scheduled) sends a fill payload to the shared SQS queue. For\n *    AlwaysOnWarmRunner only, a CloudFormation custom resource (on deploy)\n *    invokes this Lambda directly to fill immediately; the deadline is set to\n *    the next midnight UTC (not full 24h) so runners last until the next cron\n *    fill. ScheduledWarmRunner has no deployment-fill — first fill is at the\n *    next schedule occurrence.\n *\n * 2. **Keeper** — Each keeper message tracks one runner. The SQS queue delivers the\n *    message, this Lambda inspects the runner, and one of the following happens:\n *    - Runner is past its deadline → the keeper stops the Step Function and deletes\n *      the runner. No replacement is created.\n *    - Runner is idle and within deadline → message is returned to the queue\n *      (via batch item failure) to be checked again after the visibility timeout.\n *    - Runner is busy or its Step Function finished → a replacement runner is\n *      started with the same deadline, and a new keeper message is enqueued.\n *    - Config hash mismatch (config was changed/removed since this runner was\n *      created) → the runner is stopped and deleted. No replacement is created.\n *      This is how old runners are cleaned up quickly on config changes.\n *\n * 3. **Shutdown mechanisms** — The keeper is the primary mechanism for enforcing the\n *    absolute deadline: when a runner is past its deadline, the keeper stops the\n *    Step Function and deletes the runner. Fallbacks:\n *    - **Idle reaper**: Measures idle time from runner *registration* (cdkghr:started\n *      label), not step function start. So it fires at deadline + provisioning delay.\n *      It's a fallback if the keeper misses a message; it does not enforce the\n *      absolute deadline precisely.\n *    - **Step Function idle timeout**: Each runner is started with `maxIdleSeconds`\n *      matching the deadline. If both keeper and idle reaper miss it, the Step\n *      Function will self-terminate when its idle timeout fires.\n *\n * ## Config hash\n *\n * Each warm runner config (provider, count, labels, owner, repo, duration) is\n * hashed at CDK synth time. All current hashes are stored in the WARM_CONFIG_HASHES\n * environment variable. Fill payloads and keeper messages carry the hash. When the\n * keeper processes a message whose hash is not in the current set, it knows the\n * config was changed or removed and stops the runner immediately. This helps quickly\n * get rid of stale runners while keeping over-provisioning to a minimum.\n *\n * ## Gotchas\n *\n * - Keeper messages rely on SQS redelivery (batch item failure) for periodic\n *   checking. The visibility timeout (1 min) determines how often runners are\n *   polled. Failed messages are retried until they succeed or the runner\n *   self-terminates at its idle timeout.\n * - Each fill unconditionally starts `count` runners — it does not check how many\n *   are already running. On cron fire, this creates a brief overlap with the\n *   previous cycle's runners (which are near their deadline).\n * - Removing all warm runners configurations may result in warm runners staying\n *   around until they expire. To remove all warm runners quickly, set count to 0\n *   and deploy. Only once all the warm runners are stopped, you can remove all\n *   configurations and deploy again.\n * - **Gaps in coverage**: The Step Function that provisions each warm runner uses\n *   increasing timeouts between retries for provider failures (CodeBuild timeout,\n *   Lambda timeout, capacity errors, etc.). While a warm runner slot is retrying,\n *   that slot has no runner. This may create gaps in coverage. An idle warm runner\n *   that fails to provision (or whose replacement fails) will be unavailable until\n *   the retry succeeds. Current retry mechanism has built-in back-off rate and can\n *   be tweaked using `retryOptions`. This will be improved in the future.\n */\nimport * as crypto from 'crypto';\nimport {\n  DescribeExecutionCommand,\n  SFNClient,\n  StartExecutionCommand,\n  StopExecutionCommand,\n  ExecutionAlreadyExists,\n} from '@aws-sdk/client-sfn';\nimport { SQSClient, SendMessageCommand } from '@aws-sdk/client-sqs';\nimport type { Octokit } from '@octokit/rest';\nimport * as AWSLambda from 'aws-lambda';\nimport { deleteRunner, getAppOctokit, getOctokit, getRunner, GitHubSecrets } from './lambda-github';\nimport { customResourceRespond } from './lambda-helpers';\n\nconst sfn = new SFNClient();\nconst sqs = new SQSClient();\n\nconst SFN_EXECUTION_NAME_MAX_LENGTH = 80;\n\nexport interface WarmRunnerKeeperMessage {\n  readonly executionArn: string;\n  readonly runnerName: string;\n  readonly owner: string;\n  readonly repo: string;\n  readonly installationId?: number;\n  readonly providerPath: string;\n  readonly providerLabels: string[];\n  readonly absoluteDeadline: number; // Unix ms — inherited by replacements\n  readonly configHash: string;\n}\n\n/**\n * @internal\n */\nexport interface WarmRunnerFillPayload {\n  readonly action: 'fill';\n  readonly providerPath: string;\n  readonly providerLabels: string[];\n  readonly count: number;\n  readonly duration: number;\n  readonly owner: string;\n  readonly repo: string;\n  readonly configHash: string;\n}\n\nfunction isSqsEvent(event: unknown): event is AWSLambda.SQSEvent {\n  return Array.isArray((event as AWSLambda.SQSEvent).Records);\n}\n\nfunction isFillInput(event: unknown): event is WarmRunnerFillPayload {\n  return typeof event === 'object' && event !== null && (event as WarmRunnerFillPayload).action === 'fill';\n}\n\nfunction isCustomResourceEvent(event: unknown): event is AWSLambda.CloudFormationCustomResourceEvent {\n  const e = event as AWSLambda.CloudFormationCustomResourceEvent;\n  return typeof e?.RequestType === 'string' && typeof e?.ResponseURL === 'string';\n}\n\nfunction requireEnv(name: string) {\n  const value = process.env[name];\n  if (!value) {\n    throw new Error(`Missing environment variable ${name}`);\n  }\n  return value;\n}\n\ninterface StartWarmRunnerInput {\n  readonly providerPath: string;\n  readonly providerLabels: string[];\n  readonly owner: string;\n  readonly repo: string;\n  readonly installationId?: number;\n  readonly absoluteDeadline: number; // Unix ms\n  readonly configHash: string;\n  readonly executionName: string;\n  readonly slot?: number; // 0-based index when filling multiple slots; helps correlate logs\n}\n\n/**\n * Deterministic execution name for idempotent fills. Same seed → same name, so retries\n * (custom resource, SQS redelivery) don't create duplicate runners.\n */\nfunction deterministicExecutionName(providerPath: string, seed: string) {\n  const pathWithoutStack = providerPath.split('/').slice(1).join('/') || providerPath;\n  const sanitized = `warm-${pathWithoutStack.replace(/[^a-zA-Z0-9-]/g, '-')}`;\n  const hash = crypto.createHash('sha256').update(seed).digest('hex').slice(0, 16);\n  const maxPrefixLen = SFN_EXECUTION_NAME_MAX_LENGTH - hash.length - 1;\n  return `${sanitized.slice(0, maxPrefixLen)}-${hash}`;\n}\n\n/** Returns Unix ms of the next midnight UTC. Used for AlwaysOn deployment-fill deadline. */\nfunction getNextMidnightUtcMs(): number {\n  const now = new Date();\n  const nextMidnight = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1, 0, 0, 0, 0));\n  return nextMidnight.getTime();\n}\n\n/** Find installation id for our app. Normal code path gets this from the webhook payload, but we schedule these ourselves. */\nasync function resolveInstallationId(owner: string, repo: string) {\n  const appOctokit = await getAppOctokit();\n  if (!appOctokit) {\n    return undefined; // PAT authentication\n  }\n\n  if (repo) {\n    const { data } = await appOctokit.rest.apps.getRepoInstallation({ owner, repo });\n    return data.id;\n  } else {\n    const { data } = await appOctokit.rest.apps.getOrgInstallation({ org: owner });\n    return data.id;\n  }\n}\n\n/** Start a warm runner and enqueue a keeper message using SQS. */\nasync function startWarmRunnerAndEnqueueKeeper(input: StartWarmRunnerInput) {\n  const stepFunctionArn = requireEnv('STEP_FUNCTION_ARN');\n  const queueUrl = requireEnv('WARM_RUNNER_QUEUE_URL');\n\n  const remainingSeconds = Math.floor((input.absoluteDeadline - Date.now()) / 1000);\n  if (remainingSeconds <= 0) {\n    console.log({\n      notice: 'Absolute deadline already passed; not starting replacement',\n      configHash: input.configHash,\n      runnerName: input.executionName,\n      input,\n    });\n    return;\n  }\n\n  let executionArn: string;\n  try {\n    const result = await sfn.send(new StartExecutionCommand({\n      stateMachineArn: stepFunctionArn,\n      name: input.executionName,\n      input: JSON.stringify({\n        owner: input.owner,\n        repo: input.repo || '',\n        jobId: -1,\n        jobUrl: '',\n        installationId: input.installationId ?? -1,\n        jobLabels: input.providerLabels.join(','),\n        provider: input.providerPath,\n        labels: [...input.providerLabels, 'cdkghr:warm'].join(','),\n        maxIdleSeconds: remainingSeconds,\n      }),\n    }));\n    executionArn = result.executionArn!;\n  } catch (e) {\n    if (e instanceof ExecutionAlreadyExists) {\n      // Idempotent retry: execution was already started (e.g. Lambda timed out mid-fill).\n      // Don't enqueue. The first attempt already did, so duplicate keeper messages would cause duplicate replacements.\n      console.log({\n        notice: 'ExecutionAlreadyExists — idempotent retry, skipping enqueue',\n        configHash: input.configHash,\n        slot: input.slot,\n        runnerName: input.executionName,\n      });\n      return;\n    } else {\n      throw e;\n    }\n  }\n\n  const message: WarmRunnerKeeperMessage = {\n    executionArn,\n    runnerName: input.executionName,\n    owner: input.owner,\n    repo: input.repo,\n    installationId: input.installationId,\n    providerPath: input.providerPath,\n    providerLabels: input.providerLabels,\n    absoluteDeadline: input.absoluteDeadline,\n    configHash: input.configHash,\n  };\n\n  await sqs.send(new SendMessageCommand({\n    QueueUrl: queueUrl,\n    MessageBody: JSON.stringify(message),\n  }));\n\n  console.log({\n    notice: 'Started warm runner and enqueued keeper message',\n    configHash: input.configHash,\n    slot: input.slot,\n    runnerName: input.executionName,\n    executionArn,\n    remainingSeconds,\n  });\n}\n\n/**\n * Unconditionally starts `count` warm runners for the given config and enqueues keeper messages.\n *\n * @param input the fill payload\n * @param getNameForSlot a function to generate a unique and stable execution name for each slot\n * @param source the source of the fill for debugging purposes\n * @param absoluteDeadlineOverride if provided, use this instead of now + duration (for AlwaysOn deployment-fill)\n */\nasync function runFiller(input: WarmRunnerFillPayload, getNameForSlot: (slot: number) => string, source: string, absoluteDeadlineOverride?: number) {\n  const installationId = await resolveInstallationId(input.owner, input.repo);\n  const absoluteDeadline = absoluteDeadlineOverride ?? Date.now() + input.duration * 1000;\n\n  for (let i = 0; i < input.count; i++) {\n    await startWarmRunnerAndEnqueueKeeper({\n      providerPath: input.providerPath,\n      providerLabels: input.providerLabels,\n      owner: input.owner,\n      repo: input.repo,\n      installationId,\n      absoluteDeadline,\n      configHash: input.configHash,\n      executionName: getNameForSlot(i),\n      slot: i,\n    });\n  }\n\n  console.log({\n    notice: 'Fill complete - started warm runners',\n    source,\n    configHash: input.configHash,\n    providerPath: input.providerPath,\n    started: input.count,\n  });\n}\n\n/** Stop the step function and delete the runner from GitHub. */\nasync function stopAndDeleteRunner(input: WarmRunnerKeeperMessage, octokit: Octokit, secrets: GitHubSecrets, reason: string) {\n  try {\n    await sfn.send(new StopExecutionCommand({\n      executionArn: input.executionArn,\n      error: reason,\n      cause: 'Warm runner stopped by keeper',\n    }));\n  } catch (e) {\n    console.error({\n      notice: 'Failed to stop step function',\n      configHash: input.configHash,\n      runnerName: input.runnerName,\n      executionArn: input.executionArn,\n      error: e,\n      input,\n    });\n  }\n\n  const runner = await getRunner(octokit, secrets.runnerLevel, input.owner, input.repo, input.runnerName);\n  if (runner) {\n    try {\n      await deleteRunner(octokit, secrets.runnerLevel, input.owner, input.repo, runner.id);\n    } catch (e) {\n      console.error({\n        notice: 'Failed to delete runner',\n        configHash: input.configHash,\n        runnerName: input.runnerName,\n        runnerId: runner.id,\n        error: e,\n        input,\n      });\n    }\n  }\n}\n\n/**\n * Warm runner manager Lambda - handles three invocation modes:\n *\n * 1. CloudFormation Custom Resource - triggered on stack deploy (Create/Update) for AlwaysOnWarmRunner only. Runs\n *    runFiller with deadline = next midnight UTC so runners last until the next cron fill. Delete is a no-op.\n * 2. SQS messages - fill or keeper\n *    - Fill - from EventBridge cron. Uses messageId for deterministic execution names (idempotent on redelivery).\n *    - Keeper - tracks one runner. Uses SQS message cycling for periodic checks.\n *      Each message tracks one warm runner. The keeper checks:\n *      - Past deadline - stop the Step Function and delete the runner.\n *      - Config hash - if the message's `configHash` doesn't match the current `WARM_CONFIG_HASHES` env var, the runner is from a stale config - stop it and discard the message without replacement.\n *      - Busy/finished - if the Step Function ended or the GitHub runner is busy (took a job), start a replacement runner (inheriting the same deadline and config hash).\n *      - Not found yet (runner/infrastructure still starting) - retry later (message goes back to queue).\n *      - Still idle - retry later to check again.\n */\nexport async function handler(event: AWSLambda.SQSEvent | AWSLambda.CloudFormationCustomResourceEvent) {\n  if (isCustomResourceEvent(event)) {\n    const physicalId = ('PhysicalResourceId' in event ? event.PhysicalResourceId : undefined) ?? event.LogicalResourceId;\n    try {\n      const props = event.ResourceProperties as unknown as WarmRunnerFillPayload;\n      console.log({\n        notice: 'Custom resource fill',\n        requestType: event.RequestType,\n        logicalResourceId: event.LogicalResourceId,\n        configHash: props.configHash,\n        providerPath: props.providerPath,\n        count: props.count,\n      });\n      if (event.RequestType === 'Create' || event.RequestType === 'Update') {\n        const getNameForSlot = (slot: number) =>\n          deterministicExecutionName(props.providerPath, `${event.LogicalResourceId}:${event.RequestType}:${props.configHash}:${slot}`);\n        const deadline = getNextMidnightUtcMs();\n        await runFiller(props, getNameForSlot, 'customResource', deadline);\n      }\n      await customResourceRespond(event, 'SUCCESS', 'OK', physicalId, {});\n    } catch (e) {\n      console.error({ notice: 'Custom resource handler failed', error: e });\n      await customResourceRespond(event, 'FAILED', (e as Error).message || 'Internal Error', physicalId, {});\n    }\n    return;\n  }\n\n  if (!isSqsEvent(event)) {\n    console.error({ notice: 'Unknown event type; ignoring', event });\n    return;\n  }\n\n  const validHashes = new Set((process.env.WARM_CONFIG_HASHES ?? '').split(',').filter(Boolean));\n  const result: AWSLambda.SQSBatchResponse = { batchItemFailures: [] };\n  const octokitCache = new Map<number | undefined, { octokit: Octokit; secrets: GitHubSecrets }>();\n\n  for (const record of event.Records) {\n    let body: WarmRunnerKeeperMessage | WarmRunnerFillPayload;\n    try {\n      body = JSON.parse(record.body) as WarmRunnerKeeperMessage | WarmRunnerFillPayload;\n    } catch (e) {\n      console.error({\n        notice: 'Failed to parse message body',\n        requestId: record.messageId,\n        error: e,\n      });\n      continue;\n    }\n\n    const retryLater = () => result.batchItemFailures.push({ itemIdentifier: record.messageId });\n\n    const isFill = isFillInput(body);\n    const configHash = (body as WarmRunnerFillPayload & WarmRunnerKeeperMessage).configHash;\n    const runnerName = isFill ? undefined : (body as WarmRunnerKeeperMessage).runnerName;\n    console.log({\n      notice: 'Processing SQS message',\n      messageId: record.messageId,\n      configHash,\n      runnerName,\n    });\n\n    // scheduled fill from EventBridge via SQS\n    if (isFill) {\n      const fillPayload = body as WarmRunnerFillPayload;\n      try {\n        console.log({\n          notice: 'Scheduled fill',\n          configHash,\n          providerPath: fillPayload.providerPath,\n          count: fillPayload.count,\n        });\n        const getNameForSlot = (slot: number) =>\n          deterministicExecutionName(fillPayload.providerPath, `${record.messageId}:${slot}`);\n        await runFiller(fillPayload, getNameForSlot, 'scheduled', undefined);\n      } catch (e) {\n        console.error({\n          notice: 'Fill failed',\n          messageId: record.messageId,\n          configHash: fillPayload.configHash,\n          error: e,\n        });\n        retryLater();\n      }\n      continue;\n    }\n\n    // keeper message\n    const input = body as WarmRunnerKeeperMessage;\n    console.log({\n      notice: 'Checking warm runner',\n      configHash: input.configHash,\n      runnerName: input.runnerName,\n    });\n\n    // get github access (cached per installationId to avoid re-reading the secrets manager and Github API every time)\n    let octokit: Octokit;\n    let secrets: GitHubSecrets;\n    const cached = octokitCache.get(input.installationId);\n    if (cached) {\n      octokit = cached.octokit;\n      secrets = cached.secrets;\n    } else {\n      const got = await getOctokit(input.installationId);\n      octokit = got.octokit;\n      secrets = got.githubSecrets;\n      octokitCache.set(input.installationId, { octokit, secrets });\n    }\n\n    // stale config - best-effort stop, then discard message (runner will self-terminate at its idle timeout)\n    if (!validHashes.has(input.configHash)) {\n      console.log({\n        notice: 'Config hash mismatch (new CDK deployment, old runner) - stopping stale warm runner',\n        configHash: input.configHash,\n        runnerName: input.runnerName,\n        validHashes: validHashes,\n      });\n\n      try {\n        await stopAndDeleteRunner(input, octokit, secrets, 'StaleWarmRunner');\n      } catch (e) {\n        console.error({\n          notice: 'Best-effort cleanup of stale warm runner failed; it will self-terminate at idle timeout',\n          configHash: input.configHash,\n          runnerName: input.runnerName,\n          error: e,\n        });\n      }\n      continue;\n    }\n\n    // past deadline - keeper must stop and delete the runner\n    if (Date.now() >= input.absoluteDeadline) {\n      console.log({\n        notice: 'Warm runner past deadline, stopping and deleting',\n        configHash: input.configHash,\n        runnerName: input.runnerName,\n      });\n      try {\n        await stopAndDeleteRunner(input, octokit, secrets, 'WarmRunnerExpired');\n      } catch (e) {\n        console.error({\n          notice: 'Failed to stop expired warm runner',\n          configHash: input.configHash,\n          runnerName: input.runnerName,\n          error: e,\n        });\n        // don't retry to not accidentally create a new runner\n        // idle reaper will take care of it soon enough\n      }\n      continue;\n    }\n\n    // check if step function is still running\n    const execution = await sfn.send(new DescribeExecutionCommand({ executionArn: input.executionArn }));\n    const stillRunning = execution.status === 'RUNNING';\n\n    // find runner\n    const runner = await getRunner(octokit, secrets.runnerLevel, input.owner, input.repo, input.runnerName);\n\n    // need replacement: step function finished (not running) or runner took a job (busy)\n    if (!stillRunning || runner?.busy) {\n      console.log({\n        notice: 'Warm runner finished or busy; starting replacement',\n        configHash: input.configHash,\n        runnerName: input.runnerName,\n        stillRunning,\n        runnerBusy: runner?.busy ?? false,\n      });\n      try {\n        await startWarmRunnerAndEnqueueKeeper({\n          providerPath: input.providerPath,\n          providerLabels: input.providerLabels,\n          owner: input.owner,\n          repo: input.repo,\n          installationId: input.installationId,\n          absoluteDeadline: input.absoluteDeadline,\n          configHash: input.configHash,\n          executionName: deterministicExecutionName(input.providerPath, record.messageId),\n        });\n      } catch (e) {\n        console.error({\n          notice: 'Failed to start replacement warm runner',\n          configHash: input.configHash,\n          runnerName: input.runnerName,\n          error: e,\n        });\n        retryLater();\n      }\n      continue;\n    }\n\n    // step function still running but runner not found yet\n    if (!runner) {\n      console.log({\n        notice: 'Runner not running yet',\n        configHash: input.configHash,\n        runnerName: input.runnerName,\n      });\n      retryLater();\n      continue;\n    }\n\n    // still idle - check again later\n    console.log({\n      notice: 'Runner still idle - will check again later',\n      configHash: input.configHash,\n      runnerName: input.runnerName,\n    });\n    retryLater();\n  }\n\n  return result;\n}\n"]}