@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/discovery/extensions.js

@@ -2,15 +2,6 @@
  * `agent/extensions/<ns>.ts` | `agent/extensions/<ns>/extension.ts`:
  * agent-shaped trees and Cursor plugins mounted under a namespace.
  */
-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, resolve } from "node:path";
 import { hostingEntryErrors } from "../hosting.js";
 import { buildIdentityPreamble, withIdentityPreamble } from "../workspace.js";
@@ -36,58 +27,54 @@ import { compileTool, loadTools } from "./tools.js";
  * contributes to the authored lists as `<ns>__<name>`, stamped with
  * `extension`. The namespace is the mount's filename stem or directory name.
  */
-export function appendExtensions(ctx, extensionsDir, into) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!(yield isDirectory(extensionsDir))) {
-            return [];
+export async function appendExtensions(ctx, extensionsDir, into) {
+    if (!(await isDirectory(extensionsDir))) {
+        return [];
+    }
+    const extensions = [];
+    for (const entry of await sortedEntries(extensionsDir)) {
+        const path = join(extensionsDir, entry.name);
+        const site = await resolveMountSite(ctx, path, entry);
+        if (site === undefined) {
+            continue;
+        }
+        if (extensions.some(extension => extension.name === site.ns)) {
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, path),
+                message: `Extension "${site.ns}" is mounted twice (as a file and as a directory).`,
+            });
+            continue;
         }
-        const extensions = [];
-        for (const entry of yield sortedEntries(extensionsDir)) {
-            const path = join(extensionsDir, entry.name);
-            const site = yield resolveMountSite(ctx, path, entry);
-            if (site === undefined) {
-                continue;
-            }
-            if (extensions.some(extension => extension.name === site.ns)) {
-                ctx.diagnostics.push({
-                    severity: "error",
-                    path: displayPath(ctx, path),
-                    message: `Extension "${site.ns}" is mounted twice (as a file and as a directory).`,
-                });
-                continue;
-            }
-            const mount = yield importDefault(ctx, site.mountPath, "extension");
-            if (mount === undefined) {
-                continue;
-            }
-            extensions.push(yield mountExtension(ctx, site, mount, into));
+        const mount = await importDefault(ctx, site.mountPath, "extension");
+        if (mount === undefined) {
+            continue;
         }
-        return extensions;
-    });
+        extensions.push(await mountExtension(ctx, site, mount, into));
+    }
+    return extensions;
 }
-function resolveMountSite(ctx, path, entry) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (entry.isDirectory()) {
-            if (!validateName(ctx, "extension", entry.name, path)) {
-                return undefined;
-            }
-            const mountPath = yield findModuleFile(path, "extension");
-            if (mountPath === undefined) {
-                ctx.diagnostics.push({
-                    severity: "error",
-                    path: displayPath(ctx, path),
-                    message: "A directory mount needs an extension.ts default-exporting the mount (`export default ci({ ... })`).",
-                });
-                return undefined;
-            }
-            return { ns: entry.name, mountPath, overlayDir: path };
+async function resolveMountSite(ctx, path, entry) {
+    if (entry.isDirectory()) {
+        if (!validateName(ctx, "extension", entry.name, path)) {
+            return undefined;
         }
-        if (!entry.isFile() || !isModuleFile(entry.name)) {
+        const mountPath = await findModuleFile(path, "extension");
+        if (mountPath === undefined) {
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, path),
+                message: "A directory mount needs an extension.ts default-exporting the mount (`export default ci({ ... })`).",
+            });
             return undefined;
         }
-        const ns = moduleStem(entry.name);
-        return validateName(ctx, "extension", ns, path) ? { ns, mountPath: path } : undefined;
-    });
+        return { ns: entry.name, mountPath, overlayDir: path };
+    }
+    if (!entry.isFile() || !isModuleFile(entry.name)) {
+        return undefined;
+    }
+    const ns = moduleStem(entry.name);
+    return validateName(ctx, "extension", ns, path) ? { ns, mountPath: path } : undefined;
 }
 function emptyDiscovered(ns, description) {
     return {
@@ -112,210 +99,216 @@ function emptyDiscovered(ns, description) {
  * file replaces, `disable()` / `disableTool()` removes), then namespace
  * what is left.
  */
-function mountExtension(ctx, site, mount, into) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const mounted = emptyDiscovered(site.ns, mount.extension.description);
-        const root = resolve(ctx.rootDir, mount.extension.root);
-        if (!(yield isDirectory(root))) {
-            const hint = "layout" in mount.extension
-                ? "Point `path` at the plugin directory."
-                : "Pass `import.meta.dirname` from extension.ts.";
+async function mountExtension(ctx, site, mount, into) {
+    const mounted = emptyDiscovered(site.ns, mount.extension.description);
+    const root = resolve(ctx.rootDir, mount.extension.root);
+    if (!(await isDirectory(root))) {
+        const hint = "layout" in mount.extension
+            ? "Point `path` at the plugin directory."
+            : "Pass `import.meta.dirname` from extension.ts.";
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, site.mountPath),
+            message: `Extension "${site.ns}" declares root ${root}, which is not a directory. ${hint}`,
+        });
+        return mounted;
+    }
+    const tree = await readExtensionTree(ctx, site, mount, root);
+    if (tree === undefined) {
+        return mounted;
+    }
+    mounted.description = mount.extension.description ?? tree.description;
+    const tools = byName(tree.tools);
+    const skills = byName(tree.skills);
+    const connections = byName(tree.connections);
+    const hostConnections = byName(tree.hostConnections);
+    const hooks = byName(tree.hooks);
+    const channels = byId(tree.channels);
+    const schedules = byName(tree.schedules);
+    const subagents = byName(tree.subagents);
+    for (const agent of tree.agents) {
+        subagents.set(agent.name, subagent(agent.name, agent));
+    }
+    const seedFiles = new Map(tree.seedFiles.map(seed => [seed.relativePath, seed]));
+    let artifacts = tree.artifacts;
+    let instructions = tree.instructions;
+    if (site.overlayDir !== undefined) {
+        const connectionOverlay = await moduleEntries(ctx, join(site.overlayDir, "mcp-connections"), "connection");
+        await overlaySlot(ctx, site, tools, await moduleEntries(ctx, join(site.overlayDir, "tools"), "tool"), {
+            kind: "tool",
+            disabledKind: "disabled-tool",
+            disableHelper: "disableTool",
+            declared: new Set(tools.keys()),
+            compile: (ctx, path, name, definition) => compileTool(ctx, path, name, definition),
+        });
+        await overlaySlot(ctx, site, connections, connectionOverlay, {
+            kind: "connection",
+            disabledKind: "disabled-connection",
+            disableHelper: "disableConnection",
+            declared: new Set([...connections.keys(), ...tree.overlaidServers]),
+            compile: (ctx, path, name, definition) => compileConnection(ctx, path, name, definition, "model"),
+        });
+        await overlaySlot(ctx, site, hostConnections, await moduleEntries(ctx, join(site.overlayDir, "host-connections"), "connection"), {
+            kind: "connection",
+            disabledKind: "disabled-connection",
+            disableHelper: "disableConnection",
+            declared: new Set(hostConnections.keys()),
+            compile: (ctx, path, name, definition) => compileHostConnection(ctx, path, name, definition),
+        });
+        await overlaySkills(ctx, site, skills, join(site.overlayDir, "skills"));
+        await overlayHooks(ctx, site, hooks, join(site.overlayDir, "hooks"));
+        await overlayChannels(ctx, site, channels, join(site.overlayDir, "channels"));
+        await overlaySchedules(ctx, site, schedules, join(site.overlayDir, "schedules"));
+        await overlaySubagents(ctx, site, subagents, join(site.overlayDir, "subagents"));
+        const overlayInstructions = await overlayInstructionsFragment(ctx, site.overlayDir);
+        if (overlayInstructions !== "keep") {
+            instructions = overlayInstructions;
+        }
+        for (const seed of await loadSeedFiles(ctx, site.overlayDir)) {
+            seedFiles.set(seed.relativePath, seed);
+        }
+        artifacts = await overlayArtifacts(ctx, site.overlayDir, artifacts);
+    }
+    for (const [name, tool] of tools) {
+        const composed = `${site.ns}__${name}`;
+        into.tools.push({ ...tool, name: composed, extension: site.ns });
+        mounted.tools.push(composed);
+    }
+    for (const [name, skill] of skills) {
+        const composed = `${site.ns}__${name}`;
+        into.skills.push({ ...skill, name: composed, extension: site.ns });
+        mounted.skills.push(composed);
+    }
+    const modelNames = new Set();
+    for (const [name, connection] of connections) {
+        const composed = `${site.ns}__${name}`;
+        modelNames.add(composed);
+        into.connections.push({ ...connection, name: composed });
+        mounted.connections.push(composed);
+    }
+    for (const [name, connection] of hostConnections) {
+        const composed = `${site.ns}__${name}`;
+        if (modelNames.has(composed)) {
             ctx.diagnostics.push({
                 severity: "error",
-                path: displayPath(ctx, site.mountPath),
-                message: `Extension "${site.ns}" declares root ${root}, which is not a directory. ${hint}`,
+                path: displayPath(ctx, join(root, "host-connections", `${name}.ts`)),
+                message: `Host connection "${composed}" collides with MCP connection "${composed}". Rename one of them.`,
             });
-            return mounted;
-        }
-        const tree = yield readExtensionTree(ctx, site, mount, root);
-        if (tree === undefined) {
-            return mounted;
-        }
-        mounted.description = (_a = mount.extension.description) !== null && _a !== void 0 ? _a : tree.description;
-        const tools = byName(tree.tools);
-        const skills = byName(tree.skills);
-        const connections = byName(tree.connections);
-        const hostConnections = byName(tree.hostConnections);
-        const hooks = byName(tree.hooks);
-        const channels = byId(tree.channels);
-        const schedules = byName(tree.schedules);
-        const subagents = byName(tree.subagents);
-        for (const agent of tree.agents) {
-            subagents.set(agent.name, subagent(agent.name, agent));
+            continue;
         }
-        const seedFiles = new Map(tree.seedFiles.map(seed => [seed.relativePath, seed]));
-        let artifacts = tree.artifacts;
-        let instructions = tree.instructions;
-        if (site.overlayDir !== undefined) {
-            const connectionOverlay = yield moduleEntries(ctx, join(site.overlayDir, "mcp-connections"), "connection");
-            yield overlaySlot(ctx, site, tools, yield moduleEntries(ctx, join(site.overlayDir, "tools"), "tool"), {
-                kind: "tool",
-                disabledKind: "disabled-tool",
-                disableHelper: "disableTool",
-                declared: new Set(tools.keys()),
-                compile: (ctx, path, name, definition) => compileTool(ctx, path, name, definition),
-            });
-            yield overlaySlot(ctx, site, connections, connectionOverlay, {
-                kind: "connection",
-                disabledKind: "disabled-connection",
-                disableHelper: "disableConnection",
-                declared: new Set([...connections.keys(), ...tree.overlaidServers]),
-                compile: (ctx, path, name, definition) => compileConnection(ctx, path, name, definition, "model"),
-            });
-            yield overlaySlot(ctx, site, hostConnections, yield moduleEntries(ctx, join(site.overlayDir, "host-connections"), "connection"), {
-                kind: "connection",
-                disabledKind: "disabled-connection",
-                disableHelper: "disableConnection",
-                declared: new Set(hostConnections.keys()),
-                compile: (ctx, path, name, definition) => compileHostConnection(ctx, path, name, definition),
+        into.hostConnections.push({ ...connection, name: composed });
+        mounted.hostConnections.push(composed);
+    }
+    for (const [name, child] of subagents) {
+        const composed = `${site.ns}__${name}`;
+        into.subagents.push(namespaceSubagent(composed, child));
+        mounted.subagents.push(composed);
+    }
+    for (const [name, hook] of hooks) {
+        const composed = `${site.ns}__${name}`;
+        into.hooks.push({ ...hook, name: composed });
+        mounted.hooks.push(composed);
+    }
+    for (const [id, channel] of channels) {
+        const composed = `${site.ns}__${id}`;
+        into.channels.push({ ...channel, id: composed });
+        mounted.channels.push(composed);
+    }
+    for (const [name, schedule] of schedules) {
+        const composed = `${site.ns}__${name}`;
+        into.schedules.push({ ...schedule, name: composed });
+        mounted.schedules.push(composed);
+    }
+    // Not overlaid: the tree's own tools arm these by definition object, which
+    // an overlay's replacement would no longer resolve to.
+    for (const reminder of tree.reminders) {
+        const composed = `${site.ns}__${reminder.name}`;
+        into.reminders.push({ ...reminder, name: composed });
+        mounted.reminders.push(composed);
+    }
+    if (instructions !== undefined && instructions !== "") {
+        into.instructionParts.push(instructions);
+        mounted.instructions = true;
+    }
+    for (const seed of seedFiles.values()) {
+        if (into.seedFiles.some(existing => existing.relativePath === seed.relativePath)) {
+            ctx.diagnostics.push({
+                severity: "warning",
+                path: displayPath(ctx, seed.sourcePath),
+                message: `Extension seed "${seed.relativePath}" collides with an existing workspace seed; keeping the first.`,
             });
-            yield overlaySkills(ctx, site, skills, join(site.overlayDir, "skills"));
-            yield overlayHooks(ctx, site, hooks, join(site.overlayDir, "hooks"));
-            yield overlayChannels(ctx, site, channels, join(site.overlayDir, "channels"));
-            yield overlaySchedules(ctx, site, schedules, join(site.overlayDir, "schedules"));
-            yield overlaySubagents(ctx, site, subagents, join(site.overlayDir, "subagents"));
-            const overlayInstructions = yield overlayInstructionsFragment(ctx, site.overlayDir);
-            if (overlayInstructions !== "keep") {
-                instructions = overlayInstructions;
-            }
-            for (const seed of yield loadSeedFiles(ctx, site.overlayDir)) {
-                seedFiles.set(seed.relativePath, seed);
-            }
-            artifacts = yield overlayArtifacts(ctx, site.overlayDir, artifacts);
-        }
-        for (const [name, tool] of tools) {
-            const composed = `${site.ns}__${name}`;
-            into.tools.push(Object.assign(Object.assign({}, tool), { name: composed, extension: site.ns }));
-            mounted.tools.push(composed);
-        }
-        for (const [name, skill] of skills) {
-            const composed = `${site.ns}__${name}`;
-            into.skills.push(Object.assign(Object.assign({}, skill), { name: composed, extension: site.ns }));
-            mounted.skills.push(composed);
-        }
-        const modelNames = new Set();
-        for (const [name, connection] of connections) {
-            const composed = `${site.ns}__${name}`;
-            modelNames.add(composed);
-            into.connections.push(Object.assign(Object.assign({}, connection), { name: composed }));
-            mounted.connections.push(composed);
-        }
-        for (const [name, connection] of hostConnections) {
-            const composed = `${site.ns}__${name}`;
-            if (modelNames.has(composed)) {
-                ctx.diagnostics.push({
-                    severity: "error",
-                    path: displayPath(ctx, join(root, "host-connections", `${name}.ts`)),
-                    message: `Host connection "${composed}" collides with MCP connection "${composed}". Rename one of them.`,
-                });
-                continue;
-            }
-            into.hostConnections.push(Object.assign(Object.assign({}, connection), { name: composed }));
-            mounted.hostConnections.push(composed);
-        }
-        for (const [name, child] of subagents) {
-            const composed = `${site.ns}__${name}`;
-            into.subagents.push(namespaceSubagent(composed, child));
-            mounted.subagents.push(composed);
-        }
-        for (const [name, hook] of hooks) {
-            const composed = `${site.ns}__${name}`;
-            into.hooks.push(Object.assign(Object.assign({}, hook), { name: composed }));
-            mounted.hooks.push(composed);
-        }
-        for (const [id, channel] of channels) {
-            const composed = `${site.ns}__${id}`;
-            into.channels.push(Object.assign(Object.assign({}, channel), { id: composed }));
-            mounted.channels.push(composed);
+            continue;
         }
-        for (const [name, schedule] of schedules) {
-            const composed = `${site.ns}__${name}`;
-            into.schedules.push(Object.assign(Object.assign({}, schedule), { name: composed }));
-            mounted.schedules.push(composed);
-        }
-        // Not overlaid: the tree's own tools arm these by definition object, which
-        // an overlay's replacement would no longer resolve to.
-        for (const reminder of tree.reminders) {
-            const composed = `${site.ns}__${reminder.name}`;
-            into.reminders.push(Object.assign(Object.assign({}, reminder), { name: composed }));
-            mounted.reminders.push(composed);
-        }
-        if (instructions !== undefined && instructions !== "") {
-            into.instructionParts.push(instructions);
-            mounted.instructions = true;
-        }
-        for (const seed of seedFiles.values()) {
-            if (into.seedFiles.some(existing => existing.relativePath === seed.relativePath)) {
-                ctx.diagnostics.push({
-                    severity: "warning",
-                    path: displayPath(ctx, seed.sourcePath),
-                    message: `Extension seed "${seed.relativePath}" collides with an existing workspace seed; keeping the first.`,
-                });
-                continue;
-            }
-            into.seedFiles.push(seed);
-            mounted.seedFiles.push(seed.relativePath);
-        }
-        if (artifacts !== undefined) {
-            const kinds = {};
-            for (const [kind, config] of Object.entries((_b = artifacts.kinds) !== null && _b !== void 0 ? _b : {})) {
-                const composed = `${site.ns}__${kind}`;
-                kinds[composed] = config;
-                mounted.artifactKinds.push(composed);
-            }
-            into.artifacts = mergeArtifacts(into.artifacts, Object.assign(Object.assign({}, artifacts), { kinds }));
+        into.seedFiles.push(seed);
+        mounted.seedFiles.push(seed.relativePath);
+    }
+    if (artifacts !== undefined) {
+        const kinds = {};
+        for (const [kind, config] of Object.entries(artifacts.kinds ?? {})) {
+            const composed = `${site.ns}__${kind}`;
+            kinds[composed] = config;
+            mounted.artifactKinds.push(composed);
         }
-        if (mount.hosting !== undefined) {
-            mounted.hosting = mount.hosting;
-            const mountPath = displayPath(ctx, site.mountPath);
-            for (const error of hostingEntryErrors(mount.hosting)) {
-                ctx.diagnostics.push({
-                    severity: "warning",
-                    path: mountPath,
-                    message: `Extension "${site.ns}" hosting.${error}`,
-                });
-            }
+        into.artifacts = mergeArtifacts(into.artifacts, {
+            ...artifacts,
+            kinds,
+        });
+    }
+    if (mount.hosting !== undefined) {
+        mounted.hosting = mount.hosting;
+        const mountPath = displayPath(ctx, site.mountPath);
+        for (const error of hostingEntryErrors(mount.hosting)) {
+            ctx.diagnostics.push({
+                severity: "warning",
+                path: mountPath,
+                message: `Extension "${site.ns}" hosting.${error}`,
+            });
         }
-        return mounted;
-    });
+    }
+    return mounted;
 }
-function readExtensionTree(ctx, site, mount, root) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if ("layout" in mount.extension) {
-            const connectionOverlay = site.overlayDir === undefined
-                ? []
-                : yield moduleEntries(ctx, join(site.overlayDir, "mcp-connections"), "connection");
-            const plugin = yield readCursorPlugin(ctx, root, site.mountPath, mount.extension.variables, new Set(connectionOverlay.map(entry => entry.name)));
-            if (plugin === undefined) {
-                return undefined;
-            }
-            return Object.assign(Object.assign({}, plugin), { tools: [], hostConnections: [], subagents: [], hooks: [], channels: [], schedules: [], reminders: [], seedFiles: [] });
+async function readExtensionTree(ctx, site, mount, root) {
+    if ("layout" in mount.extension) {
+        const connectionOverlay = site.overlayDir === undefined
+            ? []
+            : await moduleEntries(ctx, join(site.overlayDir, "mcp-connections"), "connection");
+        const plugin = await readCursorPlugin(ctx, root, site.mountPath, mount.extension.variables, new Set(connectionOverlay.map(entry => entry.name)));
+        if (plugin === undefined) {
+            return undefined;
         }
-        return readNativeTree(ctx, root, mount.contributions);
-    });
-}
-function readNativeTree(ctx, root, contributions) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield warnAgentRootOnlySlots(ctx, root);
-        const connections = yield loadConnections(ctx, join(root, "mcp-connections"));
         return {
-            tools: (contributions === null || contributions === void 0 ? void 0 : contributions.tools) === false ? [] : yield loadTools(ctx, join(root, "tools")),
-            skills: (contributions === null || contributions === void 0 ? void 0 : contributions.skills) === false ? [] : yield loadSkills(ctx, join(root, "skills")),
-            connections,
-            hostConnections: yield loadHostConnections(ctx, root, connections),
-            overlaidServers: [],
-            agents: [],
-            subagents: yield loadSubagents(ctx, join(root, "subagents")),
-            hooks: yield loadHooks(ctx, join(root, "hooks")),
-            channels: (yield loadChannels(ctx, join(root, "channels"), "extension")).channels,
-            schedules: yield loadSchedules(ctx, join(root, "schedules")),
-            reminders: yield loadReminders(ctx, join(root, "reminders")),
-            instructions: yield loadInstructions(ctx, root, undefined, false),
-            seedFiles: yield loadSeedFiles(ctx, root),
-            artifacts: yield loadArtifacts(ctx, root),
+            ...plugin,
+            tools: [],
+            hostConnections: [],
+            subagents: [],
+            hooks: [],
+            channels: [],
+            schedules: [],
+            reminders: [],
+            seedFiles: [],
         };
-    });
+    }
+    return readNativeTree(ctx, root, mount.contributions);
+}
+async function readNativeTree(ctx, root, contributions) {
+    await warnAgentRootOnlySlots(ctx, root);
+    const connections = await loadConnections(ctx, join(root, "mcp-connections"));
+    return {
+        tools: contributions?.tools === false ? [] : await loadTools(ctx, join(root, "tools")),
+        skills: contributions?.skills === false ? [] : await loadSkills(ctx, join(root, "skills")),
+        connections,
+        hostConnections: await loadHostConnections(ctx, root, connections),
+        overlaidServers: [],
+        agents: [],
+        subagents: await loadSubagents(ctx, join(root, "subagents")),
+        hooks: await loadHooks(ctx, join(root, "hooks")),
+        channels: (await loadChannels(ctx, join(root, "channels"), "extension")).channels,
+        schedules: await loadSchedules(ctx, join(root, "schedules")),
+        reminders: await loadReminders(ctx, join(root, "reminders")),
+        instructions: await loadInstructions(ctx, root, undefined, false),
+        seedFiles: await loadSeedFiles(ctx, root),
+        artifacts: await loadArtifacts(ctx, root),
+    };
 }
 function namespaceSubagent(composed, child) {
     const oldPreamble = buildIdentityPreamble(child.name);
@@ -323,7 +316,11 @@ function namespaceSubagent(composed, child) {
     if (body !== undefined && oldPreamble !== "" && body.startsWith(oldPreamble)) {
         body = body.slice(oldPreamble.length).replace(/^\n+/, "");
     }
-    return Object.assign(Object.assign({}, child), { name: composed, instructions: withIdentityPreamble(composed, body) });
+    return {
+        ...child,
+        name: composed,
+        instructions: withIdentityPreamble(composed, body),
+    };
 }
 function byName(items) {
     return new Map(items.map(item => [item.name, item]));
@@ -336,39 +333,37 @@ function byId(items) {
  * one OTLP exporter. Playground chips are a Vite glob of the agent tree,
  * not a discovery walk. Nested `extensions/` are not mounted.
  */
-function warnAgentRootOnlySlots(ctx, root) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const files = [
-            ["agent.ts", "agent.ts"],
-            ["storage.ts", "storage"],
-            ["otel.ts", "otel"],
-        ];
-        for (const [file, label] of files) {
-            const path = join(root, file);
-            if (yield isFile(path)) {
-                ctx.diagnostics.push({
-                    severity: "warning",
-                    path: displayPath(ctx, path),
-                    message: `The agent that mounts this extension owns ${label}; ignoring.`,
-                });
-            }
+async function warnAgentRootOnlySlots(ctx, root) {
+    const files = [
+        ["agent.ts", "agent.ts"],
+        ["storage.ts", "storage"],
+        ["otel.ts", "otel"],
+    ];
+    for (const [file, label] of files) {
+        const path = join(root, file);
+        if (await isFile(path)) {
+            ctx.diagnostics.push({
+                severity: "warning",
+                path: displayPath(ctx, path),
+                message: `The agent that mounts this extension owns ${label}; ignoring.`,
+            });
         }
-        const dirs = [
-            [
-                "playground",
-                "Playground chips are a Vite glob of the agent tree, not an extension slot; ignoring.",
-            ],
-            ["extensions", "Nested extensions are not mounted; ignoring."],
-        ];
-        for (const [slot, message] of dirs) {
-            const path = join(root, slot);
-            if (yield isDirectory(path)) {
-                ctx.diagnostics.push({
-                    severity: "warning",
-                    path: displayPath(ctx, path),
-                    message,
-                });
-            }
+    }
+    const dirs = [
+        [
+            "playground",
+            "Playground chips are a Vite glob of the agent tree, not an extension slot; ignoring.",
+        ],
+        ["extensions", "Nested extensions are not mounted; ignoring."],
+    ];
+    for (const [slot, message] of dirs) {
+        const path = join(root, slot);
+        if (await isDirectory(path)) {
+            ctx.diagnostics.push({
+                severity: "warning",
+                path: displayPath(ctx, path),
+                message,
+            });
         }
-    });
+    }
 }