@cursor/bdk 0.2.8 → 0.2.10

package/dist/files-backends/local-fs.js

@@ -6,40 +6,6 @@
  * `materialized` — and there are no etags, so `conflictDetection` is honestly
  * false and concurrent writers are last-writer-wins.
  */
-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());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
-};
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
 import { randomUUID } from "node:crypto";
 import { mkdir, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { join, relative, resolve, sep } from "node:path";
@@ -53,9 +19,8 @@ import { FilePathRejectedError, } from "../files.js";
  * writers are last-writer-wins.
  */
 export function localFiles(options) {
-    var _a;
     const root = resolve(options.filesRoot);
-    const stripPrefix = (_a = options.stripKeyPrefix) !== null && _a !== void 0 ? _a : "";
+    const stripPrefix = options.stripKeyPrefix ?? "";
     const pathForKey = (key) => {
         const rel = stripPrefix !== "" && key.startsWith(stripPrefix) ? key.slice(stripPrefix.length) : key;
         const candidate = resolve(root, rel);
@@ -65,9 +30,9 @@ export function localFiles(options) {
         }
         return candidate;
     };
-    const entryFor = (key, absPath) => __awaiter(this, void 0, void 0, function* () {
+    const entryFor = async (key, absPath) => {
         try {
-            const info = yield stat(absPath);
+            const info = await stat(absPath);
             if (!info.isFile()) {
                 return undefined;
             }
@@ -79,117 +44,90 @@ export function localFiles(options) {
             }
             throw error;
         }
-    });
+    };
     return {
         capabilities: { materialized: true },
         materializedPath: key => pathForKey(key),
-        put(key, body) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const target = pathForKey(key);
-                yield mkdir(join(target, ".."), { recursive: true });
-                // Same-directory temp + rename: a reader either sees the previous value
-                // or the whole new one, never a half-written file.
-                const tmp = join(target, "..", `.tmp-${randomUUID()}`);
-                try {
-                    yield writeFile(tmp, body);
-                    yield rename(tmp, target);
-                }
-                catch (error) {
-                    yield rm(tmp, { force: true });
-                    throw error;
-                }
-            });
+        async put(key, body) {
+            const target = pathForKey(key);
+            await mkdir(join(target, ".."), { recursive: true });
+            // Same-directory temp + rename: a reader either sees the previous value
+            // or the whole new one, never a half-written file.
+            const tmp = join(target, "..", `.tmp-${randomUUID()}`);
+            try {
+                await writeFile(tmp, body);
+                await rename(tmp, target);
+            }
+            catch (error) {
+                await rm(tmp, { force: true });
+                throw error;
+            }
         },
-        get(key) {
-            return __awaiter(this, void 0, void 0, function* () {
-                try {
-                    return { body: new Uint8Array(yield readFile(pathForKey(key))) };
-                }
-                catch (error) {
-                    const code = error.code;
-                    if (code === "ENOENT" || code === "EISDIR") {
-                        return undefined;
-                    }
-                    throw error;
+        async get(key) {
+            try {
+                return { body: new Uint8Array(await readFile(pathForKey(key))) };
+            }
+            catch (error) {
+                const code = error.code;
+                if (code === "ENOENT" || code === "EISDIR") {
+                    return undefined;
                 }
-            });
+                throw error;
+            }
         },
-        delete(key) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield rm(pathForKey(key), { force: true });
-            });
+        async delete(key) {
+            await rm(pathForKey(key), { force: true });
         },
-        stat(key) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return yield entryFor(key, pathForKey(key));
-            });
+        async stat(key) {
+            return await entryFor(key, pathForKey(key));
         },
-        list(prefix) {
-            return __awaiter(this, void 0, void 0, function* () {
-                var _a, e_1, _b, _c;
-                // Walk the deepest existing directory at or above the prefix, then keep
-                // the keys that actually start with it — `prefix` is a key prefix, not a
-                // directory, so `notes/sum` must match `notes/summary.md`.
-                const prefixPath = pathForKey(prefix);
-                const searchRoot = (yield isDirectory(prefixPath)) ? prefixPath : join(prefixPath, "..");
-                const out = [];
-                try {
-                    for (var _d = true, _e = __asyncValues(walkFiles(searchRoot)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                        _c = _f.value;
-                        _d = false;
-                        const absPath = _c;
-                        const key = `${stripPrefix}${relative(root, absPath).split(sep).join("/")}`;
-                        if (!key.startsWith(prefix)) {
-                            continue;
-                        }
-                        const entry = yield entryFor(key, absPath);
-                        if (entry !== undefined) {
-                            out.push(entry);
-                        }
-                    }
+        async list(prefix) {
+            // Walk the deepest existing directory at or above the prefix, then keep
+            // the keys that actually start with it — `prefix` is a key prefix, not a
+            // directory, so `notes/sum` must match `notes/summary.md`.
+            const prefixPath = pathForKey(prefix);
+            const searchRoot = (await isDirectory(prefixPath)) ? prefixPath : join(prefixPath, "..");
+            const out = [];
+            for await (const absPath of walkFiles(searchRoot)) {
+                const key = `${stripPrefix}${relative(root, absPath).split(sep).join("/")}`;
+                if (!key.startsWith(prefix)) {
+                    continue;
                 }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                    }
-                    finally { if (e_1) throw e_1.error; }
+                const entry = await entryFor(key, absPath);
+                if (entry !== undefined) {
+                    out.push(entry);
                 }
-                return out.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
-            });
+            }
+            return out.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
         },
     };
 }
-function isDirectory(absPath) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            return (yield stat(absPath)).isDirectory();
-        }
-        catch (_a) {
-            return false;
-        }
-    });
+async function isDirectory(absPath) {
+    try {
+        return (await stat(absPath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
 }
-function walkFiles(dir) {
-    return __asyncGenerator(this, arguments, function* walkFiles_1() {
-        let entries;
-        try {
-            entries = yield __await(readdir(dir, { withFileTypes: true }));
+async function* walkFiles(dir) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return;
         }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return yield __await(void 0);
-            }
-            throw error;
+        throw error;
+    }
+    for (const entry of entries) {
+        const abs = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            yield* walkFiles(abs);
         }
-        for (const entry of entries) {
-            const abs = join(dir, entry.name);
-            if (entry.isDirectory()) {
-                yield __await(yield* __asyncDelegator(__asyncValues(walkFiles(abs))));
-            }
-            else if (entry.isFile() && !entry.name.startsWith(".tmp-")) {
-                yield yield __await(abs);
-            }
+        else if (entry.isFile() && !entry.name.startsWith(".tmp-")) {
+            yield abs;
         }
-    });
+    }
 }

package/dist/files.js

@@ -90,13 +90,13 @@ export const USER_STORE_MOUNT_PATH = "/cursor/stores/user";
 /** Errors raised by the file surface. Thrown by sinks and by the framework. */
 export class FileConflictError extends Error {
     constructor(key, options) {
-        super(`host.files write for "${key}" lost a race with another writer${(options === null || options === void 0 ? void 0 : options.storedEtag) === undefined ? "" : ` (stored version ${options.storedEtag})`}`);
+        super(`host.files write for "${key}" lost a race with another writer${options?.storedEtag === undefined ? "" : ` (stored version ${options.storedEtag})`}`);
         this.key = key;
         this.name = "FileConflictError";
-        if ((options === null || options === void 0 ? void 0 : options.cause) !== undefined) {
+        if (options?.cause !== undefined) {
             this.cause = options.cause;
         }
-        if ((options === null || options === void 0 ? void 0 : options.storedEtag) !== undefined) {
+        if (options?.storedEtag !== undefined) {
             this.storedEtag = options.storedEtag;
         }
     }