@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/turn-lease-store.js

@@ -10,21 +10,12 @@
  *
  * Liveness is lock age, not pid: containers have separate PID namespaces.
  */
-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 { randomUUID } from "node:crypto";
 import { mkdir, rename, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
 import * as lockfile from "proper-lockfile";
 /** Long enough that the library never runs its own takeover. */
-const NEVER_STALE_MS = 365 * 24 * 60 * 60000;
+const NEVER_STALE_MS = 365 * 24 * 60 * 60_000;
 /** Reject path traversal; session ids are opaque strings from the caller. */
 function safeKey(sessionId) {
     const sanitized = sessionId
@@ -37,12 +28,11 @@ function safeKey(sessionId) {
 }
 export class TurnLeaseStore {
     constructor(dir, options = {}) {
-        var _a;
         /** Locks this process holds. Their release closures cannot live on disk. */
         this.held = new Map();
         this.dir = dir;
         // Several refreshes, so a slow owner is not mistaken for a dead one.
-        this.staleMs = (_a = options.ttlMs) !== null && _a !== void 0 ? _a : 30000;
+        this.staleMs = options.ttlMs ?? 30_000;
     }
     path(sessionId) {
         return join(this.dir, `${safeKey(sessionId)}.lease`);
@@ -55,92 +45,86 @@ export class TurnLeaseStore {
      * that; the callback is how the displaced turn learns to stand down instead
      * of answering alongside its successor.
      */
-    acquire(sessionId, onCompromised) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const existing = this.held.get(sessionId);
-            if (existing !== undefined) {
-                existing.refs += 1;
-                return this.handle(sessionId);
-            }
-            yield mkdir(this.dir, { recursive: true });
-            const path = this.path(sessionId);
-            yield this.evictStaleLock(path);
-            let release;
-            try {
-                release = yield lockfile.lock(path, {
-                    realpath: false,
-                    retries: 0,
-                    stale: NEVER_STALE_MS,
-                    // How often the library refreshes the lock's mtime while we hold it.
-                    update: 5000,
-                    onCompromised: () => {
-                        this.held.delete(sessionId);
-                        onCompromised === null || onCompromised === void 0 ? void 0 : onCompromised();
-                    },
-                });
-            }
-            catch (_a) {
-                // Held elsewhere, or the store is unusable. Either way this process must
-                // not run the turn: coalescing costs latency, two servers on one session
-                // costs the conversation.
-                return undefined;
-            }
-            this.held.set(sessionId, { release, refs: 1 });
+    async acquire(sessionId, onCompromised) {
+        const existing = this.held.get(sessionId);
+        if (existing !== undefined) {
+            existing.refs += 1;
             return this.handle(sessionId);
-        });
+        }
+        await mkdir(this.dir, { recursive: true });
+        const path = this.path(sessionId);
+        await this.evictStaleLock(path);
+        let release;
+        try {
+            release = await lockfile.lock(path, {
+                realpath: false,
+                retries: 0,
+                stale: NEVER_STALE_MS,
+                // How often the library refreshes the lock's mtime while we hold it.
+                update: 5_000,
+                onCompromised: () => {
+                    this.held.delete(sessionId);
+                    onCompromised?.();
+                },
+            });
+        }
+        catch {
+            // Held elsewhere, or the store is unusable. Either way this process must
+            // not run the turn: coalescing costs latency, two servers on one session
+            // costs the conversation.
+            return undefined;
+        }
+        this.held.set(sessionId, { release, refs: 1 });
+        return this.handle(sessionId);
     }
     /**
      * Clear an abandoned lock, leaving a claim itself a single atomic `mkdir`.
      * Only the contender holding the takeover removes anything, and no claim can
      * land on an occupied path meanwhile, so the rest just race that `mkdir`.
      */
-    evictStaleLock(path) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // proper-lockfile's own naming for the lock it creates.
-            const lockPath = `${path}.lock`;
-            if (!(yield this.isStale(lockPath))) {
-                return;
-            }
-            const takeoverPath = `${path}.takeover`;
-            if (yield this.isStale(takeoverPath)) {
-                // Left by a process that died mid-takeover. Grabbing it by rename admits
-                // one clearer, where checking and then removing would admit several.
-                const abandoned = `${takeoverPath}.${randomUUID()}`;
-                try {
-                    yield rename(takeoverPath, abandoned);
-                }
-                catch (_a) {
-                    return;
-                }
-                yield rm(abandoned, { recursive: true, force: true });
-            }
+    async evictStaleLock(path) {
+        // proper-lockfile's own naming for the lock it creates.
+        const lockPath = `${path}.lock`;
+        if (!(await this.isStale(lockPath))) {
+            return;
+        }
+        const takeoverPath = `${path}.takeover`;
+        if (await this.isStale(takeoverPath)) {
+            // Left by a process that died mid-takeover. Grabbing it by rename admits
+            // one clearer, where checking and then removing would admit several.
+            const abandoned = `${takeoverPath}.${randomUUID()}`;
             try {
-                yield mkdir(takeoverPath);
+                await rename(takeoverPath, abandoned);
             }
-            catch (_b) {
+            catch {
                 return;
             }
-            try {
-                // A successor may have claimed the session while this contender queued.
-                if (yield this.isStale(lockPath)) {
-                    yield rm(lockPath, { recursive: true, force: true });
-                }
-            }
-            finally {
-                yield rm(takeoverPath, { recursive: true, force: true });
+            await rm(abandoned, { recursive: true, force: true });
+        }
+        try {
+            await mkdir(takeoverPath);
+        }
+        catch {
+            return;
+        }
+        try {
+            // A successor may have claimed the session while this contender queued.
+            if (await this.isStale(lockPath)) {
+                await rm(lockPath, { recursive: true, force: true });
             }
-        });
+        }
+        finally {
+            await rm(takeoverPath, { recursive: true, force: true });
+        }
     }
-    isStale(lockPath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const entry = yield stat(lockPath).catch(() => undefined);
-            return entry !== undefined && entry.mtimeMs < Date.now() - this.staleMs;
-        });
+    async isStale(lockPath) {
+        const entry = await stat(lockPath).catch(() => undefined);
+        return entry !== undefined && entry.mtimeMs < Date.now() - this.staleMs;
     }
     handle(sessionId) {
         let released = false;
         return {
-            release: () => __awaiter(this, void 0, void 0, function* () {
+            release: async () => {
                 if (released) {
                     return;
                 }
@@ -156,37 +140,33 @@ export class TurnLeaseStore {
                 this.held.delete(sessionId);
                 // Throws if the lock was already compromised, which is not our problem
                 // to solve here: the successor owns it.
-                yield lock.release().catch(() => { });
-            }),
+                await lock.release().catch(() => { });
+            },
         };
     }
     /** Graceful shutdown: drop every claim so a successor need not wait it out. */
-    releaseAll() {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const [sessionId, lock] of [...this.held]) {
-                this.held.delete(sessionId);
-                yield lock.release().catch(() => { });
-            }
-        });
+    async releaseAll() {
+        for (const [sessionId, lock] of [...this.held]) {
+            this.held.delete(sessionId);
+            await lock.release().catch(() => { });
+        }
     }
     /**
      * The session is running in another server process. Mirrors the engine's
      * in-memory `isTurnRunning`, which only ever sees this process.
      */
-    runningElsewhere(sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.held.has(sessionId)) {
-                return false;
-            }
-            try {
-                return yield lockfile.check(this.path(sessionId), {
-                    realpath: false,
-                    stale: this.staleMs,
-                });
-            }
-            catch (_a) {
-                return false;
-            }
-        });
+    async runningElsewhere(sessionId) {
+        if (this.held.has(sessionId)) {
+            return false;
+        }
+        try {
+            return await lockfile.check(this.path(sessionId), {
+                realpath: false,
+                stale: this.staleMs,
+            });
+        }
+        catch {
+            return false;
+        }
     }
 }

package/dist/internal/turn-outbox.js

@@ -8,15 +8,6 @@
  * turn runs and once more after releasing the lease. Local messages never
  * touch this.
  */
-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 { randomUUID } from "node:crypto";
 import { mkdir, readdir, readFile, rename, rm, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -36,45 +27,39 @@ export class TurnOutbox {
     dir(sessionId) {
         return join(this.rootDir, safeKey(sessionId));
     }
-    post(sessionId, item) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const dir = this.dir(sessionId);
-            yield mkdir(dir, { recursive: true });
-            // Timestamp first so a listing sorts in arrival order.
-            const path = join(dir, `${Date.now()}-${randomUUID()}.json`);
-            yield writeFile(`${path}.tmp`, `${JSON.stringify(item)}\n`, "utf8");
-            yield rename(`${path}.tmp`, path);
-        });
+    async post(sessionId, item) {
+        const dir = this.dir(sessionId);
+        await mkdir(dir, { recursive: true });
+        // Timestamp first so a listing sorts in arrival order.
+        const path = join(dir, `${Date.now()}-${randomUUID()}.json`);
+        await writeFile(`${path}.tmp`, `${JSON.stringify(item)}\n`, "utf8");
+        await rename(`${path}.tmp`, path);
     }
     /** Remove and return everything posted, in arrival order. */
-    takeAll(sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const dir = this.dir(sessionId);
-            let names;
+    async takeAll(sessionId) {
+        const dir = this.dir(sessionId);
+        let names;
+        try {
+            names = await readdir(dir);
+        }
+        catch {
+            return [];
+        }
+        const items = [];
+        for (const name of names.filter(n => n.endsWith(".json")).sort()) {
+            const path = join(dir, name);
             try {
-                names = yield readdir(dir);
+                const raw = await readFile(path, "utf8");
+                await unlink(path);
+                items.push(JSON.parse(raw));
             }
-            catch (_a) {
-                return [];
+            catch {
+                // Taken by the holder between readdir and here.
             }
-            const items = [];
-            for (const name of names.filter(n => n.endsWith(".json")).sort()) {
-                const path = join(dir, name);
-                try {
-                    const raw = yield readFile(path, "utf8");
-                    yield unlink(path);
-                    items.push(JSON.parse(raw));
-                }
-                catch (_b) {
-                    // Taken by the holder between readdir and here.
-                }
-            }
-            return items;
-        });
+        }
+        return items;
     }
-    clear(sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield rm(this.dir(sessionId), { recursive: true, force: true });
-        });
+    async clear(sessionId) {
+        await rm(this.dir(sessionId), { recursive: true, force: true });
     }
 }