@cursor/july 0.1.1

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

@@ -0,0 +1,342 @@
+/**
+ * The Cursor account MCP bridge: `defineConnection({ cursorAccount: true })`
+ * resolved for local turns.
+ *
+ * The serve host mounts one loopback-only streamable-HTTP MCP route per
+ * authored account MCP connection (`<base>/v1/cursor-account/<name>/mcp`,
+ * guarded by a per-boot bearer secret). The bridge lists and executes the
+ * account's connector tools through the Cursor backend
+ * (`DashboardService.ListSandMcpTools` / `ExecuteSandMcpTool`), which owns
+ * the OAuth credentials — **raw MCP tokens never enter this process**.
+ *
+ * Cloud-runtime turns reach the same bridge through the serve `publicUrl`
+ * (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";
+import { bearerAuth } from "../../channels.js";
+import { isCursorAccountTransport } from "../../types.js";
+import { handleStatelessMcpRequest } from "../mcp-endpoint.js";
+import { isLoopbackAddress } from "../net.js";
+/** Catalog freshness window; a miss inside it re-uses the cached listing. */
+const CATALOG_TTL_MS = 60000;
+/**
+ * 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;
+/** MCP clients commonly enforce `^[a-zA-Z0-9_-]{1,128}$` for tool names. */
+const MAX_TOOL_NAME_LENGTH = 128;
+/**
+ * Collect `cursorAccount` connections across `mounts`, grouped by mount
+ * slug. Purely structural — per-connector validation happens live against
+ * the account (see {@link CursorAccountMcpBridge.logPreflight}).
+ */
+export function collectCursorAccountConnections(mounts) {
+    const bySlug = new Map();
+    for (const { slug, project } of mounts) {
+        const refs = [];
+        for (const connection of project.agent.connections) {
+            if (!isCursorAccountTransport(connection.transport)) {
+                continue;
+            }
+            refs.push(Object.assign({ name: connection.name }, (connection.transport.servers === undefined
+                ? {}
+                : { servers: [...connection.transport.servers] })));
+        }
+        if (refs.length > 0) {
+            bySlug.set(slug, refs);
+        }
+    }
+    return bySlug;
+}
+/** Bridge mount path for one account MCP connection, relative to the agent base. */
+export function cursorAccountMcpPath(connectionName) {
+    return `/v1/cursor-account/${connectionName}/mcp`;
+}
+/**
+ * Resolve account refs to engine connections once the server is listening.
+ * Local turns and host-side `ctx.host.mcp` reach the loopback bridge with
+ * the per-boot secret. When `publicUrl` is configured, cloud turns use the
+ * same bridge route so `servers` filters apply there too.
+ */
+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 }))));
+}
+export class CursorAccountMcpBridge {
+    constructor(args) {
+        var _a;
+        /** 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.secretPolicy = bearerAuth(this.secret);
+        this.allowRemoteCallers = args.allowRemoteCallers === true;
+    }
+    /**
+     * Route auth for the bridge: the per-boot bearer secret, from a loopback
+     * TCP peer — or from anywhere when the serve host exposed the bridge via
+     * `publicUrl` (cloud turns arrive through that ingress with the secret).
+     */
+    authPolicy() {
+        return (request, info) => __awaiter(this, void 0, void 0, function* () {
+            const loopback = info.requestIp !== null && isLoopbackAddress(info.requestIp);
+            if (!loopback && !this.allowRemoteCallers) {
+                return null;
+            }
+            if ((yield this.secretPolicy(request, info)) === null) {
+                return null;
+            }
+            return {
+                authenticator: "cursor-account-bridge",
+                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) {
+        return handleStatelessMcpRequest({
+            request,
+            buildServer: () => this.buildServer(ref),
+            label: "cursor account bridge",
+            logger: this.logger,
+        });
+    }
+    /**
+     * Startup DX: log the account's connector statuses for `refs` without
+     * blocking serve startup. Surfaces "needsAuth" connectors (authorize in
+     * Cursor) and filters that matched nothing (typo'd connector names).
+     */
+    logPreflight(refs) {
+        for (const ref of refs) {
+            void this.getCatalog(ref)
+                .then((catalog) => {
+                const summary = catalog.servers
+                    .map((server) => `${server.serverIdentifier} (${server.status === "connected"
+                    ? `${server.tools.length} tools`
+                    : server.status})`)
+                    .join(", ");
+                this.logger(`[agent-serve] Cursor account MCP connection "${ref.name}": ${catalog.servers.length === 0
+                    ? "no matching connectors on this account — connect servers in Cursor (dashboard → MCP) or fix the `servers` filter"
+                    : summary}`);
+                const needsAuth = catalog.servers.filter((server) => server.status === "needsAuth");
+                if (needsAuth.length > 0) {
+                    this.logger(`[agent-serve] Cursor account MCP connection "${ref.name}": ${needsAuth
+                        .map((server) => server.serverIdentifier)
+                        .join(", ")} need re-authorization in Cursor before their tools appear`);
+                }
+            })
+                .catch((error) => {
+                this.logger(`[agent-serve] Cursor account MCP connection "${ref.name}" preflight failed: ${describeError(error)}`);
+            });
+        }
+    }
+    buildServer(ref) {
+        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);
+            return {
+                tools: catalog.tools.map((tool) => ({
+                    name: tool.exposedName,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema,
+                })),
+            };
+        }));
+        server.setRequestHandler(CallToolRequestSchema, (request) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const tool = yield this.findTool(ref, request.params.name);
+            if (tool === undefined) {
+                const catalog = yield this.getCatalog(ref);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Unknown tool "${request.params.name}". Available: ${catalog.tools.map((t) => t.exposedName).join(", ") || "(none)"}.`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            try {
+                const result = yield this.client.executeAccountMcpTool({
+                    serverIdentifier: tool.serverIdentifier,
+                    toolName: tool.backendName,
+                    args: (_a = request.params.arguments) !== null && _a !== void 0 ? _a : {},
+                });
+                return Object.assign(Object.assign({ content: result.content }, (result.isError ? { isError: true } : {})), (result.structuredContent === undefined
+                    ? {}
+                    : { structuredContent: result.structuredContent }));
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Account connector tool failed: ${describeError(error)}`,
+                        },
+                    ],
+                    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);
+        });
+    }
+    /**
+     * Fetch (or join) the catalog for `ref`'s server filter. Staleness and
+     * joining are decided synchronously: in-flight entries always join their
+     * 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) {
+            if (entry.freshAtMs === undefined) {
+                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;
+            if (age < maxAge) {
+                return entry.promise;
+            }
+        }
+        const fresh = {
+            promise: this.client
+                .listAccountMcpTools((_a = ref.servers) !== null && _a !== void 0 ? _a : [])
+                .then((servers) => {
+                const catalog = buildCatalog(servers);
+                fresh.freshAtMs = Date.now();
+                return catalog;
+            })
+                .catch((error) => {
+                // Never cache a failure — but only evict our own entry, so a slow
+                // failing fetch cannot delete a newer, healthy refresh.
+                if (this.catalogs.get(key) === fresh) {
+                    this.catalogs.delete(key);
+                }
+                throw error;
+            }),
+        };
+        this.catalogs.set(key, fresh);
+        return fresh.promise;
+    }
+}
+/**
+ * Build the exposed-tool catalog. Collision suffixes are assigned after
+ * sorting the colliding group by backend identity, so the exposed-name →
+ * backend-tool mapping is stable across refreshes even when the backend
+ * enumerates servers in a different order.
+ */
+function buildCatalog(servers) {
+    const byBase = new Map();
+    for (const server of servers) {
+        for (const tool of server.tools) {
+            const base = sanitizeToolName(tool.name);
+            const group = byBase.get(base);
+            const item = { serverIdentifier: server.serverIdentifier, tool };
+            if (group === undefined) {
+                byBase.set(base, [item]);
+            }
+            else {
+                group.push(item);
+            }
+        }
+    }
+    const tools = [];
+    const byExposedName = new Map();
+    // Process sanitize bases in deterministic order so cross-group exposed-name
+    // reservation does not depend on backend server listing order.
+    const sortedBases = [...byBase.keys()].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+    for (const base of sortedBases) {
+        const group = byBase.get(base);
+        // Codepoint comparison (not localeCompare): the suffix assignment must
+        // be identical on every host and across refreshes.
+        group.sort((a, b) => {
+            const left = `${a.serverIdentifier}\n${a.tool.name}`;
+            const right = `${b.serverIdentifier}\n${b.tool.name}`;
+            return left < right ? -1 : left > right ? 1 : 0;
+        });
+        group.forEach(({ serverIdentifier, tool }, index) => {
+            let suffixIndex = index;
+            let exposedName = suffixToolName(base, suffixIndex);
+            while (byExposedName.has(exposedName)) {
+                suffixIndex++;
+                exposedName = suffixToolName(base, suffixIndex);
+            }
+            const entry = {
+                exposedName,
+                backendName: tool.name,
+                serverIdentifier,
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+            };
+            tools.push(entry);
+            byExposedName.set(entry.exposedName, entry);
+        });
+    }
+    return { servers, tools, byExposedName };
+}
+/** Connector display names can contain anything (spaces, dots, emoji). */
+function sanitizeToolName(name) {
+    const cleaned = name
+        .replace(/[^a-zA-Z0-9_-]/g, "_")
+        .slice(0, MAX_TOOL_NAME_LENGTH);
+    return cleaned === "" ? "tool" : cleaned;
+}
+/** `base` for the first claimant, `base_2` / `base_3` … for colliders. */
+function suffixToolName(base, index) {
+    if (index === 0) {
+        return base;
+    }
+    const suffix = `_${index + 1}`;
+    return `${base.slice(0, MAX_TOOL_NAME_LENGTH - suffix.length)}${suffix}`;
+}
+function trimTrailingSlash(url) {
+    return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/internal/cursor/backend-client.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Minimal Connect-JSON client for the handful of `aiserver.v1.DashboardService`
+ * RPCs agent-serve needs — `GetMe`, `ListSandMcpTools`, `ExecuteSandMcpTool`,
+ * and the login-time key lifecycle (`CreateUserApiKey`, `ListUserApiKeys`,
+ * `RevokeUserApiKey`).
+ *
+ * Plain `fetch` POSTs with proto-JSON bodies and zod-validated responses:
+ * agent-serve is a published package and should not pull the generated
+ * proto tree in for a few unary calls.
+ *
+ * Auth: the client holds the account API key and exchanges it on demand for
+ * a short-lived access token (`POST /auth/exchange_user_api_key`, ~1h),
+ * cached until shortly before expiry and re-exchanged once on a 401.
+ */
+import { z } from "zod";
+export declare class CursorBackendError extends Error {
+    readonly status?: number | undefined;
+    constructor(message: string, status?: number | undefined);
+}
+declare const getMeResponseSchema: z.ZodObject<{
+    authId: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    firstName: z.ZodOptional<z.ZodString>;
+    lastName: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodNumber>;
+    teamName: z.ZodOptional<z.ZodString>;
+}, "strip">;
+export type CursorIdentity = z.infer<typeof getMeResponseSchema>;
+export interface AccountMcpTool {
+    /** Fully-qualified tool name (`<server>-<tool>`), the execution key. */
+    name: string;
+    description: string;
+    /** JSON Schema for the tool input (defaulted when the server omits it). */
+    inputSchema: Record<string, unknown>;
+}
+export interface AccountMcpServer {
+    serverIdentifier: string;
+    status: string;
+    tools: AccountMcpTool[];
+}
+/** Normalized tool-call outcome, shaped like an MCP `CallToolResult`. */
+export interface AccountMcpCallResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        data: string;
+        mimeType?: string;
+    }>;
+    isError: boolean;
+    structuredContent?: Record<string, unknown>;
+}
+export interface CursorBackendClientOptions {
+    backendUrl: string;
+    apiKey: string;
+    logger?: (line: string) => void;
+    /** Test seam; defaults to global fetch. */
+    fetchImpl?: typeof fetch;
+}
+export declare class CursorBackendClient {
+    private readonly backendUrl;
+    private readonly apiKey;
+    private readonly logger;
+    private readonly fetchImpl;
+    private token;
+    private tokenExchange;
+    constructor(options: CursorBackendClientOptions);
+    /** Who this API key acts as. */
+    getMe(): Promise<CursorIdentity>;
+    /**
+     * The account's MCP connectors with live status and backend-prefixed tool
+     * definitions. `serverIdentifiers` restricts discovery (empty = all
+     * HTTP/SSE servers on the account).
+     */
+    listAccountMcpTools(serverIdentifiers: readonly string[]): Promise<AccountMcpServer[]>;
+    /**
+     * Execute one connector tool **on the Cursor backend** with the account's
+     * stored OAuth credentials. `toolName` is the fully-qualified name from
+     * {@link listAccountMcpTools}.
+     */
+    executeAccountMcpTool(args: {
+        serverIdentifier: string;
+        toolName: string;
+        args: Record<string, unknown>;
+    }): Promise<AccountMcpCallResult>;
+    private rpc;
+    private getAccessToken;
+    private exchangeApiKey;
+}
+/**
+ * Mint a named user API key from a short-lived login session token. Used
+ * exactly once per `agent-serve login`; the session token is then discarded.
+ */
+export declare function createUserApiKeyWithSessionToken(args: {
+    backendUrl: string;
+    sessionToken: string;
+    keyName: string;
+    fetchImpl?: typeof fetch;
+}): Promise<string>;
+/**
+ * Best-effort cleanup when `login` mints a key but fails before storing it,
+ * authenticated with the browser session token that minted it. The key is
+ * identified by its masked suffix in `ListUserApiKeys` — never by name alone,
+ * so replica lag after `CreateUserApiKey` can only skip the cleanup, not
+ * revoke an older same-named key.
+ */
+export declare function revokeMintedUserApiKey(args: {
+    backendUrl: string;
+    keyName: string;
+    /** The raw minted key; selects the exact list row via `maskedKey`. */
+    apiKey: string;
+    /** Session token from the PKCE login; the bearer for list + revoke. */
+    sessionToken: string;
+    fetchImpl?: typeof fetch;
+}): Promise<void>;
+export {};
+//# sourceMappingURL=backend-client.d.ts.map

package/dist/internal/cursor/backend-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend-client.d.ts","sourceRoot":"","sources":["../../../src/internal/cursor/backend-client.ts"],"names":[],"mappings":"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"}