@cursor/bdk 0.2.8 → 0.2.10

package/dist/internal/local-control-plane.js

@@ -14,338 +14,324 @@
  * owns the `/v0/scm-events` long poll. v1 keeps engine-side scm-events.
  * Hosted `--no-control-plane` v2 skips that poll — the hosted CP delivers.
  */
-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 { join } from "node:path";
 import { parseCron } from "./cron.js";
 import { routeLocalIngressContinuation, } from "./local-ingress.js";
 import { applyOutcomeToRecord, claimFromDescriptor, intentToNewRecord, REMINDER_CP_PROTOCOL_VERSION, recordGeneration, toFireDescriptor, } from "./reminder-control-plane-protocol.js";
 import { MAX_TIMER_MS } from "./reminder-schedule.js";
 import { ReminderStore } from "./reminder-store.js";
-export function createLocalControlPlane(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        if (opts.fireReminder === undefined && opts.executeReminder === undefined) {
-            throw new Error("createLocalControlPlane requires fireReminder and/or executeReminder");
+export async function createLocalControlPlane(opts) {
+    if (opts.fireReminder === undefined && opts.executeReminder === undefined) {
+        throw new Error("createLocalControlPlane requires fireReminder and/or executeReminder");
+    }
+    const logger = opts.logger ?? (() => { });
+    const armReminderClocks = opts.armReminderClocks !== false;
+    const store = opts.stateDir === undefined ? undefined : new ReminderStore(join(opts.stateDir, "reminders"));
+    const schedules = new Map();
+    const reminderTimers = new Map();
+    const reminders = new Map(((await store?.list()) ?? []).map(record => [
+        record.id,
+        { ...record, generation: record.generation ?? 0 },
+    ]));
+    /** In-flight claims keyed by reminder id (single-flight per id). */
+    const inflight = new Map();
+    let scheduleTimer;
+    let lastFiredMinute = -1;
+    let scmRelay;
+    async function persist(record) {
+        reminders.set(record.id, record);
+        await store?.save(record);
+    }
+    function armScheduleTicker() {
+        if (scheduleTimer !== undefined || schedules.size === 0) {
+            return;
         }
-        const logger = (_a = opts.logger) !== null && _a !== void 0 ? _a : (() => { });
-        const armReminderClocks = opts.armReminderClocks !== false;
-        const store = opts.stateDir === undefined ? undefined : new ReminderStore(join(opts.stateDir, "reminders"));
-        const schedules = new Map();
-        const reminderTimers = new Map();
-        const reminders = new Map(((_b = (yield store === null || store === void 0 ? void 0 : store.list())) !== null && _b !== void 0 ? _b : []).map(record => { var _a; return [
-            record.id,
-            Object.assign(Object.assign({}, record), { generation: (_a = record.generation) !== null && _a !== void 0 ? _a : 0 }),
-        ]; }));
-        /** In-flight claims keyed by reminder id (single-flight per id). */
-        const inflight = new Map();
-        let scheduleTimer;
-        let lastFiredMinute = -1;
-        let scmRelay;
-        function persist(record) {
-            return __awaiter(this, void 0, void 0, function* () {
-                reminders.set(record.id, record);
-                yield store === null || store === void 0 ? void 0 : store.save(record);
-            });
+        const now = Date.now();
+        const nextMinute = (Math.floor(now / 60_000) + 1) * 60_000;
+        scheduleTimer = setTimeout(() => tickSchedules(), nextMinute - now + 250);
+        scheduleTimer.unref?.();
+    }
+    function stopScheduleTicker() {
+        if (scheduleTimer === undefined) {
+            return;
         }
-        function armScheduleTicker() {
-            var _a;
-            if (scheduleTimer !== undefined || schedules.size === 0) {
-                return;
+        clearTimeout(scheduleTimer);
+        scheduleTimer = undefined;
+    }
+    function tickSchedules() {
+        scheduleTimer = undefined;
+        const now = new Date();
+        const minute = Math.floor(now.getTime() / 60_000);
+        if (minute !== lastFiredMinute) {
+            lastFiredMinute = minute;
+            for (const [name, cron] of schedules) {
+                if (!cron.matches(now)) {
+                    continue;
+                }
+                void opts.fireSchedule(name).catch(error => {
+                    logger(`[bdk] schedule "${name}" dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
             }
-            const now = Date.now();
-            const nextMinute = (Math.floor(now / 60000) + 1) * 60000;
-            scheduleTimer = setTimeout(() => tickSchedules(), nextMinute - now + 250);
-            (_a = scheduleTimer.unref) === null || _a === void 0 ? void 0 : _a.call(scheduleTimer);
         }
-        function stopScheduleTicker() {
-            if (scheduleTimer === undefined) {
-                return;
-            }
-            clearTimeout(scheduleTimer);
-            scheduleTimer = undefined;
+        armScheduleTicker();
+    }
+    function clearReminderTimer(id) {
+        const timer = reminderTimers.get(id);
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            reminderTimers.delete(id);
         }
-        function tickSchedules() {
-            scheduleTimer = undefined;
-            const now = new Date();
-            const minute = Math.floor(now.getTime() / 60000);
-            if (minute !== lastFiredMinute) {
-                lastFiredMinute = minute;
-                for (const [name, cron] of schedules) {
-                    if (!cron.matches(now)) {
-                        continue;
-                    }
-                    void opts.fireSchedule(name).catch(error => {
-                        logger(`[bdk] schedule "${name}" dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
-                    });
-                }
-            }
-            armScheduleTicker();
+    }
+    function armReminder(record) {
+        clearReminderTimer(record.id);
+        if (record.status !== "armed") {
+            return;
+        }
+        const delay = Math.min(MAX_TIMER_MS, Math.max(0, record.nextFireAtMs - Date.now()));
+        const timer = setTimeout(() => {
+            reminderTimers.delete(record.id);
+            void onReminderDue(record.id).catch(error => {
+                logger(`[bdk] reminder "${record.id}" dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }, delay);
+        timer.unref?.();
+        reminderTimers.set(record.id, timer);
+    }
+    async function claimDue(id) {
+        const current = reminders.get(id);
+        if (current === undefined || current.status !== "armed") {
+            return undefined;
+        }
+        if (current.nextFireAtMs > Date.now() + 50) {
+            armReminder(current);
+            return undefined;
         }
-        function clearReminderTimer(id) {
-            const timer = reminderTimers.get(id);
-            if (timer !== undefined) {
-                clearTimeout(timer);
-                reminderTimers.delete(id);
+        if (inflight.has(id)) {
+            return undefined;
+        }
+        const claimed = {
+            ...current,
+            status: "firing",
+            generation: recordGeneration(current),
+            updatedAt: new Date().toISOString(),
+        };
+        await persist(claimed);
+        inflight.set(id, {
+            id: claimed.id,
+            fireCount: claimed.fireCount,
+            generation: recordGeneration(claimed),
+        });
+        return claimed;
+    }
+    async function applyReminderOutcome(claim, outcome) {
+        const current = reminders.get(claim.id);
+        if (current === undefined) {
+            inflight.delete(claim.id);
+            return { applied: false, reason: "missing" };
+        }
+        const result = applyOutcomeToRecord(current, claim, outcome);
+        inflight.delete(claim.id);
+        if (!result.applied) {
+            if (current.status === "armed" && armReminderClocks) {
+                armReminder(current);
             }
+            return result;
+        }
+        await persist(result.record);
+        if (armReminderClocks && result.record.status === "armed") {
+            armReminder(result.record);
         }
-        function armReminder(record) {
-            var _a;
-            clearReminderTimer(record.id);
-            if (record.status !== "armed") {
+        else {
+            clearReminderTimer(result.record.id);
+        }
+        return result;
+    }
+    async function onReminderDue(id) {
+        // Protocol path: claim → guest execute → CAS apply.
+        if (opts.executeReminder !== undefined) {
+            const claimed = await claimDue(id);
+            if (claimed === undefined) {
                 return;
             }
-            const delay = Math.min(MAX_TIMER_MS, Math.max(0, record.nextFireAtMs - Date.now()));
-            const timer = setTimeout(() => {
-                reminderTimers.delete(record.id);
-                void onReminderDue(record.id).catch(error => {
-                    logger(`[bdk] reminder "${record.id}" dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
-                });
-            }, delay);
-            (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
-            reminderTimers.set(record.id, timer);
+            const descriptor = toFireDescriptor(claimed, Date.now());
+            let outcome;
+            try {
+                outcome = await opts.executeReminder(descriptor);
+            }
+            catch (error) {
+                logger(`[bdk] reminder "${id}" guest execution failed: ${error instanceof Error ? error.message : String(error)}`);
+                outcome = {
+                    kind: "retry",
+                    delayMs: 1_000,
+                    reason: "guest_error",
+                };
+            }
+            const result = await applyReminderOutcome(claimFromDescriptor(descriptor), outcome);
+            if (!result.applied) {
+                logger(`[bdk] reminder "${id}" outcome not applied: ${result.reason}`);
+            }
+            return;
         }
-        function claimDue(id) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const current = reminders.get(id);
-                if (current === undefined || current.status !== "armed") {
-                    return undefined;
-                }
-                if (current.nextFireAtMs > Date.now() + 50) {
-                    armReminder(current);
-                    return undefined;
-                }
-                if (inflight.has(id)) {
-                    return undefined;
-                }
-                const claimed = Object.assign(Object.assign({}, current), { status: "firing", generation: recordGeneration(current), updatedAt: new Date().toISOString() });
-                yield persist(claimed);
-                inflight.set(id, {
-                    id: claimed.id,
-                    fireCount: claimed.fireCount,
-                    generation: recordGeneration(claimed),
-                });
-                return claimed;
-            });
+        // Legacy v1: do not claim/firing — runner mutates via putReminder after fire.
+        const current = reminders.get(id);
+        if (current === undefined || current.status !== "armed") {
+            return;
         }
-        function applyReminderOutcome(claim, outcome) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const current = reminders.get(claim.id);
-                if (current === undefined) {
-                    inflight.delete(claim.id);
-                    return { applied: false, reason: "missing" };
-                }
-                const result = applyOutcomeToRecord(current, claim, outcome);
-                inflight.delete(claim.id);
-                if (!result.applied) {
-                    if (current.status === "armed" && armReminderClocks) {
-                        armReminder(current);
-                    }
-                    return result;
-                }
-                yield persist(result.record);
-                if (armReminderClocks && result.record.status === "armed") {
-                    armReminder(result.record);
-                }
-                else {
-                    clearReminderTimer(result.record.id);
-                }
-                return result;
-            });
+        if (current.nextFireAtMs > Date.now() + 50) {
+            armReminder(current);
+            return;
         }
-        function onReminderDue(id) {
-            return __awaiter(this, void 0, void 0, function* () {
-                // Protocol path: claim → guest execute → CAS apply.
-                if (opts.executeReminder !== undefined) {
-                    const claimed = yield claimDue(id);
-                    if (claimed === undefined) {
-                        return;
-                    }
-                    const descriptor = toFireDescriptor(claimed, Date.now());
-                    let outcome;
-                    try {
-                        outcome = yield opts.executeReminder(descriptor);
-                    }
-                    catch (error) {
-                        logger(`[bdk] reminder "${id}" guest execution failed: ${error instanceof Error ? error.message : String(error)}`);
-                        outcome = {
-                            kind: "retry",
-                            delayMs: 1000,
-                            reason: "guest_error",
-                        };
-                    }
-                    const result = yield applyReminderOutcome(claimFromDescriptor(descriptor), outcome);
-                    if (!result.applied) {
-                        logger(`[bdk] reminder "${id}" outcome not applied: ${result.reason}`);
-                    }
-                    return;
-                }
-                // Legacy v1: do not claim/firing — runner mutates via putReminder after fire.
-                const current = reminders.get(id);
-                if (current === undefined || current.status !== "armed") {
-                    return;
+        try {
+            await opts.fireReminder(current.id, current.fireCount);
+        }
+        catch (error) {
+            logger(`[bdk] reminder "${id}" dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return {
+        protocolVersion: REMINDER_CP_PROTOCOL_VERSION,
+        routeContinuation: routeLocalIngressContinuation,
+        attachScmEvents(relay) {
+            scmRelay = relay;
+            relay.start();
+            logger("[bdk] cursor-events: control-plane ingest started");
+        },
+        async upsertSchedule(input) {
+            schedules.set(input.name, parseCron(input.cron));
+            armScheduleTicker();
+        },
+        async deleteSchedule(name) {
+            schedules.delete(name);
+            if (schedules.size === 0) {
+                stopScheduleTicker();
+            }
+        },
+        async putReminder(record) {
+            const normalized = {
+                ...record,
+                generation: record.generation ?? 0,
+            };
+            await persist(normalized);
+            if (armReminderClocks && normalized.status === "armed") {
+                armReminder(normalized);
+                return;
+            }
+            clearReminderTimer(normalized.id);
+            if (normalized.status !== "firing") {
+                inflight.delete(normalized.id);
+            }
+        },
+        async getReminder(id) {
+            return reminders.get(id);
+        },
+        async listReminders() {
+            return [...reminders.values()];
+        },
+        async deleteReminder(id) {
+            clearReminderTimer(id);
+            inflight.delete(id);
+            reminders.delete(id);
+            await store?.delete(id);
+        },
+        async createReminder(intent) {
+            if (intent.protocolVersion !== REMINDER_CP_PROTOCOL_VERSION) {
+                throw new Error(`Unsupported reminder CP protocol version ${String(intent.protocolVersion)}`);
+            }
+            const record = intentToNewRecord(intent);
+            await persist(record);
+            if (armReminderClocks && record.status === "armed") {
+                armReminder(record);
+            }
+            return record;
+        },
+        async cancelReminder(id, reason = "explicit_cancel") {
+            const current = reminders.get(id);
+            if (current === undefined) {
+                return undefined;
+            }
+            if (current.status === "completed" ||
+                current.status === "cancelled" ||
+                current.status === "disarmed") {
+                return current;
+            }
+            clearReminderTimer(id);
+            inflight.delete(id);
+            const updated = {
+                ...current,
+                status: "cancelled",
+                disarmReason: reason,
+                generation: recordGeneration(current) + 1,
+                updatedAt: new Date().toISOString(),
+            };
+            await persist(updated);
+            return updated;
+        },
+        async rekeyReminders(channelId, oldToken, newToken) {
+            let n = 0;
+            for (const record of [...reminders.values()]) {
+                if (record.channelId !== channelId || record.continuationToken !== oldToken) {
+                    continue;
                 }
-                if (current.nextFireAtMs > Date.now() + 50) {
-                    armReminder(current);
-                    return;
+                if (record.status !== "armed" && record.status !== "firing") {
+                    continue;
                 }
-                try {
-                    yield opts.fireReminder(current.id, current.fireCount);
+                const wasInflight = inflight.has(record.id);
+                inflight.delete(record.id);
+                let updated = {
+                    ...record,
+                    continuationToken: newToken,
+                    status: "armed",
+                    generation: recordGeneration(record) + 1,
+                    updatedAt: new Date().toISOString(),
+                };
+                // Interrupted in-flight fire: retry the same fireCount soon.
+                if (wasInflight) {
+                    updated = {
+                        ...updated,
+                        nextFireAtMs: Math.min(updated.nextFireAtMs, Date.now()),
+                    };
                 }
-                catch (error) {
-                    logger(`[bdk] reminder "${id}" dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+                await persist(updated);
+                if (armReminderClocks) {
+                    armReminder(updated);
                 }
-            });
-        }
-        return {
-            protocolVersion: REMINDER_CP_PROTOCOL_VERSION,
-            routeContinuation: routeLocalIngressContinuation,
-            attachScmEvents(relay) {
-                scmRelay = relay;
-                relay.start();
-                logger("[bdk] cursor-events: control-plane ingest started");
-            },
-            upsertSchedule(input) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    schedules.set(input.name, parseCron(input.cron));
-                    armScheduleTicker();
-                });
-            },
-            deleteSchedule(name) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    schedules.delete(name);
-                    if (schedules.size === 0) {
-                        stopScheduleTicker();
-                    }
-                });
-            },
-            putReminder(record) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    var _a;
-                    const normalized = Object.assign(Object.assign({}, record), { generation: (_a = record.generation) !== null && _a !== void 0 ? _a : 0 });
-                    yield persist(normalized);
-                    if (armReminderClocks && normalized.status === "armed") {
-                        armReminder(normalized);
-                        return;
-                    }
-                    clearReminderTimer(normalized.id);
-                    if (normalized.status !== "firing") {
-                        inflight.delete(normalized.id);
-                    }
-                });
-            },
-            getReminder(id) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    return reminders.get(id);
-                });
-            },
-            listReminders() {
-                return __awaiter(this, void 0, void 0, function* () {
-                    return [...reminders.values()];
-                });
-            },
-            deleteReminder(id) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    clearReminderTimer(id);
-                    inflight.delete(id);
-                    reminders.delete(id);
-                    yield store === null || store === void 0 ? void 0 : store.delete(id);
-                });
-            },
-            createReminder(intent) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    if (intent.protocolVersion !== REMINDER_CP_PROTOCOL_VERSION) {
-                        throw new Error(`Unsupported reminder CP protocol version ${String(intent.protocolVersion)}`);
-                    }
-                    const record = intentToNewRecord(intent);
-                    yield persist(record);
-                    if (armReminderClocks && record.status === "armed") {
-                        armReminder(record);
-                    }
-                    return record;
-                });
-            },
-            cancelReminder(id_1) {
-                return __awaiter(this, arguments, void 0, function* (id, reason = "explicit_cancel") {
-                    const current = reminders.get(id);
-                    if (current === undefined) {
-                        return undefined;
-                    }
-                    if (current.status === "completed" ||
-                        current.status === "cancelled" ||
-                        current.status === "disarmed") {
-                        return current;
-                    }
-                    clearReminderTimer(id);
-                    inflight.delete(id);
-                    const updated = Object.assign(Object.assign({}, current), { status: "cancelled", disarmReason: reason, generation: recordGeneration(current) + 1, updatedAt: new Date().toISOString() });
-                    yield persist(updated);
-                    return updated;
-                });
-            },
-            rekeyReminders(channelId, oldToken, newToken) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    let n = 0;
-                    for (const record of [...reminders.values()]) {
-                        if (record.channelId !== channelId || record.continuationToken !== oldToken) {
-                            continue;
-                        }
-                        if (record.status !== "armed" && record.status !== "firing") {
-                            continue;
-                        }
-                        const wasInflight = inflight.has(record.id);
-                        inflight.delete(record.id);
-                        let updated = Object.assign(Object.assign({}, record), { continuationToken: newToken, status: "armed", generation: recordGeneration(record) + 1, updatedAt: new Date().toISOString() });
-                        // Interrupted in-flight fire: retry the same fireCount soon.
-                        if (wasInflight) {
-                            updated = Object.assign(Object.assign({}, updated), { nextFireAtMs: Math.min(updated.nextFireAtMs, Date.now()) });
-                        }
-                        yield persist(updated);
+                n += 1;
+            }
+            return n;
+        },
+        applyReminderOutcome,
+        startClocks() {
+            for (const record of reminders.values()) {
+                if (record.status === "firing") {
+                    // Restart hydration: treat interrupted fires as armed for retry
+                    // even when clocks are not armed (status must still recover).
+                    const restored = {
+                        ...record,
+                        status: "armed",
+                        updatedAt: new Date().toISOString(),
+                    };
+                    void persist(restored).then(() => {
                         if (armReminderClocks) {
-                            armReminder(updated);
+                            armReminder(restored);
                         }
-                        n += 1;
-                    }
-                    return n;
-                });
-            },
-            applyReminderOutcome,
-            startClocks() {
-                for (const record of reminders.values()) {
-                    if (record.status === "firing") {
-                        // Restart hydration: treat interrupted fires as armed for retry
-                        // even when clocks are not armed (status must still recover).
-                        const restored = Object.assign(Object.assign({}, record), { status: "armed", updatedAt: new Date().toISOString() });
-                        void persist(restored).then(() => {
-                            if (armReminderClocks) {
-                                armReminder(restored);
-                            }
-                        });
-                        continue;
-                    }
-                    if (armReminderClocks && record.status === "armed") {
-                        armReminder(record);
-                    }
-                }
-            },
-            stop() {
-                stopScheduleTicker();
-                for (const id of [...reminderTimers.keys()]) {
-                    clearReminderTimer(id);
+                    });
+                    continue;
                 }
-                inflight.clear();
-                if (scmRelay !== undefined) {
-                    void scmRelay.stop();
-                    scmRelay = undefined;
+                if (armReminderClocks && record.status === "armed") {
+                    armReminder(record);
                 }
-            },
-        };
-    });
+            }
+        },
+        stop() {
+            stopScheduleTicker();
+            for (const id of [...reminderTimers.keys()]) {
+                clearReminderTimer(id);
+            }
+            inflight.clear();
+            if (scmRelay !== undefined) {
+                void scmRelay.stop();
+                scmRelay = undefined;
+            }
+        },
+    };
 }

package/dist/internal/local-env.js

@@ -40,7 +40,7 @@ export function loadAgentLocalEnv(dir) {
             .filter(entry => entry.isDirectory() && !entry.name.startsWith("."))
             .map(entry => entry.name);
     }
-    catch (_a) {
+    catch {
         trackLoadedKeys();
         return loaded;
     }