@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/inline-stdio-mcp.js

@@ -4,15 +4,6 @@
  * repo-less cloud VM can spawn it. Keep this file free of framework
  * barrels and the official MCP SDK.
  */
-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());
-    });
-};
 const PROTOCOL_VERSION = "2025-03-26";
 function write(message) {
     process.stdout.write(`${JSON.stringify(message)}\n`);
@@ -30,21 +21,19 @@ function isMcpEnvelope(result) {
         Array.isArray(result.content));
 }
 function validateInput(tool, args) {
-    var _a;
-    var _b;
     const record = typeof args === "object" && args !== null ? args : {};
     const schema = tool.inputSchema;
     if (schema === undefined || typeof schema.safeParse !== "function") {
         return { ok: true, value: record };
     }
-    const parsed = schema.safeParse(args !== null && args !== void 0 ? args : {});
+    const parsed = schema.safeParse(args ?? {});
     if (parsed.success) {
         const value = typeof parsed.data === "object" && parsed.data !== null
             ? parsed.data
             : record;
         return { ok: true, value };
     }
-    const issues = (_b = (_a = parsed.error) === null || _a === void 0 ? void 0 : _a.issues) !== null && _b !== void 0 ? _b : [];
+    const issues = parsed.error?.issues ?? [];
     const message = issues
         .map(issue => {
         const path = issue.path.join(".");
@@ -53,107 +42,112 @@ function validateInput(tool, args) {
         .join("; ") || "invalid input";
     return { ok: false, message };
 }
-function handle(message, serverName, tools, catalog) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const method = message.method;
-        if (typeof method !== "string" || !("id" in message)) {
+async function handle(message, serverName, tools, catalog) {
+    const method = message.method;
+    if (typeof method !== "string" || !("id" in message)) {
+        return;
+    }
+    const id = message.id;
+    const params = typeof message.params === "object" && message.params !== null ? message.params : {};
+    try {
+        if (method === "initialize") {
+            const requested = params.protocolVersion;
+            write({
+                jsonrpc: "2.0",
+                id,
+                result: {
+                    protocolVersion: typeof requested === "string" ? requested : PROTOCOL_VERSION,
+                    capabilities: { tools: {} },
+                    serverInfo: { name: serverName, version: "0.1.0" },
+                },
+            });
+            return;
+        }
+        if (method === "ping") {
+            write({ jsonrpc: "2.0", id, result: {} });
             return;
         }
-        const id = message.id;
-        const params = typeof message.params === "object" && message.params !== null ? message.params : {};
-        try {
-            if (method === "initialize") {
-                const requested = params.protocolVersion;
+        if (method === "tools/list") {
+            write({
+                jsonrpc: "2.0",
+                id,
+                result: {
+                    tools: Object.entries(catalog).map(([name, entry]) => ({
+                        name,
+                        description: entry.description,
+                        inputSchema: entry.inputSchema,
+                        ...(entry.outputSchema === undefined ? {} : { outputSchema: entry.outputSchema }),
+                    })),
+                },
+            });
+            return;
+        }
+        if (method === "tools/call") {
+            const name = params.name;
+            const tool = typeof name === "string" ? tools[name] : undefined;
+            if (tool === undefined) {
                 write({
                     jsonrpc: "2.0",
                     id,
                     result: {
-                        protocolVersion: typeof requested === "string" ? requested : PROTOCOL_VERSION,
-                        capabilities: { tools: {} },
-                        serverInfo: { name: serverName, version: "0.1.0" },
+                        content: [{ type: "text", text: `Unknown tool: ${String(name)}` }],
+                        isError: true,
                     },
                 });
                 return;
             }
-            if (method === "ping") {
-                write({ jsonrpc: "2.0", id, result: {} });
-                return;
-            }
-            if (method === "tools/list") {
+            const checked = validateInput(tool, params.arguments);
+            if (!checked.ok) {
                 write({
                     jsonrpc: "2.0",
                     id,
                     result: {
-                        tools: Object.entries(catalog).map(([name, entry]) => (Object.assign({ name, description: entry.description, inputSchema: entry.inputSchema }, (entry.outputSchema === undefined ? {} : { outputSchema: entry.outputSchema })))),
+                        content: [{ type: "text", text: checked.message }],
+                        isError: true,
                     },
                 });
                 return;
             }
-            if (method === "tools/call") {
-                const name = params.name;
-                const tool = typeof name === "string" ? tools[name] : undefined;
-                if (tool === undefined) {
-                    write({
-                        jsonrpc: "2.0",
-                        id,
-                        result: {
-                            content: [{ type: "text", text: `Unknown tool: ${String(name)}` }],
-                            isError: true,
-                        },
-                    });
-                    return;
-                }
-                const checked = validateInput(tool, params.arguments);
-                if (!checked.ok) {
-                    write({
-                        jsonrpc: "2.0",
-                        id,
-                        result: {
-                            content: [{ type: "text", text: checked.message }],
-                            isError: true,
-                        },
-                    });
-                    return;
-                }
-                const result = yield tool.execute(checked.value);
-                if (isMcpEnvelope(result)) {
-                    write({ jsonrpc: "2.0", id, result });
-                    return;
-                }
-                // A tool that advertises an outputSchema must return structuredContent
-                // (MCP clients enforce this), so plain-object results ride along as
-                // structuredContent next to the serialized text.
-                const structuredContent = typeof result === "object" && result !== null && !Array.isArray(result)
-                    ? result
-                    : undefined;
-                write({
-                    jsonrpc: "2.0",
-                    id,
-                    result: Object.assign({ content: [{ type: "text", text: stringifyResult(result) }] }, (structuredContent === undefined ? {} : { structuredContent })),
-                });
+            const result = await tool.execute(checked.value);
+            if (isMcpEnvelope(result)) {
+                write({ jsonrpc: "2.0", id, result });
                 return;
             }
+            // A tool that advertises an outputSchema must return structuredContent
+            // (MCP clients enforce this), so plain-object results ride along as
+            // structuredContent next to the serialized text.
+            const structuredContent = typeof result === "object" && result !== null && !Array.isArray(result)
+                ? result
+                : undefined;
             write({
                 jsonrpc: "2.0",
                 id,
-                error: { code: -32601, message: `Method not found: ${method}` },
-            });
-        }
-        catch (error) {
-            write({
-                jsonrpc: "2.0",
-                id,
-                error: {
-                    code: -32603,
-                    message: error instanceof Error ? error.message : String(error),
+                result: {
+                    content: [{ type: "text", text: stringifyResult(result) }],
+                    ...(structuredContent === undefined ? {} : { structuredContent }),
                 },
             });
+            return;
         }
-    });
+        write({
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32601, message: `Method not found: ${method}` },
+        });
+    }
+    catch (error) {
+        write({
+            jsonrpc: "2.0",
+            id,
+            error: {
+                code: -32603,
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
 }
 export function serveInlineStdioMcp(serverName, definition, catalog) {
-    var _a;
-    const tools = (_a = definition.tools) !== null && _a !== void 0 ? _a : {};
+    const tools = definition.tools ?? {};
     let buffer = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", chunk => {