@cursor/bdk 0.2.8 → 0.2.10

package/dist/internal/workspace-sync.js

@@ -3,15 +3,6 @@
  * per-turn `workspaceFiles` use separate deployment and session scopes.
  * User-scoped storage also namespaces both by agent.
  */
-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 { readFile } from "node:fs/promises";
 import { agentStoreKeys } from "../files.js";
 import { MEMORY_DIR_NAME } from "../memory.js";
@@ -28,16 +19,13 @@ export class WorkspaceFileRefusal extends Error {
  * delete keys no seed claims so redeploys drop removed files. Every seed
  * loads and validates before the store is touched.
  */
-export function syncWorkspaceToStore(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const workspacePrefix = (_a = args.workspacePrefix) !== null && _a !== void 0 ? _a : agentStoreKeys.workspacePrefix();
-        const desired = new Map();
-        for (const seed of args.seedFiles) {
-            desired.set(agentStoreKeys.workspaceFile(workspaceRelPath(seed.relativePath), workspacePrefix), yield readFile(seed.sourcePath));
-        }
-        yield mirrorToStore({ sink: args.sink, prefix: workspacePrefix, desired });
-    });
+export async function syncWorkspaceToStore(args) {
+    const workspacePrefix = args.workspacePrefix ?? agentStoreKeys.workspacePrefix();
+    const desired = new Map();
+    for (const seed of args.seedFiles) {
+        desired.set(agentStoreKeys.workspaceFile(workspaceRelPath(seed.relativePath), workspacePrefix), await readFile(seed.sourcePath));
+    }
+    await mirrorToStore({ sink: args.sink, prefix: workspacePrefix, desired });
 }
 /**
  * Replace the session workspace prefix with this turn's `workspaceFiles`.
@@ -45,31 +33,27 @@ export function syncWorkspaceToStore(args) {
  * stale `pr.json`. Every path validates before the store is touched.
  * Returns the relative paths that landed, in send order.
  */
-export function syncSessionWorkspaceFiles(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const desired = new Map();
-        const relPaths = [];
-        for (const [relativePath, contents] of Object.entries(args.files)) {
-            const rel = workspaceRelPath(relativePath);
-            desired.set(agentStoreKeys.workspaceFile(rel, args.workspacePrefix), workspaceFileBytes(relativePath, contents));
-            relPaths.push(rel);
-        }
-        yield mirrorToStore({
-            sink: args.sink,
-            prefix: args.workspacePrefix,
-            desired,
-        });
-        return relPaths;
+export async function syncSessionWorkspaceFiles(args) {
+    const desired = new Map();
+    const relPaths = [];
+    for (const [relativePath, contents] of Object.entries(args.files)) {
+        const rel = workspaceRelPath(relativePath);
+        desired.set(agentStoreKeys.workspaceFile(rel, args.workspacePrefix), workspaceFileBytes(relativePath, contents));
+        relPaths.push(rel);
+    }
+    await mirrorToStore({
+        sink: args.sink,
+        prefix: args.workspacePrefix,
+        desired,
     });
+    return relPaths;
 }
 /** Delete every key under the session workspace prefix. */
-export function wipeSessionWorkspace(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield mirrorToStore({
-            sink: args.sink,
-            prefix: args.workspacePrefix,
-            desired: new Map(),
-        });
+export async function wipeSessionWorkspace(args) {
+    await mirrorToStore({
+        sink: args.sink,
+        prefix: args.workspacePrefix,
+        desired: new Map(),
     });
 }
 /**

package/dist/internal/workspace.js

@@ -8,15 +8,6 @@
  * deliver them as the harness system prompt ({@link buildAgentsMdContent}),
  * and cloud / grokbot harnesses never read the session workspace.
  */
-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 } from "node:child_process";
 import { chmod, copyFile, lstat, mkdir, readlink, rm, stat, symlink, writeFile, } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -91,9 +82,8 @@ export function buildIdentityPreamble(name) {
  * loading `instructions.md` / `.ts` / dir into {@link ResolvedAgent.instructions}.
  */
 export function withIdentityPreamble(name, instructions) {
-    var _a;
     const preamble = buildIdentityPreamble(name);
-    const body = (_a = instructions === null || instructions === void 0 ? void 0 : instructions.trim()) !== null && _a !== void 0 ? _a : "";
+    const body = instructions?.trim() ?? "";
     if (preamble === "" && body === "") {
         return undefined;
     }
@@ -208,10 +198,8 @@ export function buildServerToolsCatalog(tools, options) {
  * there the harness exposes server tools natively.
  */
 export function buildAgentsMdContent(agent, options) {
-    var _a;
-    var _b;
     return [
-        (_b = (_a = agent.instructions) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : "",
+        agent.instructions?.trim() ?? "",
         buildIdentitySection(agent),
         options.serverToolsMcpName === undefined
             ? ""
@@ -233,22 +221,20 @@ export function buildAgentsMdContent(agent, options) {
  * repo's rules load instead, and the (necessarily gitignored) workspace files
  * are skipped by nested rule discovery.
  */
-export function isNestedInGitRepo(dir) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let current = resolve(dir);
-        if (yield exists(join(current, ".git"))) {
-            // The workspace is itself a repo root; the harness roots rules here.
-            return false;
-        }
-        const { root } = parse(current);
-        while (current !== root) {
-            current = dirname(current);
-            if (yield exists(join(current, ".git"))) {
-                return true;
-            }
-        }
+export async function isNestedInGitRepo(dir) {
+    let current = resolve(dir);
+    if (await exists(join(current, ".git"))) {
+        // The workspace is itself a repo root; the harness roots rules here.
         return false;
-    });
+    }
+    const { root } = parse(current);
+    while (current !== root) {
+        current = dirname(current);
+        if (await exists(join(current, ".git"))) {
+            return true;
+        }
+    }
+    return false;
 }
 /** Default harness parent for a nested-git agent project. */
 export function defaultLocalHarnessCwd(dirName) {
@@ -265,47 +251,43 @@ export function defaultLocalHarnessCwd(dirName) {
  * worktree) is left alone, and a failed `git init` leaves the harness where
  * it already was.
  */
-export function ensureOwnGitRoot(dir) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!(yield isNestedInGitRepo(dir))) {
-            return false;
-        }
-        try {
-            yield execFileAsync("git", ["init", "--quiet"], { cwd: dir });
-            return true;
-        }
-        catch (_a) {
-            return false;
-        }
-    });
+export async function ensureOwnGitRoot(dir) {
+    if (!(await isNestedInGitRepo(dir))) {
+        return false;
+    }
+    try {
+        await execFileAsync("git", ["init", "--quiet"], { cwd: dir });
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
-export function materializeWorkspace(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { agent, workspaceDir, seed, stateRoot } = options;
-        yield mkdir(workspaceDir, { recursive: true });
-        if (seed) {
-            yield linkSharedMemoryDir(workspaceDir, stateRoot);
+export async function materializeWorkspace(options) {
+    const { agent, workspaceDir, seed, stateRoot } = options;
+    await mkdir(workspaceDir, { recursive: true });
+    if (seed) {
+        await linkSharedMemoryDir(workspaceDir, stateRoot);
+    }
+    for (const tool of agent.tools) {
+        if (tool.execution !== "agent" || tool.script === undefined) {
+            continue;
         }
-        for (const tool of agent.tools) {
-            if (tool.execution !== "agent" || tool.script === undefined) {
+        await materializeAgentTool(workspaceDir, tool);
+    }
+    for (const skill of agent.skills) {
+        await materializeSkill(workspaceDir, skill);
+    }
+    if (seed) {
+        for (const seedFile of agent.seedFiles) {
+            const target = resolveWorkspaceWritePath(workspaceDir, seedFile.relativePath);
+            if (await exists(target)) {
                 continue;
             }
-            yield materializeAgentTool(workspaceDir, tool);
+            await mkdir(dirname(target), { recursive: true });
+            await copyFile(seedFile.sourcePath, target);
         }
-        for (const skill of agent.skills) {
-            yield materializeSkill(workspaceDir, skill);
-        }
-        if (seed) {
-            for (const seedFile of agent.seedFiles) {
-                const target = resolveWorkspaceWritePath(workspaceDir, seedFile.relativePath);
-                if (yield exists(target)) {
-                    continue;
-                }
-                yield mkdir(dirname(target), { recursive: true });
-                yield copyFile(seedFile.sourcePath, target);
-            }
-        }
-    });
+    }
 }
 /**
  * Resolve a workspace-rooted write target, refusing escapes and the
@@ -329,60 +311,54 @@ function resolveWorkspaceWritePath(workspaceDir, relativePath) {
  * platforms (unprivileged Windows) are left alone — memory then stays
  * reachable only via the state path.
  */
-function linkSharedMemoryDir(workspaceDir, stateRoot) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const target = join(stateRoot, MEMORY_DIR_NAME);
-        const linkPath = join(workspaceDir, MEMORY_DIR_NAME);
-        yield mkdir(target, { recursive: true });
-        try {
-            yield symlink(target, linkPath, "dir");
-        }
-        catch (error) {
-            if (error.code !== "EEXIST") {
-                return;
-            }
-            const existing = yield lstat(linkPath);
-            if (!existing.isSymbolicLink() || (yield readlink(linkPath)) === target) {
-                return;
-            }
-            yield rm(linkPath);
-            yield symlink(target, linkPath, "dir");
-        }
-    });
-}
-function materializeAgentTool(workspaceDir, tool) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (tool.script === undefined) {
+async function linkSharedMemoryDir(workspaceDir, stateRoot) {
+    const target = join(stateRoot, MEMORY_DIR_NAME);
+    const linkPath = join(workspaceDir, MEMORY_DIR_NAME);
+    await mkdir(target, { recursive: true });
+    try {
+        await symlink(target, linkPath, "dir");
+    }
+    catch (error) {
+        if (error.code !== "EEXIST") {
             return;
         }
-        const relativePath = agentToolScriptPath(tool.name);
-        const target = resolveInside(workspaceDir, relativePath);
-        yield mkdir(dirname(target), { recursive: true });
-        yield writeFile(target, `${normalizeScriptBody(tool.script)}\n`, "utf8");
-        try {
-            yield chmod(target, 0o755);
-        }
-        catch (_a) {
-            // Best-effort on platforms that ignore mode bits.
+        const existing = await lstat(linkPath);
+        if (!existing.isSymbolicLink() || (await readlink(linkPath)) === target) {
+            return;
         }
-    });
+        await rm(linkPath);
+        await symlink(target, linkPath, "dir");
+    }
 }
-function materializeSkill(workspaceDir, skill) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const skillDir = join(workspaceDir, ".cursor", "skills", skill.name);
-        yield mkdir(skillDir, { recursive: true });
-        yield writeFile(join(skillDir, "SKILL.md"), buildSkillMd(skill), "utf8");
-        for (const [relativePath, source] of Object.entries(skill.files)) {
-            const target = resolveInside(skillDir, relativePath);
-            yield mkdir(dirname(target), { recursive: true });
-            if ("contents" in source) {
-                yield writeFile(target, source.contents, "utf8");
-            }
-            else {
-                yield copyFile(source.sourcePath, target);
-            }
+async function materializeAgentTool(workspaceDir, tool) {
+    if (tool.script === undefined) {
+        return;
+    }
+    const relativePath = agentToolScriptPath(tool.name);
+    const target = resolveInside(workspaceDir, relativePath);
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, `${normalizeScriptBody(tool.script)}\n`, "utf8");
+    try {
+        await chmod(target, 0o755);
+    }
+    catch {
+        // Best-effort on platforms that ignore mode bits.
+    }
+}
+async function materializeSkill(workspaceDir, skill) {
+    const skillDir = join(workspaceDir, ".cursor", "skills", skill.name);
+    await mkdir(skillDir, { recursive: true });
+    await writeFile(join(skillDir, "SKILL.md"), buildSkillMd(skill), "utf8");
+    for (const [relativePath, source] of Object.entries(skill.files)) {
+        const target = resolveInside(skillDir, relativePath);
+        await mkdir(dirname(target), { recursive: true });
+        if ("contents" in source) {
+            await writeFile(target, source.contents, "utf8");
         }
-    });
+        else {
+            await copyFile(source.sourcePath, target);
+        }
+    }
 }
 /**
  * Ensure the script has a shebang. Catalog fences stay tidy without a
@@ -412,22 +388,20 @@ export function buildSkillMd(skill) {
  * Write relative path → contents under `workspaceDir`, refusing paths that
  * escape the directory. Values may be utf8 strings or base64 blob envelopes.
  */
-export function writeWorkspaceFiles(workspaceDir, files) {
-    return __awaiter(this, void 0, void 0, function* () {
-        for (const [relativePath, contents] of Object.entries(files)) {
-            const target = resolveWorkspaceWritePath(workspaceDir, relativePath);
-            yield mkdir(dirname(target), { recursive: true });
-            if (typeof contents === "string") {
-                yield writeFile(target, contents, "utf8");
-            }
-            else if (contents.encoding === "base64") {
-                yield writeFile(target, Buffer.from(contents.data, "base64"));
-            }
-            else {
-                throw new Error(`Unsupported workspace file encoding for ${relativePath}`);
-            }
+export async function writeWorkspaceFiles(workspaceDir, files) {
+    for (const [relativePath, contents] of Object.entries(files)) {
+        const target = resolveWorkspaceWritePath(workspaceDir, relativePath);
+        await mkdir(dirname(target), { recursive: true });
+        if (typeof contents === "string") {
+            await writeFile(target, contents, "utf8");
         }
-    });
+        else if (contents.encoding === "base64") {
+            await writeFile(target, Buffer.from(contents.data, "base64"));
+        }
+        else {
+            throw new Error(`Unsupported workspace file encoding for ${relativePath}`);
+        }
+    }
 }
 function resolveInside(baseDir, relativePath) {
     const target = resolve(baseDir, relativePath);
@@ -437,14 +411,12 @@ function resolveInside(baseDir, relativePath) {
     }
     return target;
 }
-function exists(path) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            yield stat(path);
-            return true;
-        }
-        catch (_a) {
-            return false;
-        }
-    });
+async function exists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }

package/dist/kv/memory-kv.js

@@ -9,15 +9,6 @@
  * CAS contract, not a mock of an RPC. Values are deep-copied on both write and
  * read so callers can never observe (or cause) shared-reference mutation.
  */
-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());
-    });
-};
 /** Create an empty in-memory CAS-capable KV. */
 export function createMemoryKv() {
     const entries = new Map();
@@ -34,55 +25,40 @@ export function createMemoryKv() {
         return { value: structuredClone(entry.value), version: entry.version };
     };
     return {
-        get(key) {
-            return __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                return (_a = snapshot(key)) === null || _a === void 0 ? void 0 : _a.value;
-            });
+        async get(key) {
+            return snapshot(key)?.value;
         },
-        put(key, value) {
-            return __awaiter(this, void 0, void 0, function* () {
-                entries.set(key, {
-                    value: structuredClone(value),
-                    version: nextVersion(),
-                });
+        async put(key, value) {
+            entries.set(key, {
+                value: structuredClone(value),
+                version: nextVersion(),
             });
         },
-        delete(key) {
-            return __awaiter(this, void 0, void 0, function* () {
-                entries.delete(key);
-            });
+        async delete(key) {
+            entries.delete(key);
         },
-        getWithVersion(key) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return snapshot(key);
-            });
+        async getWithVersion(key) {
+            return snapshot(key);
         },
-        putIfAbsent(key, value) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (entries.has(key)) {
-                    return { ok: false, current: snapshot(key) };
-                }
-                const version = nextVersion();
-                entries.set(key, { value: structuredClone(value), version });
-                return { ok: true, version };
-            });
+        async putIfAbsent(key, value) {
+            if (entries.has(key)) {
+                return { ok: false, current: snapshot(key) };
+            }
+            const version = nextVersion();
+            entries.set(key, { value: structuredClone(value), version });
+            return { ok: true, version };
         },
-        putIfVersion(key, value, expectedVersion) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const entry = entries.get(key);
-                if (entry === undefined || entry.version !== expectedVersion) {
-                    return { ok: false, current: snapshot(key) };
-                }
-                const version = nextVersion();
-                entries.set(key, { value: structuredClone(value), version });
-                return { ok: true, version };
-            });
+        async putIfVersion(key, value, expectedVersion) {
+            const entry = entries.get(key);
+            if (entry === undefined || entry.version !== expectedVersion) {
+                return { ok: false, current: snapshot(key) };
+            }
+            const version = nextVersion();
+            entries.set(key, { value: structuredClone(value), version });
+            return { ok: true, version };
         },
-        listKeys(prefix) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return [...entries.keys()].filter(key => key.startsWith(prefix)).sort();
-            });
+        async listKeys(prefix) {
+            return [...entries.keys()].filter(key => key.startsWith(prefix)).sort();
         },
     };
 }