@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/frontmatter.js

@@ -8,15 +8,14 @@ const FRONTMATTER_OPEN = /^---\s*$/;
 const YAML_FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/;
 /** YAML frontmatter with the JSON schema (no custom tags). */
 export function parseYamlFrontmatter(source) {
-    var _a, _b;
     const match = YAML_FRONTMATTER.exec(source);
     if (match === null) {
         return { data: {}, body: source };
     }
-    const body = (_a = match[2]) !== null && _a !== void 0 ? _a : "";
+    const body = match[2] ?? "";
     let data;
     try {
-        data = parseYaml((_b = match[1]) !== null && _b !== void 0 ? _b : "", { schema: JSON_SCHEMA });
+        data = parseYaml(match[1] ?? "", { schema: JSON_SCHEMA });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -31,14 +30,13 @@ export function parseYamlFrontmatter(source) {
     return { data: data, body };
 }
 export function parseFrontmatter(source) {
-    var _a, _b;
     const lines = source.split(/\r?\n/);
-    if (lines.length === 0 || !FRONTMATTER_OPEN.test((_a = lines[0]) !== null && _a !== void 0 ? _a : "")) {
+    if (lines.length === 0 || !FRONTMATTER_OPEN.test(lines[0] ?? "")) {
         return { data: {}, body: source };
     }
     let closeIndex = -1;
     for (let i = 1; i < lines.length; i++) {
-        if (FRONTMATTER_OPEN.test((_b = lines[i]) !== null && _b !== void 0 ? _b : "")) {
+        if (FRONTMATTER_OPEN.test(lines[i] ?? "")) {
             closeIndex = i;
             break;
         }

package/dist/internal/github-fanout.js

@@ -8,15 +8,6 @@
  * still pass — to every channel whose declared event set matches the
  * delivery's `x-github-event`.
  */
-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 { createServer } from "node:http";
 import { targetLabel } from "../channels/github/forward.js";
 /** Request headers copied verbatim from gh onto each fanned-out delivery. */
@@ -31,25 +22,23 @@ export const FANOUT_FORWARD_HEADERS = [
     "accept",
 ];
 /** Start a loopback proxy that fans deliveries out to {@link targets}. */
-export function startFanoutServer(targets_1) {
-    return __awaiter(this, arguments, void 0, function* (targets, options = {}) {
-        const server = createServer((req, res) => {
-            handleFanoutRequest(req, res, targets, options);
-        });
-        yield new Promise((resolve, reject) => {
-            server.once("error", reject);
-            server.listen(0, "127.0.0.1", () => {
-                resolve();
-            });
+export async function startFanoutServer(targets, options = {}) {
+    const server = createServer((req, res) => {
+        handleFanoutRequest(req, res, targets, options);
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            resolve();
         });
-        const address = server.address();
-        return {
-            url: `http://127.0.0.1:${address.port}`,
-            close: () => {
-                server.close();
-            },
-        };
     });
+    const address = server.address();
+    return {
+        url: `http://127.0.0.1:${address.port}`,
+        close: () => {
+            server.close();
+        },
+    };
 }
 function handleFanoutRequest(req, res, targets, options) {
     const chunks = [];
@@ -76,45 +65,42 @@ function handleFanoutRequest(req, res, targets, options) {
  * accepted it. Only targets whose event set includes the delivery's
  * `x-github-event` receive it (all of them when the header is absent).
  */
-export function fanoutDelivery(body_1, headers_1, targets_1) {
-    return __awaiter(this, arguments, void 0, function* (body, headers, targets, options = {}) {
-        var _a;
-        const log = (_a = options.logger) !== null && _a !== void 0 ? _a : (line => process.stderr.write(line));
-        const event = typeof headers["x-github-event"] === "string" ? headers["x-github-event"] : undefined;
-        const outbound = {};
-        for (const name of FANOUT_FORWARD_HEADERS) {
-            const value = headers[name];
-            if (typeof value === "string") {
-                outbound[name] = value;
-            }
+export async function fanoutDelivery(body, headers, targets, options = {}) {
+    const log = options.logger ?? (line => process.stderr.write(line));
+    const event = typeof headers["x-github-event"] === "string" ? headers["x-github-event"] : undefined;
+    const outbound = {};
+    for (const name of FANOUT_FORWARD_HEADERS) {
+        const value = headers[name];
+        if (typeof value === "string") {
+            outbound[name] = value;
         }
-        const recipients = targets.filter(target => event === undefined || target.events.includes(event));
-        // Reuse one Uint8Array view across recipients (Buffer isn't a BodyInit).
-        const payload = new Uint8Array(body);
-        const delivered = [];
-        // Bounded by the number of GitHub channels in the project (a handful), so
-        // unbounded-concurrency concerns do not apply here.
-        yield Promise.all(recipients.map((target) => __awaiter(this, void 0, void 0, function* () {
-            const label = targetLabel(target);
-            try {
-                const response = yield fetch(target.url, {
-                    method: "POST",
-                    headers: outbound,
-                    body: payload,
-                });
-                if (!response.ok) {
-                    log(`[bdk] delivery to ${label} failed: HTTP ${response.status}\n`);
-                    return;
-                }
-                delivered.push(label);
-            }
-            catch (error) {
-                log(`[bdk] delivery to ${label} failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    }
+    const recipients = targets.filter(target => event === undefined || target.events.includes(event));
+    // Reuse one Uint8Array view across recipients (Buffer isn't a BodyInit).
+    const payload = new Uint8Array(body);
+    const delivered = [];
+    // Bounded by the number of GitHub channels in the project (a handful), so
+    // unbounded-concurrency concerns do not apply here.
+    await Promise.all(recipients.map(async (target) => {
+        const label = targetLabel(target);
+        try {
+            const response = await fetch(target.url, {
+                method: "POST",
+                headers: outbound,
+                body: payload,
+            });
+            if (!response.ok) {
+                log(`[bdk] delivery to ${label} failed: HTTP ${response.status}\n`);
+                return;
             }
-        })));
-        if (recipients.length > 0 && delivered.length === 0) {
-            throw new Error(`fan-out delivery failed for all ${recipients.length} matching channel(s)`);
+            delivered.push(label);
         }
-        return delivered;
-    });
+        catch (error) {
+            log(`[bdk] delivery to ${label} failed: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+    }));
+    if (recipients.length > 0 && delivered.length === 0) {
+        throw new Error(`fan-out delivery failed for all ${recipients.length} matching channel(s)`);
+    }
+    return delivered;
 }

package/dist/internal/guest-network.js

@@ -16,15 +16,6 @@
  * not dead NICs. Those become `guest_connect_stalled` so TAS retries the same
  * pod. Untyped errors stay unknown rather than being classified from prose.
  */
-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 { HOSTED_GUEST_RETRY_TRANSIENT } from "./hosted-delivery-protocol.js";
 export const GUEST_NETWORK_UNAVAILABLE = "guest_network_unavailable";
 export const GUEST_CONNECT_STALLED = "guest_connect_stalled";
@@ -35,7 +26,7 @@ export const GUEST_NETWORK_PATH = "/v1/guest-network";
  * at {@link DEFAULT_WAIT_TIMEOUT_MS}; this budget is for GET `/v1/guest-network`
  * so TAS does not open a hosted turn on a dead NIC.
  */
-export const GUEST_NETWORK_READY_WAIT_TIMEOUT_MS = 90000;
+export const GUEST_NETWORK_READY_WAIT_TIMEOUT_MS = 90_000;
 /**
  * Node/undici codes that mean the request never produced an HTTP response.
  * `ENOTFOUND`/`EAI_AGAIN` cover restored-pod DNS races.
@@ -57,12 +48,11 @@ const TRANSIENT_NETWORK_ERROR_CODES = new Set([
 const MAX_CAUSE_DEPTH = 8;
 export class GuestNetworkUnavailableError extends Error {
     constructor(message = "Guest network is not ready for outbound requests.", extras = {}) {
-        var _a, _b;
         super(message);
         this.code = GUEST_NETWORK_UNAVAILABLE;
         this.name = "GuestNetworkUnavailableError";
-        this.waitMs = (_a = extras.waitMs) !== null && _a !== void 0 ? _a : 0;
-        this.probeAttempts = (_b = extras.probeAttempts) !== null && _b !== void 0 ? _b : 0;
+        this.waitMs = extras.waitMs ?? 0;
+        this.probeAttempts = extras.probeAttempts ?? 0;
     }
 }
 class GuestNetworkProbeFailedError extends Error {
@@ -179,9 +169,9 @@ function isTransientAtDepth(error, depth) {
     }
     return isTransientAtDepth(error.cause, depth + 1);
 }
-const DEFAULT_PROBE_TIMEOUT_MS = 2000;
+const DEFAULT_PROBE_TIMEOUT_MS = 2_000;
 /** Last-line wait inside an already-open hosted POST. */
-export const DEFAULT_WAIT_TIMEOUT_MS = 8000;
+export const DEFAULT_WAIT_TIMEOUT_MS = 8_000;
 const DEFAULT_POLL_MS = 250;
 function defaultSleep(ms) {
     return new Promise(resolve => {
@@ -189,9 +179,10 @@ function defaultSleep(ms) {
     });
 }
 function resolveProbeUrl(explicit) {
-    var _a, _b;
-    const raw = (_a = explicit !== null && explicit !== void 0 ? explicit : process.env.AGENT_SERVE_EGRESS_PROBE_URL) !== null && _a !== void 0 ? _a : process.env.AGENT_SERVE_CURSOR_BACKEND_URL;
-    const trimmed = (_b = raw === null || raw === void 0 ? void 0 : raw.trim()) !== null && _b !== void 0 ? _b : "";
+    const raw = explicit ??
+        process.env.AGENT_SERVE_EGRESS_PROBE_URL ??
+        process.env.AGENT_SERVE_CURSOR_BACKEND_URL;
+    const trimmed = raw?.trim() ?? "";
     return trimmed.length > 0 ? trimmed : undefined;
 }
 function waitEnabled(options) {
@@ -206,22 +197,19 @@ function waitEnabled(options) {
     }
     return resolveProbeUrl(options.probeUrl) !== undefined;
 }
-function defaultProbe(probeUrl, probeTimeoutMs) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        try {
-            // Any HTTP response means egress and DNS work. 401/404 are ready.
-            const response = yield fetch(probeUrl, {
-                method: "GET",
-                redirect: "manual",
-                signal: AbortSignal.timeout(probeTimeoutMs),
-            });
-            void ((_a = response.body) === null || _a === void 0 ? void 0 : _a.cancel());
-        }
-        catch (error) {
-            throw new GuestNetworkProbeFailedError(error);
-        }
-    });
+async function defaultProbe(probeUrl, probeTimeoutMs) {
+    try {
+        // Any HTTP response means egress and DNS work. 401/404 are ready.
+        const response = await fetch(probeUrl, {
+            method: "GET",
+            redirect: "manual",
+            signal: AbortSignal.timeout(probeTimeoutMs),
+        });
+        void response.body?.cancel();
+    }
+    catch (error) {
+        throw new GuestNetworkProbeFailedError(error);
+    }
 }
 /**
  * `Server-Timing` metric the control plane scrapes for Datadog
@@ -236,50 +224,48 @@ export function formatGuestNetworkServerTiming(stats) {
  * Throws {@link GuestNetworkUnavailableError} on timeout so hosted routes
  * can return 503 without running authored code.
  */
-export function waitForGuestNetworkReady() {
-    return __awaiter(this, arguments, void 0, function* (options = {}) {
-        var _a, _b, _c, _d, _e;
-        if (!waitEnabled(options)) {
-            return { outcome: "skipped", waitMs: 0, probeAttempts: 0 };
-        }
-        const probeUrl = resolveProbeUrl(options.probeUrl);
-        const probe = (_a = options.probe) !== null && _a !== void 0 ? _a : (probeUrl === undefined
+export async function waitForGuestNetworkReady(options = {}) {
+    if (!waitEnabled(options)) {
+        return { outcome: "skipped", waitMs: 0, probeAttempts: 0 };
+    }
+    const probeUrl = resolveProbeUrl(options.probeUrl);
+    const probe = options.probe ??
+        (probeUrl === undefined
             ? undefined
-            : () => { var _a; return defaultProbe(probeUrl, (_a = options.probeTimeoutMs) !== null && _a !== void 0 ? _a : DEFAULT_PROBE_TIMEOUT_MS); });
-        if (probe === undefined) {
-            return { outcome: "skipped", waitMs: 0, probeAttempts: 0 };
+            : () => defaultProbe(probeUrl, options.probeTimeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS));
+    if (probe === undefined) {
+        return { outcome: "skipped", waitMs: 0, probeAttempts: 0 };
+    }
+    const waitTimeoutMs = options.waitTimeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+    const pollMs = options.pollMs ?? DEFAULT_POLL_MS;
+    const now = options.now ?? Date.now;
+    const sleep = options.sleep ?? defaultSleep;
+    const startedAt = now();
+    let lastError;
+    let probeAttempts = 0;
+    for (;;) {
+        probeAttempts += 1;
+        try {
+            await probe();
+            return {
+                outcome: "ready",
+                waitMs: Math.max(0, now() - startedAt),
+                probeAttempts,
+            };
         }
-        const waitTimeoutMs = (_b = options.waitTimeoutMs) !== null && _b !== void 0 ? _b : DEFAULT_WAIT_TIMEOUT_MS;
-        const pollMs = (_c = options.pollMs) !== null && _c !== void 0 ? _c : DEFAULT_POLL_MS;
-        const now = (_d = options.now) !== null && _d !== void 0 ? _d : Date.now;
-        const sleep = (_e = options.sleep) !== null && _e !== void 0 ? _e : defaultSleep;
-        const startedAt = now();
-        let lastError;
-        let probeAttempts = 0;
-        for (;;) {
-            probeAttempts += 1;
-            try {
-                yield probe();
-                return {
-                    outcome: "ready",
-                    waitMs: Math.max(0, now() - startedAt),
-                    probeAttempts,
-                };
-            }
-            catch (error) {
-                lastError = error;
-                if (!isTransientGuestNetworkError(error)) {
-                    throw error;
-                }
-            }
-            const elapsedMs = now() - startedAt;
-            if (elapsedMs >= waitTimeoutMs) {
-                const detail = lastError instanceof Error ? lastError.message : String(lastError);
-                throw new GuestNetworkUnavailableError(`Guest network did not become ready within ${String(waitTimeoutMs)}ms (${detail}).`, { waitMs: Math.max(0, elapsedMs), probeAttempts });
+        catch (error) {
+            lastError = error;
+            if (!isTransientGuestNetworkError(error)) {
+                throw error;
             }
-            yield sleep(pollMs);
         }
-    });
+        const elapsedMs = now() - startedAt;
+        if (elapsedMs >= waitTimeoutMs) {
+            const detail = lastError instanceof Error ? lastError.message : String(lastError);
+            throw new GuestNetworkUnavailableError(`Guest network did not become ready within ${String(waitTimeoutMs)}ms (${detail}).`, { waitMs: Math.max(0, elapsedMs), probeAttempts });
+        }
+        await sleep(pollMs);
+    }
 }
 /**
  * GET `/v1/guest-network`: wait up to
@@ -287,40 +273,41 @@ export function waitForGuestNetworkReady() {
  * or 503 `guest_network_unavailable`. Server-Timing matches the hosted POST
  * so TAS can scrape the same `guest_net` metric before `postHosted`.
  */
-export function guestNetworkReadinessResponse() {
-    return __awaiter(this, arguments, void 0, function* (options = {}) {
-        try {
-            const result = yield waitForGuestNetworkReady(Object.assign({ waitTimeoutMs: GUEST_NETWORK_READY_WAIT_TIMEOUT_MS }, options));
-            return new Response(JSON.stringify(Object.assign({ ok: true }, result)), {
-                status: 200,
-                headers: {
-                    "content-type": "application/json; charset=utf-8",
-                    "server-timing": formatGuestNetworkServerTiming(result),
-                },
-            });
-        }
-        catch (error) {
-            if (!(error instanceof GuestNetworkUnavailableError)) {
-                throw error;
-            }
-            return new Response(JSON.stringify({
-                ok: false,
-                error: GUEST_NETWORK_UNAVAILABLE,
-                retry: HOSTED_GUEST_RETRY_TRANSIENT,
-                message: error.message,
-                waitMs: error.waitMs,
-                probeAttempts: error.probeAttempts,
-            }), {
-                status: 503,
-                headers: {
-                    "content-type": "application/json; charset=utf-8",
-                    "server-timing": formatGuestNetworkServerTiming({
-                        outcome: "unavailable",
-                        waitMs: error.waitMs,
-                        probeAttempts: error.probeAttempts,
-                    }),
-                },
-            });
+export async function guestNetworkReadinessResponse(options = {}) {
+    try {
+        const result = await waitForGuestNetworkReady({
+            waitTimeoutMs: GUEST_NETWORK_READY_WAIT_TIMEOUT_MS,
+            ...options,
+        });
+        return new Response(JSON.stringify({ ok: true, ...result }), {
+            status: 200,
+            headers: {
+                "content-type": "application/json; charset=utf-8",
+                "server-timing": formatGuestNetworkServerTiming(result),
+            },
+        });
+    }
+    catch (error) {
+        if (!(error instanceof GuestNetworkUnavailableError)) {
+            throw error;
         }
-    });
+        return new Response(JSON.stringify({
+            ok: false,
+            error: GUEST_NETWORK_UNAVAILABLE,
+            retry: HOSTED_GUEST_RETRY_TRANSIENT,
+            message: error.message,
+            waitMs: error.waitMs,
+            probeAttempts: error.probeAttempts,
+        }), {
+            status: 503,
+            headers: {
+                "content-type": "application/json; charset=utf-8",
+                "server-timing": formatGuestNetworkServerTiming({
+                    outcome: "unavailable",
+                    waitMs: error.waitMs,
+                    probeAttempts: error.probeAttempts,
+                }),
+            },
+        });
+    }
 }