@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/cursor/account-mcp.js

@@ -13,15 +13,6 @@
  * (so `servers` filters apply there too); without one they omit the bridge
  * and fall back to the account's natively hydrated connectors.
  */
-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 { randomBytes } from "node:crypto";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
@@ -35,12 +26,12 @@ import { isLoopbackAddress } from "../net.js";
 import { sanitizeMcpToolName, suffixMcpToolName } from "../sanitize-mcp-tool-name.js";
 import { colorEnabledFor, formatTerminalBox, stdoutPalette, terminalHyperlink, } from "../terminal-style.js";
 /** Catalog freshness window; a miss inside it re-uses the cached listing. */
-const CATALOG_TTL_MS = 60000;
+const CATALOG_TTL_MS = 60_000;
 /**
  * Unknown-tool lookups force a refresh, but never more often than this —
  * a model hallucinating tool names cannot turn into a backend hot loop.
  */
-const FORCE_REFRESH_MIN_INTERVAL_MS = 5000;
+const FORCE_REFRESH_MIN_INTERVAL_MS = 5_000;
 /** Dashboard Integrations & MCP — reconnect team / account connectors. */
 export const CURSOR_ACCOUNT_MCP_DASHBOARD_URL = "https://cursor.com/dashboard/integrations";
 /** Cursor app Settings → MCP (Connect / Authenticate on the named row). */
@@ -51,20 +42,22 @@ export const CURSOR_ACCOUNT_MCP_SETTINGS_DEEPLINK = "cursor://anysphere.cursor-d
  * the account (see {@link CursorAccountMcpBridge.logPreflight}).
  */
 export function collectCursorAccountConnections(mounts) {
-    var _a;
     const bySlug = new Map();
     for (const { slug, project } of mounts) {
         const refs = [];
         for (const connection of [
             ...project.agent.connections,
-            ...((_a = project.agent.hostConnections) !== null && _a !== void 0 ? _a : []),
+            ...(project.agent.hostConnections ?? []),
         ]) {
             if (!isCursorAccountTransport(connection.transport)) {
                 continue;
             }
-            refs.push(Object.assign({ name: connection.name }, (connection.transport.servers === undefined
-                ? {}
-                : { servers: [...connection.transport.servers] })));
+            refs.push({
+                name: connection.name,
+                ...(connection.transport.servers === undefined
+                    ? {}
+                    : { servers: [...connection.transport.servers] }),
+            });
         }
         if (refs.length > 0) {
             bySlug.set(slug, refs);
@@ -86,21 +79,26 @@ export function resolveCursorAccountConnections(args) {
     const serverBase = trimTrailingSlash(args.serverUrl);
     const publicBase = args.publicUrl === undefined ? undefined : trimTrailingSlash(args.publicUrl);
     const headers = { authorization: `Bearer ${args.bridgeSecret}` };
-    return args.refs.map(ref => (Object.assign(Object.assign(Object.assign({ name: ref.name, localUrl: `${serverBase}${args.basePath}${cursorAccountMcpPath(ref.name)}` }, (publicBase === undefined
-        ? {}
-        : {
-            cloudUrl: `${publicBase}${args.basePath}${cursorAccountMcpPath(ref.name)}`,
-        })), { headers }), (ref.servers === undefined ? {} : { accountServersFilter: ref.servers }))));
+    return args.refs.map(ref => ({
+        name: ref.name,
+        localUrl: `${serverBase}${args.basePath}${cursorAccountMcpPath(ref.name)}`,
+        ...(publicBase === undefined
+            ? {}
+            : {
+                cloudUrl: `${publicBase}${args.basePath}${cursorAccountMcpPath(ref.name)}`,
+            }),
+        headers,
+        ...(ref.servers === undefined ? {} : { accountServersFilter: ref.servers }),
+    }));
 }
 export class CursorAccountMcpBridge {
     constructor(args) {
-        var _a, _b;
         /** Per-boot shared secret; resolved connections carry it as a bearer. */
         this.secret = randomBytes(32).toString("hex");
         this.catalogs = new Map();
         this.client = args.client;
-        this.logger = (_a = args.logger) !== null && _a !== void 0 ? _a : (() => { });
-        this.palette = (_b = args.palette) !== null && _b !== void 0 ? _b : stdoutPalette();
+        this.logger = args.logger ?? (() => { });
+        this.palette = args.palette ?? stdoutPalette();
         this.secretPolicy = bearerAuth(this.secret);
         this.allowRemoteCallers = args.allowRemoteCallers === true;
     }
@@ -110,12 +108,12 @@ export class CursorAccountMcpBridge {
      * `publicUrl` (cloud turns arrive through that ingress with the secret).
      */
     authPolicy() {
-        return (request, info) => __awaiter(this, void 0, void 0, function* () {
+        return async (request, info) => {
             const loopback = info.requestIp !== null && isLoopbackAddress(info.requestIp);
             if (!loopback && !this.allowRemoteCallers) {
                 return null;
             }
-            if ((yield this.secretPolicy(request, info)) === null) {
+            if ((await this.secretPolicy(request, info)) === null) {
                 return null;
             }
             return {
@@ -123,15 +121,14 @@ export class CursorAccountMcpBridge {
                 principalId: "cursor-account-bridge",
                 principalType: "runtime",
             };
-        });
+        };
     }
     /**
      * Handle one streamable-HTTP MCP request for the connection described by
      * `ref` (stateless: fresh server per POST, like the per-agent endpoint).
      */
     handle(request, ref, decorate) {
-        var _a;
-        const sessionId = (_a = new URL(request.url).searchParams.get("agentkitSessionId")) !== null && _a !== void 0 ? _a : "";
+        const sessionId = new URL(request.url).searchParams.get("agentkitSessionId") ?? "";
         return handleStatelessMcpRequest({
             request,
             buildServer: () => this.buildServer(ref, sessionId, decorate),
@@ -148,89 +145,92 @@ export class CursorAccountMcpBridge {
      * Returns a promise that settles when every ref's log lines are written —
      * callers may ignore it; tests can await it.
      */
-    probeAuthUrl(ref) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const identifiers = ref.servers !== undefined && ref.servers.length > 0
-                ? [...ref.servers]
-                : (yield this.client.getAvailableMcpServers()).map(server => { var _a; return (_a = server.serverIdentifier) !== null && _a !== void 0 ? _a : server.name; });
-            const urls = yield probeConnectorAuthUrls({
-                client: this.client,
-                identifiers,
-            });
-            for (const url of urls.values()) {
-                if (url !== "") {
-                    return url;
-                }
-            }
-            return undefined;
+    async probeAuthUrl(ref) {
+        const identifiers = ref.servers !== undefined && ref.servers.length > 0
+            ? [...ref.servers]
+            : (await this.client.getAvailableMcpServers()).map(server => server.serverIdentifier ?? server.name);
+        const urls = await probeConnectorAuthUrls({
+            client: this.client,
+            identifiers,
         });
+        for (const url of urls.values()) {
+            if (url !== "") {
+                return url;
+            }
+        }
+        return undefined;
     }
     logPreflight(refs) {
         return Promise.all(refs.map(ref => this.runPreflight(ref))).then(() => undefined);
     }
-    runPreflight(ref) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const catalog = yield this.getCatalog(ref);
-                const errorDetails = new Map();
-                const needsAuthNames = catalog.servers
-                    .filter(server => server.status === "needsAuth")
-                    .map(server => server.serverIdentifier);
-                const [authUrls] = yield Promise.all([
-                    probeConnectorAuthUrls({
-                        client: this.client,
-                        identifiers: needsAuthNames,
-                    }),
-                    Promise.all(catalog.servers
-                        .filter(server => server.status === "error")
-                        .map((server) => __awaiter(this, void 0, void 0, function* () {
-                        const detail = yield diagnoseConnectorError(this.client, server.serverIdentifier);
-                        if (detail !== undefined) {
-                            errorDetails.set(server.serverIdentifier, detail);
-                        }
-                    }))),
-                ]);
-                const unhealthy = catalog.servers.some(server => server.status === "needsAuth" || server.status === "error");
-                if (catalog.servers.length === 0 || unhealthy) {
-                    this.logger(formatCursorAccountMcpWarningBox({
-                        connectionName: ref.name,
-                        servers: catalog.servers.map(server => ({
-                            serverIdentifier: server.serverIdentifier,
-                            status: server.status,
-                            toolCount: server.tools.length,
-                            errorDetail: errorDetails.get(server.serverIdentifier),
-                            authUrl: authUrls.get(server.serverIdentifier),
-                        })),
-                        palette: this.palette,
-                    }));
-                    return;
-                }
-                const summary = catalog.servers
-                    .map(server => formatServerStatusSummary(server, errorDetails.get(server.serverIdentifier)))
-                    .join(", ");
-                this.logger(`${LOG_PREFIX} Cursor account MCP connection "${ref.name}": ${summary}`);
-            }
-            catch (error) {
-                this.logger(`${LOG_PREFIX} Cursor account MCP connection "${ref.name}" preflight failed: ${describeError(error)}`);
+    async runPreflight(ref) {
+        try {
+            const catalog = await this.getCatalog(ref);
+            const errorDetails = new Map();
+            const needsAuthNames = catalog.servers
+                .filter(server => server.status === "needsAuth")
+                .map(server => server.serverIdentifier);
+            const [authUrls] = await Promise.all([
+                probeConnectorAuthUrls({
+                    client: this.client,
+                    identifiers: needsAuthNames,
+                }),
+                Promise.all(catalog.servers
+                    .filter(server => server.status === "error")
+                    .map(async (server) => {
+                    const detail = await diagnoseConnectorError(this.client, server.serverIdentifier);
+                    if (detail !== undefined) {
+                        errorDetails.set(server.serverIdentifier, detail);
+                    }
+                })),
+            ]);
+            const unhealthy = catalog.servers.some(server => server.status === "needsAuth" || server.status === "error");
+            if (catalog.servers.length === 0 || unhealthy) {
+                this.logger(formatCursorAccountMcpWarningBox({
+                    connectionName: ref.name,
+                    servers: catalog.servers.map(server => ({
+                        serverIdentifier: server.serverIdentifier,
+                        status: server.status,
+                        toolCount: server.tools.length,
+                        errorDetail: errorDetails.get(server.serverIdentifier),
+                        authUrl: authUrls.get(server.serverIdentifier),
+                    })),
+                    palette: this.palette,
+                }));
+                return;
             }
-        });
+            const summary = catalog.servers
+                .map(server => formatServerStatusSummary(server, errorDetails.get(server.serverIdentifier)))
+                .join(", ");
+            this.logger(`${LOG_PREFIX} Cursor account MCP connection "${ref.name}": ${summary}`);
+        }
+        catch (error) {
+            this.logger(`${LOG_PREFIX} Cursor account MCP connection "${ref.name}" preflight failed: ${describeError(error)}`);
+        }
     }
     buildServer(ref, sessionId, decorate) {
         const server = new Server({ name: `cursor-account:${ref.name}`, version: "0.1.0" }, {
             capabilities: { tools: {} },
             instructions: "Tools from the Cursor account's MCP connectors. Every call executes on the Cursor backend with the account's stored credentials.",
         });
-        server.setRequestHandler(ListToolsRequestSchema, () => __awaiter(this, void 0, void 0, function* () {
-            const catalog = yield this.getCatalog(ref);
+        server.setRequestHandler(ListToolsRequestSchema, async () => {
+            const catalog = await this.getCatalog(ref);
             return {
-                tools: catalog.tools.map(tool => (Object.assign(Object.assign({ name: tool.exposedName, description: tool.description, inputSchema: tool.inputSchema }, (tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema })), (tool.annotations === undefined ? {} : { annotations: tool.annotations })))),
+                tools: catalog.tools.map(tool => ({
+                    name: tool.exposedName,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema,
+                    ...(tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema }),
+                    // Already bounded to the MCP-spec fields at the backend-client
+                    // parse; absent stays absent so classifiers fail closed.
+                    ...(tool.annotations === undefined ? {} : { annotations: tool.annotations }),
+                })),
             };
-        }));
-        server.setRequestHandler(CallToolRequestSchema, (request) => __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const tool = yield this.findTool(ref, request.params.name);
+        });
+        server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const tool = await this.findTool(ref, request.params.name);
             if (tool === undefined) {
-                const catalog = yield this.getCatalog(ref);
+                const catalog = await this.getCatalog(ref);
                 const unhealthy = catalog.servers.filter(server => server.status !== "connected");
                 const statusHint = unhealthy.length === 0
                     ? ""
@@ -248,10 +248,10 @@ export class CursorAccountMcpBridge {
                 };
             }
             try {
-                const executed = yield this.client.executeAccountMcpTool({
+                const executed = await this.client.executeAccountMcpTool({
                     serverIdentifier: tool.serverIdentifier,
                     toolName: tool.backendName,
-                    args: (_a = request.params.arguments) !== null && _a !== void 0 ? _a : {},
+                    args: request.params.arguments ?? {},
                 });
                 const decorated = decorate === undefined ? executed : decorate(sessionId, executed);
                 return {
@@ -271,20 +271,18 @@ export class CursorAccountMcpBridge {
                     isError: true,
                 };
             }
-        }));
+        });
         return server;
     }
     /** Resolve a tool by exposed name, refreshing once when it is unknown. */
-    findTool(ref, exposedName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const catalog = yield this.getCatalog(ref);
-            const hit = catalog.byExposedName.get(exposedName);
-            if (hit !== undefined) {
-                return hit;
-            }
-            const fresh = yield this.getCatalog(ref, { forceRefresh: true });
-            return fresh.byExposedName.get(exposedName);
-        });
+    async findTool(ref, exposedName) {
+        const catalog = await this.getCatalog(ref);
+        const hit = catalog.byExposedName.get(exposedName);
+        if (hit !== undefined) {
+            return hit;
+        }
+        const fresh = await this.getCatalog(ref, { forceRefresh: true });
+        return fresh.byExposedName.get(exposedName);
     }
     /**
      * Fetch (or join) the catalog for `ref`'s server filter. Staleness and
@@ -292,7 +290,6 @@ export class CursorAccountMcpBridge {
      * promise; fresh entries use {@link CatalogEntry.freshAtMs} for TTL.
      */
     getCatalog(ref, options) {
-        var _a;
         const key = ref.servers === undefined ? "*" : [...ref.servers].sort().join("\n");
         const entry = this.catalogs.get(key);
         if (entry !== undefined) {
@@ -300,14 +297,14 @@ export class CursorAccountMcpBridge {
                 return entry.promise;
             }
             const age = Date.now() - entry.freshAtMs;
-            const maxAge = (options === null || options === void 0 ? void 0 : options.forceRefresh) === true ? FORCE_REFRESH_MIN_INTERVAL_MS : CATALOG_TTL_MS;
+            const maxAge = options?.forceRefresh === true ? FORCE_REFRESH_MIN_INTERVAL_MS : CATALOG_TTL_MS;
             if (age < maxAge) {
                 return entry.promise;
             }
         }
         const fresh = {
             promise: this.client
-                .listAccountMcpTools((_a = ref.servers) !== null && _a !== void 0 ? _a : [])
+                .listAccountMcpTools(ref.servers ?? [])
                 .then(servers => {
                 const catalog = buildCatalog(servers);
                 fresh.freshAtMs = Date.now();
@@ -368,7 +365,15 @@ function buildCatalog(servers) {
                 suffixIndex++;
                 exposedName = suffixMcpToolName(base, suffixIndex);
             }
-            const entry = Object.assign(Object.assign({ exposedName, backendName: tool.name, serverIdentifier, description: tool.description, inputSchema: tool.inputSchema }, (tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema })), (tool.annotations === undefined ? {} : { annotations: tool.annotations }));
+            const entry = {
+                exposedName,
+                backendName: tool.name,
+                serverIdentifier,
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+                ...(tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema }),
+                ...(tool.annotations === undefined ? {} : { annotations: tool.annotations }),
+            };
             tools.push(entry);
             byExposedName.set(entry.exposedName, entry);
         });
@@ -404,8 +409,7 @@ function formatWarningStatusRow(server, nameWidth, hyperlinks) {
     }
 }
 function connectUrl(authUrl) {
-    var _a;
-    const minted = (_a = authUrl === null || authUrl === void 0 ? void 0 : authUrl.trim()) !== null && _a !== void 0 ? _a : "";
+    const minted = authUrl?.trim() ?? "";
     if (minted.startsWith("https://") && !minted.includes("\u001b") && !minted.includes("\u0007")) {
         return minted;
     }
@@ -416,10 +420,9 @@ function connectUrl(authUrl) {
  * One box replaces the old stacked `[bdk]` log lines.
  */
 export function formatCursorAccountMcpWarningBox(args) {
-    var _a, _b;
-    const palette = (_a = args.palette) !== null && _a !== void 0 ? _a : stdoutPalette();
-    const hyperlinks = (_b = args.hyperlinks) !== null && _b !== void 0 ? _b : colorEnabledFor();
-    const copy = warningCopy(Object.assign(Object.assign({}, args), { hyperlinks }));
+    const palette = args.palette ?? stdoutPalette();
+    const hyperlinks = args.hyperlinks ?? colorEnabledFor();
+    const copy = warningCopy({ ...args, hyperlinks });
     return `\n${formatTerminalBox([copy.title, "", ...copy.intro, ...copy.actions], {
         color: palette.yellow,
         padding: 2,
@@ -480,31 +483,29 @@ export function formatServerStatusSummary(server, errorDetail) {
  * returns the status enum today, so probe ExecuteSandMcpTool (ping) and surface
  * the backend failure text (e.g. `HTTP MCP tool execution failed: fetch failed`).
  */
-export function diagnoseConnectorError(client, serverIdentifier) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const result = yield client.executeAccountMcpTool({
-                serverIdentifier,
-                // Conventional health tool; even a tool-not-found path usually still
-                // surfaces the same transport failure when the connector is down.
-                toolName: `${serverIdentifier}-ping`,
-                args: {},
-            });
-            const text = result.content
-                .filter((part) => part.type === "text")
-                .map(part => part.text.trim())
-                .filter(part => part.length > 0)
-                .join(" ");
-            if (result.isError) {
-                return text.length > 0 ? text : "backend reported an error with no detail";
-            }
-            // Listing said error but ping succeeded — surface that inconsistency.
-            return text.length > 0
-                ? `listing reported error but probe succeeded: ${text}`
-                : "listing reported error but probe succeeded";
-        }
-        catch (error) {
-            return describeError(error);
+export async function diagnoseConnectorError(client, serverIdentifier) {
+    try {
+        const result = await client.executeAccountMcpTool({
+            serverIdentifier,
+            // Conventional health tool; even a tool-not-found path usually still
+            // surfaces the same transport failure when the connector is down.
+            toolName: `${serverIdentifier}-ping`,
+            args: {},
+        });
+        const text = result.content
+            .filter((part) => part.type === "text")
+            .map(part => part.text.trim())
+            .filter(part => part.length > 0)
+            .join(" ");
+        if (result.isError) {
+            return text.length > 0 ? text : "backend reported an error with no detail";
         }
-    });
+        // Listing said error but ping succeeded — surface that inconsistency.
+        return text.length > 0
+            ? `listing reported error but probe succeeded: ${text}`
+            : "listing reported error but probe succeeded";
+    }
+    catch (error) {
+        return describeError(error);
+    }
 }