@magland/mochi 0.3.1

package/dist/runner/steps.js

@@ -0,0 +1,571 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNNER_TEMP = exports.ActionError = void 0;
+exports.runSteps = runSteps;
+exports.runPostHooks = runPostHooks;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const actionref_1 = require("../ci/actionref");
+const expr_1 = require("../ci/expr");
+const actions_1 = require("./actions");
+Object.defineProperty(exports, "ActionError", { enumerable: true, get: function () { return actions_1.ActionError; } });
+const context_1 = require("./context");
+Object.defineProperty(exports, "RUNNER_TEMP", { enumerable: true, get: function () { return context_1.RUNNER_TEMP; } });
+const docker_1 = require("./docker");
+const overrides_1 = require("./overrides");
+function envFileTag(index) {
+    return `${index}-${crypto.randomBytes(4).toString('hex')}`;
+}
+// Run a list of steps in one scope. `onStepState` is called for top-level
+// workflow steps only; composite steps report through the log instead, since
+// the run page's step list mirrors the workflow file rather than everything
+// that executed.
+async function runSteps(steps, scope, ctx, hooks = {}) {
+    let failed = false;
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        const cancelled = hooks.checkCancelled?.() ?? false;
+        if (cancelled)
+            return { failed, cancelled: true };
+        const stepEnv = buildStepEnv(step, scope, ctx, failed);
+        if (stepEnv === null) {
+            failed = true;
+            hooks.onEnd?.(i, { ok: false, failed: true, skipped: false });
+            continue;
+        }
+        const evalEnv = () => ({
+            contexts: (0, context_1.contextsFor)({
+                spec: ctx.spec,
+                scope,
+                stepEnv,
+                jobFailed: failed || ctx.status().failed,
+                jobCancelled: ctx.status().cancelled,
+            }),
+            functions: (0, context_1.statusFunctions)(failed || ctx.status().failed, ctx.status().cancelled),
+        });
+        let shouldRun;
+        try {
+            shouldRun = step.if === undefined ? !failed : (0, expr_1.evalCondition)(step.if, evalEnv());
+        }
+        catch (e) {
+            ctx.log(`Error evaluating if: ${e instanceof Error ? e.message : String(e)}`);
+            failed = true;
+            hooks.onEnd?.(i, { ok: false, failed: true, skipped: false });
+            continue;
+        }
+        if (!shouldRun) {
+            if (step.id)
+                scope.conclusions[step.id] = { outcome: 'skipped', conclusion: 'skipped' };
+            hooks.onEnd?.(i, { ok: true, failed: false, skipped: true });
+            continue;
+        }
+        const label = labelOf(step, i, evalEnv);
+        hooks.onStart?.(i, label);
+        if (scope.depth > 0)
+            ctx.log(`▸ ${label}`);
+        let outcome;
+        try {
+            outcome = await executeStep(step, scope, ctx, stepEnv, evalEnv, i);
+        }
+        catch (e) {
+            ctx.log(e instanceof Error ? e.message : String(e));
+            outcome = { ok: false, failed: true, skipped: false };
+        }
+        let continued = false;
+        if (!outcome.ok && step.continueOnError !== undefined) {
+            try {
+                continued = (0, expr_1.evalCondition)(step.continueOnError, evalEnv());
+            }
+            catch {
+                continued = false;
+            }
+        }
+        if (continued)
+            outcome = { ...outcome, failed: false };
+        if (step.id) {
+            scope.conclusions[step.id] = {
+                outcome: outcome.ok ? 'success' : 'failure',
+                conclusion: outcome.failed ? 'failure' : 'success',
+            };
+        }
+        if (outcome.failed)
+            failed = true;
+        hooks.onEnd?.(i, outcome);
+        // Inside a composite action, a failed step ends the action immediately.
+        if (outcome.failed && scope.depth > 0)
+            return { failed: true, cancelled: false };
+    }
+    return { failed, cancelled: hooks.checkCancelled?.() ?? false };
+}
+function labelOf(step, index, evalEnv) {
+    const resolve = (s) => (0, expr_1.render)(s, evalEnv());
+    try {
+        if (step.name)
+            return resolve(step.name);
+    }
+    catch {
+        return step.name;
+    }
+    if (step.uses)
+        return step.uses;
+    if (step.run) {
+        let text = step.run;
+        try {
+            text = resolve(step.run);
+        }
+        catch {
+            // keep the literal
+        }
+        const first = text.split('\n').find((l) => l.trim() !== '')?.trim() ?? '';
+        return `Run ${first.length > 70 ? first.slice(0, 70) + '…' : first}`;
+    }
+    return `Step ${index + 1}`;
+}
+// Environment for one step: the base environment, then anything earlier steps
+// exported through GITHUB_ENV, then the composite action's env, then the
+// step's own. Only the values written in YAML are templates; values that came
+// from GITHUB_ENV at runtime are data, and evaluating `${{ }}` found in them
+// would let one step's output become an expression in another step's context.
+function buildStepEnv(step, scope, ctx, failedSoFar) {
+    const stepEnv = { ...ctx.env, ...ctx.rt.env };
+    const templates = { ...ctx.spec.env, ...scope.actionEnv, ...step.env };
+    try {
+        const rendered = (0, expr_1.renderDeep)(templates, {
+            contexts: (0, context_1.contextsFor)({
+                spec: ctx.spec,
+                scope,
+                stepEnv,
+                jobFailed: failedSoFar || ctx.status().failed,
+                jobCancelled: ctx.status().cancelled,
+            }),
+        });
+        // Workflow env first so a runtime value from GITHUB_ENV still wins over
+        // it, then the action's and the step's, which win over everything.
+        for (const k of Object.keys(ctx.spec.env)) {
+            if (k in rendered)
+                stepEnv[k] = (0, expr_1.stringify)(rendered[k]);
+        }
+        for (const [k, v] of Object.entries(ctx.rt.env))
+            stepEnv[k] = v;
+        for (const k of [...Object.keys(scope.actionEnv), ...Object.keys(step.env)]) {
+            if (k in rendered)
+                stepEnv[k] = (0, expr_1.stringify)(rendered[k]);
+        }
+    }
+    catch (e) {
+        ctx.log(`Error evaluating env: ${e instanceof Error ? e.message : String(e)}`);
+        return null;
+    }
+    return stepEnv;
+}
+async function executeStep(step, scope, ctx, stepEnv, evalEnv, index) {
+    if (step.run !== undefined) {
+        const ok = await runShellStep(step, scope, ctx, stepEnv, evalEnv, index);
+        return { ok, failed: !ok, skipped: false };
+    }
+    if (step.uses !== undefined) {
+        const ok = await runActionStep(step, scope, ctx, stepEnv, evalEnv, index);
+        return { ok, failed: !ok, skipped: false };
+    }
+    ctx.log('a step needs either run: or uses:');
+    return { ok: false, failed: true, skipped: false };
+}
+async function makeFileCommands(ctx, tag) {
+    const files = {
+        output: `${context_1.FILE_COMMAND_DIR}/output-${tag}`,
+        envFile: `${context_1.FILE_COMMAND_DIR}/env-${tag}`,
+        pathFile: `${context_1.FILE_COMMAND_DIR}/path-${tag}`,
+        summary: `${context_1.FILE_COMMAND_DIR}/summary-${tag}`,
+        state: `${context_1.FILE_COMMAND_DIR}/state-${tag}`,
+    };
+    for (const f of Object.values(files))
+        await (0, docker_1.writeFileInContainer)(ctx.containerId, f, '');
+    return files;
+}
+function fileCommandEnv(files) {
+    return {
+        GITHUB_OUTPUT: files.output,
+        GITHUB_ENV: files.envFile,
+        GITHUB_PATH: files.pathFile,
+        GITHUB_STEP_SUMMARY: files.summary,
+        GITHUB_STATE: files.state,
+    };
+}
+// Read back everything a step wrote through the file commands, and fold it
+// into the scope and the job runtime.
+async function collectFileCommands(ctx, scope, files, stepId) {
+    const outputText = await (0, docker_1.readFileInContainer)(ctx.containerId, files.output);
+    const parsed = (0, context_1.parseKeyValueFile)(outputText);
+    if (stepId && Object.keys(parsed).length) {
+        scope.outputs[stepId] = { ...(scope.outputs[stepId] ?? {}), ...parsed };
+    }
+    const envText = await (0, docker_1.readFileInContainer)(ctx.containerId, files.envFile);
+    Object.assign(ctx.rt.env, (0, context_1.parseKeyValueFile)(envText));
+    const pathText = await (0, docker_1.readFileInContainer)(ctx.containerId, files.pathFile);
+    for (const line of pathText.split('\n')) {
+        const p = line.trim();
+        if (p !== '' && !ctx.rt.extraPath.includes(p))
+            ctx.rt.extraPath.unshift(p);
+    }
+    const summaryText = await (0, docker_1.readFileInContainer)(ctx.containerId, files.summary);
+    if (summaryText.trim() !== '')
+        ctx.rt.summaries.push(summaryText);
+}
+function pathEnv(ctx, stepEnv) {
+    if (ctx.rt.extraPath.length === 0)
+        return {};
+    const existing = stepEnv.PATH ?? '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin';
+    return { PATH: `${ctx.rt.extraPath.join(':')}:${existing}` };
+}
+function workdirFor(step, ctx, scope, evalEnv) {
+    const wd = step.workingDirectory ?? (scope.depth === 0 ? ctx.spec.defaults?.workingDirectory : undefined);
+    if (!wd)
+        return context_1.WORKSPACE;
+    try {
+        const rendered = (0, expr_1.render)(wd, evalEnv());
+        return rendered.startsWith('/') ? rendered : `${context_1.WORKSPACE}/${rendered}`;
+    }
+    catch {
+        return context_1.WORKSPACE;
+    }
+}
+// Interpret one line of a step's output: either a workflow command, or text.
+function makeLineHandler(ctx, scope, stepId) {
+    return (raw) => {
+        const cmd = (0, context_1.parseWorkflowCommand)(raw);
+        if (!cmd) {
+            ctx.log(raw);
+            return;
+        }
+        switch (cmd.name) {
+            case 'add-mask':
+                ctx.masker.add(cmd.message);
+                break;
+            case 'group':
+                ctx.log(`▾ ${cmd.message}`);
+                break;
+            case 'endgroup':
+                break;
+            case 'error':
+            case 'warning':
+            case 'notice': {
+                const where = cmd.props.file ? ` (${cmd.props.file}${cmd.props.line ? `:${cmd.props.line}` : ''})` : '';
+                ctx.log(`${cmd.name.toUpperCase()}${where}: ${cmd.message}`);
+                break;
+            }
+            case 'debug':
+                // Actions are chatty at debug level; GitHub hides these unless the
+                // run was started with debug logging, and so does mochi.
+                if (ctx.env.RUNNER_DEBUG === '1')
+                    ctx.log(`DEBUG: ${cmd.message}`);
+                break;
+            case 'set-output':
+                if (stepId && cmd.props.name) {
+                    scope.outputs[stepId] = { ...(scope.outputs[stepId] ?? {}), [cmd.props.name]: cmd.message };
+                }
+                break;
+            case 'set-env':
+                if (cmd.props.name)
+                    ctx.rt.env[cmd.props.name] = cmd.message;
+                break;
+            case 'add-path':
+                if (cmd.message && !ctx.rt.extraPath.includes(cmd.message))
+                    ctx.rt.extraPath.unshift(cmd.message);
+                break;
+            case 'echo':
+            case 'save-state':
+            case 'stop-commands':
+                break;
+            // Problem matchers annotate a run's diff on GitHub. mochi has no
+            // equivalent yet, so the commands are consumed rather than printed.
+            case 'add-matcher':
+            case 'remove-matcher':
+                break;
+            default:
+                ctx.log(raw);
+        }
+    };
+}
+async function runShellStep(step, scope, ctx, stepEnv, evalEnv, index) {
+    let script;
+    try {
+        script = (0, expr_1.render)(step.run ?? '', evalEnv());
+    }
+    catch (e) {
+        ctx.log(`Error evaluating the step body: ${e instanceof Error ? e.message : String(e)}`);
+        return false;
+    }
+    const tag = envFileTag(index);
+    const files = await makeFileCommands(ctx, tag);
+    const scriptPath = `${context_1.FILE_COMMAND_DIR}/step-${tag}`;
+    await (0, docker_1.writeFileInContainer)(ctx.containerId, scriptPath, script.endsWith('\n') ? script : script + '\n');
+    const shell = step.shell ?? (scope.depth === 0 ? ctx.spec.defaults?.shell : undefined);
+    const env = {
+        ...stepEnv,
+        ...fileCommandEnv(files),
+        ...pathEnv(ctx, stepEnv),
+        GITHUB_ACTION: step.id ?? `__run_${index}`,
+    };
+    if (scope.actionPath)
+        env.GITHUB_ACTION_PATH = scope.actionPath;
+    const handle = (0, docker_1.execInContainer)(ctx.containerId, (0, context_1.shellCommand)(shell, scriptPath), makeLineHandler(ctx, scope, step.id), {
+        workdir: workdirFor(step, ctx, scope, evalEnv),
+        env,
+    });
+    const code = await handle.done;
+    await collectFileCommands(ctx, scope, files, step.id);
+    if (code !== 0)
+        ctx.log(`Process completed with exit code ${code}.`);
+    return code === 0;
+}
+// ---- uses: steps ----
+async function runActionStep(step, scope, ctx, stepEnv, evalEnv, index) {
+    if (scope.depth >= context_1.MAX_ACTION_DEPTH) {
+        ctx.log(`actions are nested more than ${context_1.MAX_ACTION_DEPTH} deep; refusing to go further`);
+        return false;
+    }
+    let ref;
+    try {
+        ref = (0, actionref_1.parseActionRef)((0, expr_1.render)(step.uses, evalEnv()));
+    }
+    catch (e) {
+        ctx.log(e instanceof Error ? e.message : String(e));
+        return false;
+    }
+    // `with:` values are templates evaluated in the calling scope.
+    const provided = {};
+    try {
+        for (const [k, v] of Object.entries(step.with ?? {}))
+            provided[k] = (0, expr_1.render)(v, evalEnv());
+    }
+    catch (e) {
+        ctx.log(`Error evaluating with: ${e instanceof Error ? e.message : String(e)}`);
+        return false;
+    }
+    // An override stands in for actions that talk to services only GitHub has.
+    // It is chosen by the `uses:` string, so it applies at any nesting depth,
+    // including inside someone else's composite action.
+    const override = (0, overrides_1.findOverride)(ref);
+    if (override) {
+        ctx.log(`Using mochi's built-in ${override.name} (${ref.raw})`);
+        try {
+            const result = await override.run({
+                ctx,
+                ref,
+                inputs: provided,
+                stepEnv,
+            });
+            if (result.outputs && step.id) {
+                scope.outputs[step.id] = { ...(scope.outputs[step.id] ?? {}), ...result.outputs };
+            }
+            return result.ok;
+        }
+        catch (e) {
+            ctx.log(e instanceof Error ? e.message : String(e));
+            return false;
+        }
+    }
+    let resolved;
+    try {
+        resolved = await ctx.actions.resolve(ref, ctx.hostPaths.workspace, (l) => ctx.log(l));
+    }
+    catch (e) {
+        ctx.log(e instanceof Error ? e.message : String(e));
+        return false;
+    }
+    const { values, missing } = (0, actions_1.resolveInputs)(resolved.def, provided);
+    if (missing.length) {
+        ctx.log(`${ref.raw} requires the input${missing.length > 1 ? 's' : ''}: ${missing.join(', ')}`);
+        return false;
+    }
+    const containerDir = await stageAction(ctx, ref, resolved);
+    if (resolved.def.runs.using === 'composite') {
+        return runCompositeAction(step, scope, ctx, resolved, containerDir, values, index);
+    }
+    if (resolved.def.runs.using === 'node') {
+        return runNodeAction(step, scope, ctx, ref, resolved, containerDir, values, stepEnv, index);
+    }
+    ctx.log(`docker actions are not supported yet (uses: ${ref.raw})`);
+    return false;
+}
+// Copy the action's files into the job's own directory. The cache holds the
+// pristine download; the container sees a per-job copy, so an action that
+// writes into its own directory cannot poison the next job's copy.
+async function stageAction(ctx, ref, resolved) {
+    const name = `${resolved.key}${ref.kind === 'repo' && ref.subpath ? '__' + ref.subpath.replace(/\//g, '--') : ''}`;
+    const hostDir = path.join(ctx.hostPaths.actions, name);
+    if (!fs.existsSync(hostDir)) {
+        fs.mkdirSync(path.dirname(hostDir), { recursive: true });
+        fs.cpSync(resolved.dir, hostDir, { recursive: true, dereference: false });
+    }
+    return `${context_1.ACTIONS_MOUNT}/${name}`;
+}
+async function runNodeAction(step, scope, ctx, ref, resolved, containerDir, inputs, stepEnv, index) {
+    const runs = resolved.def.runs;
+    if (runs.using !== 'node')
+        return false;
+    const node = await ctx.externals.nodeFor(ctx.containerId, runs.nodeMajor, (l) => ctx.log(l));
+    const runScript = async (script, label, stepId) => {
+        const tag = envFileTag(index);
+        const files = await makeFileCommands(ctx, tag);
+        const env = {
+            ...stepEnv,
+            ...fileCommandEnv(files),
+            ...pathEnv(ctx, stepEnv),
+            GITHUB_ACTION: stepId ?? `__action_${index}`,
+            GITHUB_ACTION_PATH: containerDir,
+            GITHUB_ACTION_REPOSITORY: ref.kind === 'repo' ? `${ref.owner}/${ref.repo}` : '',
+        };
+        for (const [name, value] of Object.entries(inputs))
+            env[(0, actions_1.inputEnvName)(name)] = value;
+        const handle = (0, docker_1.execInContainer)(ctx.containerId, [node, `${containerDir}/${script}`], makeLineHandler(ctx, scope, stepId), { workdir: context_1.WORKSPACE, env });
+        const code = await handle.done;
+        await collectFileCommands(ctx, scope, files, stepId);
+        if (code !== 0)
+            ctx.log(`${label} completed with exit code ${code}.`);
+        return code === 0;
+    };
+    if (runs.pre) {
+        // A pre script runs before the action's main, and its failure is the
+        // step's failure. `pre-if` gates it the way `post-if` gates the post
+        // script; an unparseable condition runs the script, since skipping setup
+        // silently is the worse of the two failures.
+        let should = true;
+        if (runs.preIf !== undefined) {
+            const jobFailed = ctx.status().failed;
+            const jobCancelled = ctx.status().cancelled;
+            try {
+                should = (0, expr_1.evalCondition)(runs.preIf, {
+                    contexts: (0, context_1.contextsFor)({ spec: ctx.spec, scope, stepEnv: ctx.env, jobFailed, jobCancelled }),
+                    functions: (0, context_1.statusFunctions)(jobFailed, jobCancelled),
+                });
+            }
+            catch {
+                should = true;
+            }
+        }
+        if (should && !(await runScript(runs.pre, 'The pre step', step.id)))
+            return false;
+    }
+    const ok = await runScript(runs.main, 'Process', step.id);
+    if (runs.post) {
+        // Post steps run after every step in the job, in reverse order, which is
+        // how cleanup (checkout's git config, a cache save) is expected to work.
+        const label = step.name ?? step.uses ?? 'action';
+        ctx.rt.postHooks.push({
+            label: `Post ${label}`,
+            condition: runs.postIf,
+            run: async () => {
+                ctx.log(`▸ Post ${label}`);
+                await runScript(runs.post, 'The post step', undefined);
+            },
+        });
+    }
+    return ok;
+}
+async function runCompositeAction(step, scope, ctx, resolved, containerDir, inputs, index) {
+    const runs = resolved.def.runs;
+    if (runs.using !== 'composite')
+        return false;
+    const inner = (0, context_1.newScope)(scope.depth + 1);
+    inner.inputs = inputs;
+    inner.actionPath = containerDir;
+    const result = await runSteps(runs.steps, inner, ctx);
+    if (result.failed)
+        return false;
+    // The action's outputs are expressions over its own steps.
+    if (step.id && Object.keys(resolved.def.outputs).length) {
+        const env = {
+            contexts: (0, context_1.contextsFor)({
+                spec: ctx.spec,
+                scope: inner,
+                stepEnv: ctx.env,
+                jobFailed: false,
+                jobCancelled: false,
+            }),
+            functions: (0, context_1.statusFunctions)(false, false),
+        };
+        const outputs = {};
+        for (const [name, def] of Object.entries(resolved.def.outputs)) {
+            if (def.value === undefined)
+                continue;
+            try {
+                outputs[name] = (0, expr_1.render)(def.value, env);
+            }
+            catch {
+                outputs[name] = '';
+            }
+        }
+        scope.outputs[step.id] = { ...(scope.outputs[step.id] ?? {}), ...outputs };
+    }
+    void index;
+    return true;
+}
+// ---- post hooks ----
+async function runPostHooks(ctx, jobFailed) {
+    const hooks = [...ctx.rt.postHooks].reverse();
+    ctx.rt.postHooks.length = 0;
+    for (const hook of hooks) {
+        if (hook.condition !== undefined) {
+            const env = {
+                contexts: (0, context_1.contextsFor)({
+                    spec: ctx.spec,
+                    scope: (0, context_1.newScope)(0),
+                    stepEnv: ctx.env,
+                    jobFailed,
+                    jobCancelled: ctx.status().cancelled,
+                }),
+                functions: (0, context_1.statusFunctions)(jobFailed, ctx.status().cancelled),
+            };
+            let should = true;
+            try {
+                should = (0, expr_1.evalCondition)(hook.condition, env);
+            }
+            catch {
+                should = true;
+            }
+            if (!should)
+                continue;
+        }
+        try {
+            await hook.run(jobFailed);
+        }
+        catch (e) {
+            ctx.log(`${hook.label} failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+}

package/dist/runner/wake.js

@@ -0,0 +1,84 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startWakeListener = startWakeListener;
+const crypto = __importStar(require("crypto"));
+const http = __importStar(require("http"));
+function secretOk(presented, expected) {
+    if (typeof presented !== 'string')
+        return false;
+    const a = Buffer.from(presented);
+    const b = Buffer.from(expected);
+    // Length is not a secret worth padding for, and comparing buffers of
+    // different lengths throws.
+    return a.length === b.length && crypto.timingSafeEqual(a, b);
+}
+/**
+ * Listen for wake requests on `port`, calling `onWake` for each authorized one.
+ *
+ * Resolves once the socket is listening, so that a caller can report the port
+ * it actually got, and rejects if the port cannot be bound: a runner whose
+ * wake endpoint is not up is one nothing can start again, which is worth
+ * failing on rather than discovering later as a run that never began.
+ */
+function startWakeListener(opts) {
+    const server = http.createServer((req, res) => {
+        if (!secretOk(req.headers['x-mochi-wake'], opts.secret)) {
+            res.writeHead(401).end();
+            return;
+        }
+        opts.onWake();
+        res.writeHead(204).end();
+    });
+    // A wake request carries nothing, so a client that opens a connection and
+    // says nothing is either a mistake or a nuisance; either way it should not
+    // hold a socket open.
+    server.headersTimeout = 5000;
+    server.requestTimeout = 10000;
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(opts.port, opts.host ?? '0.0.0.0', () => {
+            server.removeListener('error', reject);
+            const address = server.address();
+            resolve({
+                port: typeof address === 'object' && address !== null ? address.port : opts.port,
+                close: () => new Promise((done) => {
+                    server.close(() => done());
+                    server.closeAllConnections();
+                }),
+            });
+        });
+    });
+}