@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/cli-github.js

@@ -5,15 +5,6 @@
  *
  * @see https://docs.github.com/en/webhooks/testing-and-troubleshooting-webhooks/using-the-github-cli-to-forward-webhooks-for-testing
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { execFile, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
@@ -73,282 +64,271 @@ Notes:
 
 See also: docs/guides/github.md, skills/github/SKILL.md
 `;
-export function cmdGithub(subcommand, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        switch (subcommand) {
-            case undefined:
-            case "help":
-            case "--help":
-            case "-h":
-                process.stdout.write(GITHUB_HELP);
-                return subcommand === undefined ? 1 : 0;
-            case "forward":
-                return cmdGithubForward(options);
-            case "replay":
-                return cmdGithubReplay(options);
-            case "events":
-                return cmdGithubEvents(options);
-            case "doctor":
-                return cmdGithubDoctor(options);
-            default:
-                process.stderr.write(`Unknown github subcommand: ${subcommand}\n`);
-                process.stdout.write(GITHUB_HELP);
-                return 1;
-        }
-    });
-}
-function cmdGithubForward(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
-        const dir = resolvePath(options.dir);
-        const channels = findGitHubChannelTargets(yield resolveAgentMounts(dir));
-        const resolveInput = {
-            targets: channels,
-            slug: options.slug,
-            channel: options.channel,
-            host: (_a = options.host) !== null && _a !== void 0 ? _a : DEFAULT_HOST,
-            port: (_b = options.port) !== null && _b !== void 0 ? _b : DEFAULT_PORT,
-            authoringPath: projectPath(resolveProjectRoot(dir), "channels/github.ts"),
-            url: options.url,
-            events: parseEventList(options.events),
-        };
-        const resolved = resolveGitHubForwardTargets(resolveInput);
-        if (!resolved.ok) {
-            process.stderr.write(`${resolved.error}\n`);
+export async function cmdGithub(subcommand, options) {
+    switch (subcommand) {
+        case undefined:
+        case "help":
+        case "--help":
+        case "-h":
+            process.stdout.write(GITHUB_HELP);
+            return subcommand === undefined ? 1 : 0;
+        case "forward":
+            return cmdGithubForward(options);
+        case "replay":
+            return cmdGithubReplay(options);
+        case "events":
+            return cmdGithubEvents(options);
+        case "doctor":
+            return cmdGithubDoctor(options);
+        default:
+            process.stderr.write(`Unknown github subcommand: ${subcommand}\n`);
+            process.stdout.write(GITHUB_HELP);
             return 1;
-        }
-        const targets = resolved.targets;
-        const extension = yield ensureWebhookExtension(options.install === true);
-        if (!extension.ok) {
-            process.stderr.write(`${extension.message}\n`);
+    }
+}
+async function cmdGithubForward(options) {
+    const dir = resolvePath(options.dir);
+    const channels = findGitHubChannelTargets(await resolveAgentMounts(dir));
+    const resolveInput = {
+        targets: channels,
+        slug: options.slug,
+        channel: options.channel,
+        host: options.host ?? DEFAULT_HOST,
+        port: options.port ?? DEFAULT_PORT,
+        authoringPath: projectPath(resolveProjectRoot(dir), "channels/github.ts"),
+        url: options.url,
+        events: parseEventList(options.events),
+    };
+    const resolved = resolveGitHubForwardTargets(resolveInput);
+    if (!resolved.ok) {
+        process.stderr.write(`${resolved.error}\n`);
+        return 1;
+    }
+    const targets = resolved.targets;
+    const extension = await ensureWebhookExtension(options.install === true);
+    if (!extension.ok) {
+        process.stderr.write(`${extension.message}\n`);
+        return 1;
+    }
+    let repo = options.repo;
+    const org = options.org;
+    if (repo === undefined && org === undefined) {
+        repo = await inferRepo(dir);
+        if (repo === undefined) {
+            process.stderr.write("could not infer the repository — pass --repo owner/repo (or --org <org>)\n");
             return 1;
         }
-        let repo = options.repo;
-        const org = options.org;
-        if (repo === undefined && org === undefined) {
-            repo = yield inferRepo(dir);
-            if (repo === undefined) {
-                process.stderr.write("could not infer the repository — pass --repo owner/repo (or --org <org>)\n");
-                return 1;
-            }
-            process.stderr.write(`[bdk] inferred --repo ${repo}\n`);
-        }
-        const secret = (_c = options.secret) !== null && _c !== void 0 ? _c : process.env.GITHUB_WEBHOOK_SECRET;
-        // `gh webhook forward` targets a single URL, and GitHub allows only one
-        // forwarder per repo/org. To feed several channels at once, run one
-        // forwarder into a local proxy that re-delivers each raw (still-signed)
-        // delivery to every matching channel. A single channel needs no proxy.
-        const fanout = targets.length > 1;
-        const proxy = fanout ? yield startFanoutServer(targets) : undefined;
-        const forwardUrl = (_d = proxy === null || proxy === void 0 ? void 0 : proxy.url) !== null && _d !== void 0 ? _d : targets[0].url;
-        const events = fanout ? unionForwardEvents(targets) : targets[0].events;
-        const args = buildGitHubForwardArgs({
-            url: forwardUrl,
-            events,
+        process.stderr.write(`[bdk] inferred --repo ${repo}\n`);
+    }
+    const secret = options.secret ?? process.env.GITHUB_WEBHOOK_SECRET;
+    // `gh webhook forward` targets a single URL, and GitHub allows only one
+    // forwarder per repo/org. To feed several channels at once, run one
+    // forwarder into a local proxy that re-delivers each raw (still-signed)
+    // delivery to every matching channel. A single channel needs no proxy.
+    const fanout = targets.length > 1;
+    const proxy = fanout ? await startFanoutServer(targets) : undefined;
+    const forwardUrl = proxy?.url ?? targets[0].url;
+    const events = fanout ? unionForwardEvents(targets) : targets[0].events;
+    const args = buildGitHubForwardArgs({
+        url: forwardUrl,
+        events,
+        repo,
+        org,
+        secret,
+    });
+    process.stderr.write(`[bdk] forwarding ${org !== undefined ? `org ${org}` : `repo ${repo}`} to ${targets.length} channel${targets.length === 1 ? "" : "s"}:\n`);
+    for (const target of targets) {
+        process.stderr.write(`[bdk]   → ${targetLabel(target)}  ${target.url}  (${target.events.join(", ")})\n`);
+    }
+    if (fanout) {
+        process.stderr.write(`[bdk] fan-out proxy on ${forwardUrl} (union events: ${events.join(", ")})\n`);
+    }
+    if (secret === undefined || secret === "") {
+        process.stderr.write("[bdk] no signing secret — deliveries are unsigned. A `serve --dev` github channel accepts them; set GITHUB_WEBHOOK_SECRET on both sides to verify signatures (required for a non-dev target).\n");
+    }
+    const envToken = detectGitHubEnvTokenOverride();
+    if (envToken !== undefined) {
+        process.stderr.write(`[bdk] warning: ${githubEnvTokenHint(envToken)}\n`);
+    }
+    process.stderr.write(`[bdk] running: gh ${redact(args)}\n`);
+    try {
+        return await spawnGh(args);
+    }
+    finally {
+        proxy?.close();
+    }
+}
+async function cmdGithubReplay(options) {
+    const prUrl = options.prUrl;
+    if (prUrl === undefined || prUrl === "") {
+        process.stderr.write("github replay needs a PR URL or owner/repo#N\n");
+        return 1;
+    }
+    const ref = parseGitHubPrRef(prUrl);
+    if (ref === undefined) {
+        process.stderr.write(`could not parse PR ref: ${prUrl}\n`);
+        return 1;
+    }
+    // Which channel(s) to deliver to — reuse forward's discovery + URL builder,
+    // but keep each channel's *declared* events so `--events=*` can expand them.
+    const dir = resolvePath(options.dir);
+    const channels = findGitHubChannelTargets(await resolveAgentMounts(dir));
+    const host = options.host ?? DEFAULT_HOST;
+    const port = options.port ?? DEFAULT_PORT;
+    let candidates = channels;
+    if (options.slug !== undefined) {
+        candidates = candidates.filter(c => c.slug === options.slug);
+    }
+    if (options.channel !== undefined) {
+        candidates = candidates.filter(c => c.channelId === options.channel);
+    }
+    if (options.url !== undefined && candidates.length > 1) {
+        process.stderr.write("--url targets a single channel; narrow with --slug/--channel\n");
+        return 1;
+    }
+    if (candidates.length === 0 && options.url === undefined) {
+        const channelPath = projectPath(resolveProjectRoot(dir), "channels/github.ts");
+        process.stderr.write(`no GitHub channel found. Author ${channelPath} with githubChannel(), or pass --url.\n`);
+        return 1;
+    }
+    const targets = options.url === undefined
+        ? candidates.map(c => ({
+            slug: c.slug,
+            channelId: c.channelId,
+            url: channelForwardUrl({
+                host,
+                port,
+                slug: c.slug,
+                channelId: c.channelId,
+                routePath: c.routePath,
+            }),
+            events: c.events,
+        }))
+        : [
+            {
+                slug: candidates[0]?.slug ?? "",
+                channelId: candidates[0]?.channelId ?? "",
+                url: options.url,
+                events: candidates[0]?.events ?? [],
+            },
+        ];
+    const requested = parseEventList(options.events);
+    const { events: eventsToReplay, unsupported } = selectReplayEvents(requested, unionForwardEvents(targets));
+    if (unsupported.length > 0) {
+        process.stderr.write(`[bdk] cannot synthesize (skipped): ${unsupported.join(", ")}\n`);
+    }
+    if (eventsToReplay.length === 0) {
+        process.stderr.write("no synthesizable events selected\n");
+        return 1;
+    }
+    // Read the PR — pull access is enough (no admin, no relay).
+    let repo;
+    let pull;
+    try {
+        repo = await ghApiJson(`repos/${ref.owner}/${ref.repo}`);
+        pull = await ghApiJson(`repos/${ref.owner}/${ref.repo}/pulls/${ref.number}`);
+    }
+    catch (error) {
+        process.stderr.write(`failed to read ${ref.label} via gh api: ${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+    // Best-effort: mirror a real CI check (app slug / conclusion) for CI events.
+    const wantsCi = eventsToReplay.some(event => ["check_run", "check_suite", "workflow_run", "status"].includes(event));
+    const check = wantsCi ? await fetchReplayCheck(ref, pull.head.sha) : undefined;
+    const synthesized = [];
+    for (const event of eventsToReplay) {
+        const result = synthesizeGitHubEvent({
+            event,
             repo,
-            org,
-            secret,
+            pull,
+            action: options.action,
+            conclusion: options.conclusion,
+            context: options.context,
+            comment: options.comment,
+            check,
         });
-        process.stderr.write(`[bdk] forwarding ${org !== undefined ? `org ${org}` : `repo ${repo}`} to ${targets.length} channel${targets.length === 1 ? "" : "s"}:\n`);
-        for (const target of targets) {
-            process.stderr.write(`[bdk]   → ${targetLabel(target)}  ${target.url}  (${target.events.join(", ")})\n`);
+        if ("error" in result) {
+            process.stderr.write(`[bdk] skipping ${event}: ${result.error}\n`);
+            continue;
         }
-        if (fanout) {
-            process.stderr.write(`[bdk] fan-out proxy on ${forwardUrl} (union events: ${events.join(", ")})\n`);
+        synthesized.push(result);
+    }
+    if (synthesized.length === 0) {
+        process.stderr.write("nothing to replay after synthesis\n");
+        return 1;
+    }
+    const secret = options.secret ?? process.env.GITHUB_WEBHOOK_SECRET;
+    process.stderr.write(`[bdk] replaying ${ref.label} (${synthesized
+        .map(s => s.eventName)
+        .join(", ")}) → ${targets.length} channel${targets.length === 1 ? "" : "s"}\n`);
+    const report = [];
+    let anyRejected = false;
+    for (const event of synthesized) {
+        const body = Buffer.from(JSON.stringify(event.payload));
+        const headers = {
+            "content-type": "application/json",
+            "x-github-event": event.eventName,
+            "x-github-delivery": randomUUID(),
+        };
+        if (secret !== undefined && secret !== "") {
+            headers["x-hub-signature-256"] = `sha256=${signGitHubWebhookBody({ secret, body })}`;
         }
-        if (secret === undefined || secret === "") {
-            process.stderr.write("[bdk] no signing secret — deliveries are unsigned. A `serve --dev` github channel accepts them; set GITHUB_WEBHOOK_SECRET on both sides to verify signatures (required for a non-dev target).\n");
+        if (options.out !== undefined) {
+            const file = await writeReplayFixture(options.out, event);
+            process.stderr.write(`[bdk] wrote ${file}\n`);
         }
-        const envToken = detectGitHubEnvTokenOverride();
-        if (envToken !== undefined) {
-            process.stderr.write(`[bdk] warning: ${githubEnvTokenHint(envToken)}\n`);
+        const label = eventLabel(event);
+        if (options.dryRun === true) {
+            report.push({ ...eventReport(event), payload: event.payload });
+            if (options.json !== true) {
+                process.stdout.write(`--- ${label} ---\n${JSON.stringify(event.payload, null, 2)}\n`);
+            }
+            continue;
         }
-        process.stderr.write(`[bdk] running: gh ${redact(args)}\n`);
-        try {
-            return yield spawnGh(args);
+        const deliveries = await deliverReplayEvent(body, headers, event.eventName, targets);
+        if (deliveries.length === 0 || deliveries.some(delivery => !delivery.ok)) {
+            anyRejected = true;
         }
-        finally {
-            proxy === null || proxy === void 0 ? void 0 : proxy.close();
+        report.push({ ...eventReport(event), deliveries });
+        if (options.json !== true) {
+            const summary = deliveries
+                .map(delivery => `${delivery.label} ${delivery.status || "ERR"}${delivery.ok ? "" : " (rejected)"}`)
+                .join(", ") || "(no matching channel)";
+            process.stderr.write(`[bdk]   ${label} → ${summary}\n`);
         }
-    });
+    }
+    if (options.json === true) {
+        process.stdout.write(`${JSON.stringify({ pr: ref.label, dryRun: options.dryRun === true, events: report }, null, 2)}\n`);
+    }
+    return anyRejected ? 1 : 0;
 }
-function cmdGithubReplay(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c;
-        var _d, _e, _f, _g, _h, _j;
-        const prUrl = options.prUrl;
-        if (prUrl === undefined || prUrl === "") {
-            process.stderr.write("github replay needs a PR URL or owner/repo#N\n");
-            return 1;
-        }
-        const ref = parseGitHubPrRef(prUrl);
-        if (ref === undefined) {
-            process.stderr.write(`could not parse PR ref: ${prUrl}\n`);
-            return 1;
-        }
-        // Which channel(s) to deliver to — reuse forward's discovery + URL builder,
-        // but keep each channel's *declared* events so `--events=*` can expand them.
-        const dir = resolvePath(options.dir);
-        const channels = findGitHubChannelTargets(yield resolveAgentMounts(dir));
-        const host = (_d = options.host) !== null && _d !== void 0 ? _d : DEFAULT_HOST;
-        const port = (_e = options.port) !== null && _e !== void 0 ? _e : DEFAULT_PORT;
-        let candidates = channels;
-        if (options.slug !== undefined) {
-            candidates = candidates.filter(c => c.slug === options.slug);
-        }
-        if (options.channel !== undefined) {
-            candidates = candidates.filter(c => c.channelId === options.channel);
-        }
-        if (options.url !== undefined && candidates.length > 1) {
-            process.stderr.write("--url targets a single channel; narrow with --slug/--channel\n");
-            return 1;
-        }
-        if (candidates.length === 0 && options.url === undefined) {
-            const channelPath = projectPath(resolveProjectRoot(dir), "channels/github.ts");
-            process.stderr.write(`no GitHub channel found. Author ${channelPath} with githubChannel(), or pass --url.\n`);
-            return 1;
-        }
-        const targets = options.url === undefined
-            ? candidates.map(c => ({
-                slug: c.slug,
-                channelId: c.channelId,
-                url: channelForwardUrl({
-                    host,
-                    port,
-                    slug: c.slug,
-                    channelId: c.channelId,
-                    routePath: c.routePath,
-                }),
-                events: c.events,
-            }))
-            : [
-                {
-                    slug: (_f = (_a = candidates[0]) === null || _a === void 0 ? void 0 : _a.slug) !== null && _f !== void 0 ? _f : "",
-                    channelId: (_g = (_b = candidates[0]) === null || _b === void 0 ? void 0 : _b.channelId) !== null && _g !== void 0 ? _g : "",
-                    url: options.url,
-                    events: (_h = (_c = candidates[0]) === null || _c === void 0 ? void 0 : _c.events) !== null && _h !== void 0 ? _h : [],
-                },
-            ];
-        const requested = parseEventList(options.events);
-        const { events: eventsToReplay, unsupported } = selectReplayEvents(requested, unionForwardEvents(targets));
-        if (unsupported.length > 0) {
-            process.stderr.write(`[bdk] cannot synthesize (skipped): ${unsupported.join(", ")}\n`);
-        }
-        if (eventsToReplay.length === 0) {
-            process.stderr.write("no synthesizable events selected\n");
-            return 1;
-        }
-        // Read the PR — pull access is enough (no admin, no relay).
-        let repo;
-        let pull;
+/** POST one synthesized event to every channel whose event set matches. */
+async function deliverReplayEvent(body, headers, eventName, targets) {
+    const recipients = targets.filter(target => target.events.length === 0 || target.events.includes(eventName));
+    const payload = new Uint8Array(body);
+    // Bounded by the channel count (a handful) — see fanoutDelivery.
+    return Promise.all(recipients.map(async (target) => {
         try {
-            repo = yield ghApiJson(`repos/${ref.owner}/${ref.repo}`);
-            pull = yield ghApiJson(`repos/${ref.owner}/${ref.repo}/pulls/${ref.number}`);
-        }
-        catch (error) {
-            process.stderr.write(`failed to read ${ref.label} via gh api: ${error instanceof Error ? error.message : String(error)}\n`);
-            return 1;
-        }
-        // Best-effort: mirror a real CI check (app slug / conclusion) for CI events.
-        const wantsCi = eventsToReplay.some(event => ["check_run", "check_suite", "workflow_run", "status"].includes(event));
-        const check = wantsCi ? yield fetchReplayCheck(ref, pull.head.sha) : undefined;
-        const synthesized = [];
-        for (const event of eventsToReplay) {
-            const result = synthesizeGitHubEvent({
-                event,
-                repo,
-                pull,
-                action: options.action,
-                conclusion: options.conclusion,
-                context: options.context,
-                comment: options.comment,
-                check,
+            const response = await fetch(target.url, {
+                method: "POST",
+                headers,
+                body: payload,
             });
-            if ("error" in result) {
-                process.stderr.write(`[bdk] skipping ${event}: ${result.error}\n`);
-                continue;
-            }
-            synthesized.push(result);
-        }
-        if (synthesized.length === 0) {
-            process.stderr.write("nothing to replay after synthesis\n");
-            return 1;
-        }
-        const secret = (_j = options.secret) !== null && _j !== void 0 ? _j : process.env.GITHUB_WEBHOOK_SECRET;
-        process.stderr.write(`[bdk] replaying ${ref.label} (${synthesized
-            .map(s => s.eventName)
-            .join(", ")}) → ${targets.length} channel${targets.length === 1 ? "" : "s"}\n`);
-        const report = [];
-        let anyRejected = false;
-        for (const event of synthesized) {
-            const body = Buffer.from(JSON.stringify(event.payload));
-            const headers = {
-                "content-type": "application/json",
-                "x-github-event": event.eventName,
-                "x-github-delivery": randomUUID(),
+            return {
+                label: targetLabel(target),
+                status: response.status,
+                ok: response.ok,
             };
-            if (secret !== undefined && secret !== "") {
-                headers["x-hub-signature-256"] = `sha256=${signGitHubWebhookBody({ secret, body })}`;
-            }
-            if (options.out !== undefined) {
-                const file = yield writeReplayFixture(options.out, event);
-                process.stderr.write(`[bdk] wrote ${file}\n`);
-            }
-            const label = eventLabel(event);
-            if (options.dryRun === true) {
-                report.push(Object.assign(Object.assign({}, eventReport(event)), { payload: event.payload }));
-                if (options.json !== true) {
-                    process.stdout.write(`--- ${label} ---\n${JSON.stringify(event.payload, null, 2)}\n`);
-                }
-                continue;
-            }
-            const deliveries = yield deliverReplayEvent(body, headers, event.eventName, targets);
-            if (deliveries.length === 0 || deliveries.some(delivery => !delivery.ok)) {
-                anyRejected = true;
-            }
-            report.push(Object.assign(Object.assign({}, eventReport(event)), { deliveries }));
-            if (options.json !== true) {
-                const summary = deliveries
-                    .map(delivery => `${delivery.label} ${delivery.status || "ERR"}${delivery.ok ? "" : " (rejected)"}`)
-                    .join(", ") || "(no matching channel)";
-                process.stderr.write(`[bdk]   ${label} → ${summary}\n`);
-            }
         }
-        if (options.json === true) {
-            process.stdout.write(`${JSON.stringify({ pr: ref.label, dryRun: options.dryRun === true, events: report }, null, 2)}\n`);
+        catch (error) {
+            return {
+                label: targetLabel(target),
+                status: 0,
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
         }
-        return anyRejected ? 1 : 0;
-    });
-}
-/** POST one synthesized event to every channel whose event set matches. */
-function deliverReplayEvent(body, headers, eventName, targets) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const recipients = targets.filter(target => target.events.length === 0 || target.events.includes(eventName));
-        const payload = new Uint8Array(body);
-        // Bounded by the channel count (a handful) — see fanoutDelivery.
-        return Promise.all(recipients.map((target) => __awaiter(this, void 0, void 0, function* () {
-            try {
-                const response = yield fetch(target.url, {
-                    method: "POST",
-                    headers,
-                    body: payload,
-                });
-                return {
-                    label: targetLabel(target),
-                    status: response.status,
-                    ok: response.ok,
-                };
-            }
-            catch (error) {
-                return {
-                    label: targetLabel(target),
-                    status: 0,
-                    ok: false,
-                    error: error instanceof Error ? error.message : String(error),
-                };
-            }
-        })));
-    });
+    }));
 }
 function eventLabel(event) {
     return event.action === undefined ? event.eventName : `${event.eventName}.${event.action}`;
@@ -357,159 +337,145 @@ function eventReport(event) {
     return { event: event.eventName, action: event.action };
 }
 /** GET `gh api <path>` and parse JSON (throws on non-zero exit). */
-function ghApiJson(path) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { stdout } = yield execFileAsync("gh", [
-            "api",
-            path,
-            "-H",
-            "Accept: application/vnd.github+json",
-        ]);
-        return JSON.parse(stdout);
-    });
+async function ghApiJson(path) {
+    const { stdout } = await execFileAsync("gh", [
+        "api",
+        path,
+        "-H",
+        "Accept: application/vnd.github+json",
+    ]);
+    return JSON.parse(stdout);
 }
-function fetchReplayCheck(ref, sha) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        try {
-            const data = yield ghApiJson(`repos/${ref.owner}/${ref.repo}/commits/${sha}/check-runs?per_page=100`);
-            const runs = (_a = data.check_runs) !== null && _a !== void 0 ? _a : [];
-            const chosen = (_b = runs.find(run => run.conclusion === "failure")) !== null && _b !== void 0 ? _b : runs[0];
-            if (chosen === undefined) {
-                return undefined;
-            }
-            return {
-                id: chosen.id,
-                name: chosen.name,
-                conclusion: chosen.conclusion,
-                app: chosen.app,
-            };
-        }
-        catch (_c) {
+async function fetchReplayCheck(ref, sha) {
+    try {
+        const data = await ghApiJson(`repos/${ref.owner}/${ref.repo}/commits/${sha}/check-runs?per_page=100`);
+        const runs = data.check_runs ?? [];
+        const chosen = runs.find(run => run.conclusion === "failure") ?? runs[0];
+        if (chosen === undefined) {
             return undefined;
         }
-    });
+        return {
+            id: chosen.id,
+            name: chosen.name,
+            conclusion: chosen.conclusion,
+            app: chosen.app,
+        };
+    }
+    catch {
+        return undefined;
+    }
 }
-function writeReplayFixture(outDir, event) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const dir = resolvePath(outDir);
-        yield mkdir(dir, { recursive: true });
-        const file = join(dir, `${eventLabel(event)}.json`);
-        yield writeFile(file, `${JSON.stringify(event.payload, null, 2)}\n`);
-        return file;
-    });
+async function writeReplayFixture(outDir, event) {
+    const dir = resolvePath(outDir);
+    await mkdir(dir, { recursive: true });
+    const file = join(dir, `${eventLabel(event)}.json`);
+    await writeFile(file, `${JSON.stringify(event.payload, null, 2)}\n`);
+    return file;
 }
-function cmdGithubEvents(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const dir = resolvePath(options.dir);
-        const targets = findGitHubChannelTargets(yield resolveAgentMounts(dir));
-        const host = (_a = options.host) !== null && _a !== void 0 ? _a : DEFAULT_HOST;
-        const port = (_b = options.port) !== null && _b !== void 0 ? _b : DEFAULT_PORT;
-        const urlFor = (t) => channelForwardUrl({
-            host,
-            port,
-            slug: t.slug,
-            channelId: t.channelId,
-            routePath: t.routePath,
-        });
-        if (options.json) {
-            process.stdout.write(`${JSON.stringify({
-                channels: targets.map(t => ({
-                    slug: t.slug,
-                    channelId: t.channelId,
-                    url: urlFor(t),
-                    events: t.events,
-                })),
-            }, null, 2)}\n`);
-            return 0;
-        }
-        if (targets.length === 0) {
-            const channelPath = projectPath(resolveProjectRoot(dir), "channels/github.ts");
-            process.stdout.write(`no GitHub channels found (author ${channelPath} with githubChannel())\n`);
-            return 0;
-        }
-        for (const t of targets) {
-            const label = t.slug === "" ? t.channelId : `${t.slug}/${t.channelId}`;
-            process.stdout.write(`${label}\n  url:    ${urlFor(t)}\n  events: ${t.events.join(", ") || "none"}\n`);
-        }
-        return 0;
+async function cmdGithubEvents(options) {
+    const dir = resolvePath(options.dir);
+    const targets = findGitHubChannelTargets(await resolveAgentMounts(dir));
+    const host = options.host ?? DEFAULT_HOST;
+    const port = options.port ?? DEFAULT_PORT;
+    const urlFor = (t) => channelForwardUrl({
+        host,
+        port,
+        slug: t.slug,
+        channelId: t.channelId,
+        routePath: t.routePath,
     });
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({
+            channels: targets.map(t => ({
+                slug: t.slug,
+                channelId: t.channelId,
+                url: urlFor(t),
+                events: t.events,
+            })),
+        }, null, 2)}\n`);
+        return 0;
+    }
+    if (targets.length === 0) {
+        const channelPath = projectPath(resolveProjectRoot(dir), "channels/github.ts");
+        process.stdout.write(`no GitHub channels found (author ${channelPath} with githubChannel())\n`);
+        return 0;
+    }
+    for (const t of targets) {
+        const label = t.slug === "" ? t.channelId : `${t.slug}/${t.channelId}`;
+        process.stdout.write(`${label}\n  url:    ${urlFor(t)}\n  events: ${t.events.join(", ") || "none"}\n`);
+    }
+    return 0;
 }
-function cmdGithubDoctor(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        var _b, _c, _d, _e;
-        const checks = [];
-        const version = yield tryExec({ command: "gh", args: ["--version"] });
-        if (version === undefined) {
-            checks.push({
-                id: "gh",
-                ok: false,
-                message: "gh CLI not found — install from https://cli.github.com",
-            });
-            return reportDoctor(checks, options.json);
-        }
+async function cmdGithubDoctor(options) {
+    const checks = [];
+    const version = await tryExec({ command: "gh", args: ["--version"] });
+    if (version === undefined) {
         checks.push({
             id: "gh",
-            ok: true,
-            message: (_b = (_a = version.split("\n")[0]) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : "gh present",
+            ok: false,
+            message: "gh CLI not found — install from https://cli.github.com",
         });
-        const auth = yield tryExec({ command: "gh", args: ["auth", "status"] });
-        checks.push({
-            id: "auth",
-            ok: auth !== undefined,
-            message: auth !== undefined ? "gh auth status ok" : "not logged in — run `gh auth login`",
+        return reportDoctor(checks, options.json);
+    }
+    checks.push({
+        id: "gh",
+        ok: true,
+        message: version.split("\n")[0]?.trim() ?? "gh present",
+    });
+    const auth = await tryExec({ command: "gh", args: ["auth", "status"] });
+    checks.push({
+        id: "auth",
+        ok: auth !== undefined,
+        message: auth !== undefined ? "gh auth status ok" : "not logged in — run `gh auth login`",
+    });
+    let extensionList = (await tryExec({ command: "gh", args: ["extension", "list"] })) ?? "";
+    let installed = parseGhWebhookExtensionInstalled(extensionList);
+    let pinOk = installed && ghWebhookExtensionPinSatisfied(extensionList);
+    if ((!installed || !pinOk) && options.install === true) {
+        const install = await tryExec({
+            command: "gh",
+            args: ghWebhookExtensionInstallArgs({ force: installed && !pinOk }),
         });
-        let extensionList = (_c = (yield tryExec({ command: "gh", args: ["extension", "list"] }))) !== null && _c !== void 0 ? _c : "";
-        let installed = parseGhWebhookExtensionInstalled(extensionList);
-        let pinOk = installed && ghWebhookExtensionPinSatisfied(extensionList);
-        if ((!installed || !pinOk) && options.install === true) {
-            const install = yield tryExec({
-                command: "gh",
-                args: ghWebhookExtensionInstallArgs({ force: installed && !pinOk }),
-            });
-            if (install !== undefined) {
-                extensionList = (_d = (yield tryExec({ command: "gh", args: ["extension", "list"] }))) !== null && _d !== void 0 ? _d : "";
-                installed = parseGhWebhookExtensionInstalled(extensionList);
-                pinOk = installed && ghWebhookExtensionPinSatisfied(extensionList);
-            }
-            else {
-                installed = false;
-                pinOk = false;
-            }
-            checks.push({
-                id: "install",
-                ok: installed && pinOk,
-                message: installed && pinOk
-                    ? `installed ${GITHUB_WEBHOOK_EXTENSION}@${GITHUB_WEBHOOK_EXTENSION_PIN}`
-                    : `failed to install ${GITHUB_WEBHOOK_EXTENSION}@${GITHUB_WEBHOOK_EXTENSION_PIN}`,
-            });
+        if (install !== undefined) {
+            extensionList = (await tryExec({ command: "gh", args: ["extension", "list"] })) ?? "";
+            installed = parseGhWebhookExtensionInstalled(extensionList);
+            pinOk = installed && ghWebhookExtensionPinSatisfied(extensionList);
+        }
+        else {
+            installed = false;
+            pinOk = false;
         }
         checks.push({
-            id: "extension",
+            id: "install",
             ok: installed && pinOk,
             message: installed && pinOk
-                ? `${GITHUB_WEBHOOK_EXTENSION}@${GITHUB_WEBHOOK_EXTENSION_PIN} installed`
-                : !installed
-                    ? `${GITHUB_WEBHOOK_EXTENSION} missing — run \`${CLI} github doctor --install\``
-                    : `${GITHUB_WEBHOOK_EXTENSION} is ${(_e = parseGhWebhookExtensionVersion(extensionList)) !== null && _e !== void 0 ? _e : "unknown"} (need ${GITHUB_WEBHOOK_EXTENSION_PIN}) — run \`${CLI} github doctor --install\``,
+                ? `installed ${GITHUB_WEBHOOK_EXTENSION}@${GITHUB_WEBHOOK_EXTENSION_PIN}`
+                : `failed to install ${GITHUB_WEBHOOK_EXTENSION}@${GITHUB_WEBHOOK_EXTENSION_PIN}`,
         });
-        const envToken = detectGitHubEnvTokenOverride();
-        checks.push(envToken === undefined
-            ? {
-                id: "env_token",
-                ok: true,
-                message: "no GITHUB_TOKEN/GH_TOKEN override (gh uses its own login)",
-            }
-            : {
-                id: "env_token",
-                ok: false,
-                warn: true,
-                message: githubEnvTokenHint(envToken),
-            });
-        return reportDoctor(checks, options.json);
+    }
+    checks.push({
+        id: "extension",
+        ok: installed && pinOk,
+        message: installed && pinOk
+            ? `${GITHUB_WEBHOOK_EXTENSION}@${GITHUB_WEBHOOK_EXTENSION_PIN} installed`
+            : !installed
+                ? `${GITHUB_WEBHOOK_EXTENSION} missing — run \`${CLI} github doctor --install\``
+                : `${GITHUB_WEBHOOK_EXTENSION} is ${parseGhWebhookExtensionVersion(extensionList) ?? "unknown"} (need ${GITHUB_WEBHOOK_EXTENSION_PIN}) — run \`${CLI} github doctor --install\``,
     });
+    const envToken = detectGitHubEnvTokenOverride();
+    checks.push(envToken === undefined
+        ? {
+            id: "env_token",
+            ok: true,
+            message: "no GITHUB_TOKEN/GH_TOKEN override (gh uses its own login)",
+        }
+        : {
+            id: "env_token",
+            ok: false,
+            warn: true,
+            message: githubEnvTokenHint(envToken),
+        });
+    return reportDoctor(checks, options.json);
 }
 function reportDoctor(checks, json) {
     // Warnings (e.g. an env-token override) are advisory and do not fail doctor.
@@ -526,82 +492,77 @@ function reportDoctor(checks, json) {
     }
     return ok ? 0 : 1;
 }
-function ensureWebhookExtension(install) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
-        if ((yield tryExec({ command: "gh", args: ["--version"] })) === undefined) {
-            return {
-                ok: false,
-                message: "gh CLI not found — install from https://cli.github.com, then `gh auth login`",
-            };
-        }
-        const list = (_a = (yield tryExec({ command: "gh", args: ["extension", "list"] }))) !== null && _a !== void 0 ? _a : "";
-        const installed = parseGhWebhookExtensionInstalled(list);
-        const pinOk = installed && ghWebhookExtensionPinSatisfied(list);
-        if (installed && pinOk) {
-            return { ok: true, message: "" };
-        }
-        if (!install) {
-            return {
-                ok: false,
-                message: !installed
-                    ? `${GITHUB_WEBHOOK_EXTENSION} not installed — run \`gh extension install ${GITHUB_WEBHOOK_EXTENSION} --pin ${GITHUB_WEBHOOK_EXTENSION_PIN}\` or re-run with --install`
-                    : `${GITHUB_WEBHOOK_EXTENSION} is ${(_b = parseGhWebhookExtensionVersion(list)) !== null && _b !== void 0 ? _b : "unknown"} (need ${GITHUB_WEBHOOK_EXTENSION_PIN}) — re-run with --install`,
-            };
-        }
-        process.stderr.write(`[bdk] installing ${GITHUB_WEBHOOK_EXTENSION}@${GITHUB_WEBHOOK_EXTENSION_PIN}…\n`);
-        if ((yield tryExec({
-            command: "gh",
-            args: ghWebhookExtensionInstallArgs({ force: installed && !pinOk }),
-        })) === undefined) {
-            return {
-                ok: false,
-                message: `failed to install ${GITHUB_WEBHOOK_EXTENSION}@${GITHUB_WEBHOOK_EXTENSION_PIN}`,
-            };
-        }
-        const listAfter = (_c = (yield tryExec({ command: "gh", args: ["extension", "list"] }))) !== null && _c !== void 0 ? _c : "";
-        const installedAfter = parseGhWebhookExtensionInstalled(listAfter);
-        const pinOkAfter = installedAfter && ghWebhookExtensionPinSatisfied(listAfter);
-        if (!installedAfter || !pinOkAfter) {
-            return {
-                ok: false,
-                message: !installedAfter
-                    ? `${GITHUB_WEBHOOK_EXTENSION} missing after install`
-                    : `${GITHUB_WEBHOOK_EXTENSION} is ${(_d = parseGhWebhookExtensionVersion(listAfter)) !== null && _d !== void 0 ? _d : "unknown"} after install (need ${GITHUB_WEBHOOK_EXTENSION_PIN})`,
-            };
-        }
+async function ensureWebhookExtension(install) {
+    if ((await tryExec({ command: "gh", args: ["--version"] })) === undefined) {
+        return {
+            ok: false,
+            message: "gh CLI not found — install from https://cli.github.com, then `gh auth login`",
+        };
+    }
+    const list = (await tryExec({ command: "gh", args: ["extension", "list"] })) ?? "";
+    const installed = parseGhWebhookExtensionInstalled(list);
+    const pinOk = installed && ghWebhookExtensionPinSatisfied(list);
+    if (installed && pinOk) {
         return { ok: true, message: "" };
-    });
+    }
+    if (!install) {
+        return {
+            ok: false,
+            message: !installed
+                ? `${GITHUB_WEBHOOK_EXTENSION} not installed — run \`gh extension install ${GITHUB_WEBHOOK_EXTENSION} --pin ${GITHUB_WEBHOOK_EXTENSION_PIN}\` or re-run with --install`
+                : `${GITHUB_WEBHOOK_EXTENSION} is ${parseGhWebhookExtensionVersion(list) ?? "unknown"} (need ${GITHUB_WEBHOOK_EXTENSION_PIN}) — re-run with --install`,
+        };
+    }
+    process.stderr.write(`[bdk] installing ${GITHUB_WEBHOOK_EXTENSION}@${GITHUB_WEBHOOK_EXTENSION_PIN}…\n`);
+    if ((await tryExec({
+        command: "gh",
+        args: ghWebhookExtensionInstallArgs({ force: installed && !pinOk }),
+    })) === undefined) {
+        return {
+            ok: false,
+            message: `failed to install ${GITHUB_WEBHOOK_EXTENSION}@${GITHUB_WEBHOOK_EXTENSION_PIN}`,
+        };
+    }
+    const listAfter = (await tryExec({ command: "gh", args: ["extension", "list"] })) ?? "";
+    const installedAfter = parseGhWebhookExtensionInstalled(listAfter);
+    const pinOkAfter = installedAfter && ghWebhookExtensionPinSatisfied(listAfter);
+    if (!installedAfter || !pinOkAfter) {
+        return {
+            ok: false,
+            message: !installedAfter
+                ? `${GITHUB_WEBHOOK_EXTENSION} missing after install`
+                : `${GITHUB_WEBHOOK_EXTENSION} is ${parseGhWebhookExtensionVersion(listAfter) ?? "unknown"} after install (need ${GITHUB_WEBHOOK_EXTENSION_PIN})`,
+        };
+    }
+    return { ok: true, message: "" };
 }
-function inferRepo(dir) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const viaGh = yield tryExec({
-            command: "gh",
-            args: ["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"],
-            cwd: dir,
-        });
-        const trimmed = viaGh === null || viaGh === void 0 ? void 0 : viaGh.trim();
-        if (trimmed !== undefined && trimmed !== "") {
-            return trimmed;
-        }
-        const remote = yield tryExec({
-            command: "git",
-            args: ["-C", dir, "remote", "get-url", "origin"],
-        });
-        return remote === undefined ? undefined : parseRepoFromRemoteUrl(remote);
+async function inferRepo(dir) {
+    const viaGh = await tryExec({
+        command: "gh",
+        args: ["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"],
+        cwd: dir,
     });
+    const trimmed = viaGh?.trim();
+    if (trimmed !== undefined && trimmed !== "") {
+        return trimmed;
+    }
+    const remote = await tryExec({
+        command: "git",
+        args: ["-C", dir, "remote", "get-url", "origin"],
+    });
+    return remote === undefined ? undefined : parseRepoFromRemoteUrl(remote);
 }
 /** Run a command, returning stdout on success or undefined on any failure. */
-function tryExec(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const { stdout } = yield execFileAsync(options.command, options.args, Object.assign({}, (options.cwd === undefined ? {} : { cwd: options.cwd })));
-            return stdout;
-        }
-        catch (_a) {
-            return undefined;
-        }
-    });
+async function tryExec(options) {
+    try {
+        const { stdout } = await execFileAsync(options.command, options.args, {
+            ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+        });
+        return stdout;
+    }
+    catch {
+        return undefined;
+    }
 }
 function spawnGh(args) {
     return new Promise(resolve => {
@@ -618,7 +579,7 @@ function spawnGh(args) {
             resolve(1);
         });
         child.on("exit", (code, signal) => {
-            resolve(code !== null && code !== void 0 ? code : (signal === null ? 0 : 130));
+            resolve(code ?? (signal === null ? 0 : 130));
         });
     });
 }