@cursor/bdk 0.2.8 → 0.2.10

package/dist/internal/mcp-oauth-on-demand.js

@@ -6,15 +6,6 @@
  * CLI `mcp oauth` still uses the loopback callback. This path is recovery
  * and first-use without a separate `--store` step.
  */
-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 { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
@@ -29,68 +20,63 @@ export function mcpOauthServeCallbackPath(basePath = "") {
 export function mcpOauthServeCallbackUrl(origin, basePath = "") {
     return `${origin.replace(/\/$/, "")}${mcpOauthServeCallbackPath(basePath)}`;
 }
-export function beginHostMcpOauth(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        let authorizationUrl;
-        const provider = yield createHostMcpOAuthProvider({
-            identifier: args.connection,
-            resourceUrl: args.url,
-            store: args.store,
-            redirectUrl: args.redirectUrl,
-            onRedirect: url => {
-                authorizationUrl = url;
-            },
-        });
-        const client = new Client({ name: "agent-sdk-mcp-oauth", version: "0.1.0" });
-        const url = new URL(args.url);
-        const requestInit = args.headers === undefined ? undefined : { headers: args.headers };
-        const makeTransport = () => {
-            if (args.type === "sse") {
-                return new SSEClientTransport(url, {
-                    authProvider: provider,
-                    requestInit,
-                });
-            }
-            return new StreamableHTTPClientTransport(url, {
+export async function beginHostMcpOauth(args) {
+    let authorizationUrl;
+    const provider = await createHostMcpOAuthProvider({
+        identifier: args.connection,
+        resourceUrl: args.url,
+        store: args.store,
+        redirectUrl: args.redirectUrl,
+        onRedirect: url => {
+            authorizationUrl = url;
+        },
+    });
+    const client = new Client({ name: "agent-sdk-mcp-oauth", version: "0.1.0" });
+    const url = new URL(args.url);
+    const requestInit = args.headers === undefined ? undefined : { headers: args.headers };
+    const makeTransport = () => {
+        if (args.type === "sse") {
+            return new SSEClientTransport(url, {
                 authProvider: provider,
                 requestInit,
             });
-        };
-        const transport = makeTransport();
-        try {
-            yield client.connect(transport);
-            yield client.close().catch(() => undefined);
-            return { status: "authorized" };
-        }
-        catch (error) {
-            if (!(error instanceof UnauthorizedError)) {
-                throw error;
-            }
         }
-        const redirect = authorizationUrl !== null && authorizationUrl !== void 0 ? authorizationUrl : provider.lastRedirectUrl;
-        if (redirect === undefined) {
-            throw new Error(`Auth required for "${args.connection}" but no authorization URL was provided.`);
-        }
-        const state = (_a = redirect.searchParams.get("state")) !== null && _a !== void 0 ? _a : "";
-        if (state === "") {
-            throw new Error(`Auth required for "${args.connection}" but the authorization URL had no state.`);
+        return new StreamableHTTPClientTransport(url, {
+            authProvider: provider,
+            requestInit,
+        });
+    };
+    const transport = makeTransport();
+    try {
+        await client.connect(transport);
+        await client.close().catch(() => undefined);
+        return { status: "authorized" };
+    }
+    catch (error) {
+        if (!(error instanceof UnauthorizedError)) {
+            throw error;
         }
-        return {
-            status: "needs_auth",
-            authUrl: redirect.toString(),
-            state,
-            finish: (code) => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                yield transport.finishAuth(code);
-                yield (_a = transport.close) === null || _a === void 0 ? void 0 : _a.call(transport).catch(() => undefined);
-            }),
-            abort: () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                yield (_a = transport.close) === null || _a === void 0 ? void 0 : _a.call(transport).catch(() => undefined);
-            }),
-        };
-    });
+    }
+    const redirect = authorizationUrl ?? provider.lastRedirectUrl;
+    if (redirect === undefined) {
+        throw new Error(`Auth required for "${args.connection}" but no authorization URL was provided.`);
+    }
+    const state = redirect.searchParams.get("state") ?? "";
+    if (state === "") {
+        throw new Error(`Auth required for "${args.connection}" but the authorization URL had no state.`);
+    }
+    return {
+        status: "needs_auth",
+        authUrl: redirect.toString(),
+        state,
+        finish: async (code) => {
+            await transport.finishAuth(code);
+            await transport.close?.().catch(() => undefined);
+        },
+        abort: async () => {
+            await transport.close?.().catch(() => undefined);
+        },
+    };
 }
 export class McpOauthOnDemandHub {
     constructor() {
@@ -99,69 +85,58 @@ export class McpOauthOnDemandHub {
         this.finishing = new Map();
         this.aborted = new Set();
     }
-    mint(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const redirectUrl = (_a = this.callbackUrl) !== null && _a !== void 0 ? _a : MCP_OAUTH_CALLBACK_URL;
-            const store = this.fileStore();
-            const started = yield beginHostMcpOauth({
-                connection: args.connection,
-                url: args.url,
-                type: args.type,
-                headers: args.headers,
-                redirectUrl,
-                store,
-            });
-            if (started.status === "authorized") {
-                return { authorized: true };
-            }
-            this.attempts.set(started.state, {
-                connection: args.connection,
-                resourceUrl: args.url,
-                finish: started.finish,
-                abort: started.abort,
-                sessionId: args.sessionId,
-            });
-            return { authUrl: started.authUrl, state: started.state };
+    async mint(args) {
+        const redirectUrl = this.callbackUrl ?? MCP_OAUTH_CALLBACK_URL;
+        const store = this.fileStore();
+        const started = await beginHostMcpOauth({
+            connection: args.connection,
+            url: args.url,
+            type: args.type,
+            headers: args.headers,
+            redirectUrl,
+            store,
         });
-    }
-    abortCall(sessionId, callId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.dropWhere(attempt => attempt.sessionId === sessionId && attempt.callId === callId, true);
+        if (started.status === "authorized") {
+            return { authorized: true };
+        }
+        this.attempts.set(started.state, {
+            connection: args.connection,
+            resourceUrl: args.url,
+            finish: started.finish,
+            abort: started.abort,
+            sessionId: args.sessionId,
         });
+        return { authUrl: started.authUrl, state: started.state };
     }
-    abortSession(sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.dropWhere(attempt => attempt.sessionId === sessionId, false);
-        });
+    async abortCall(sessionId, callId) {
+        await this.dropWhere(attempt => attempt.sessionId === sessionId && attempt.callId === callId, true);
     }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.dropWhere(() => true, true);
-        });
+    async abortSession(sessionId) {
+        await this.dropWhere(attempt => attempt.sessionId === sessionId, false);
+    }
+    async close() {
+        await this.dropWhere(() => true, true);
     }
-    dropWhere(match, includeCompleted) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const jobs = [];
-            for (const [state, attempt] of this.attempts) {
+    async dropWhere(match, includeCompleted) {
+        const jobs = [];
+        for (const [state, attempt] of this.attempts) {
+            if (!match(attempt)) {
+                continue;
+            }
+            this.aborted.add(state);
+            this.attempts.delete(state);
+            jobs.push(attempt.abort().catch(() => undefined));
+        }
+        if (includeCompleted) {
+            for (const [state, attempt] of this.completed) {
                 if (!match(attempt)) {
                     continue;
                 }
                 this.aborted.add(state);
-                this.attempts.delete(state);
-                jobs.push(attempt.abort().catch(() => undefined));
+                this.completed.delete(state);
             }
-            if (includeCompleted) {
-                for (const [state, attempt] of this.completed) {
-                    if (!match(attempt)) {
-                        continue;
-                    }
-                    this.aborted.add(state);
-                    this.completed.delete(state);
-                }
-            }
-            yield Promise.all(jobs);
-        });
+        }
+        await Promise.all(jobs);
     }
     bind(state, sessionId, callId) {
         const live = this.attempts.get(state);
@@ -178,105 +153,93 @@ export class McpOauthOnDemandHub {
         }
         return "unknown";
     }
-    complete(state, code) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.aborted.has(state)) {
-                throw new Error("Unknown OAuth state.");
-            }
-            const pending = this.finishing.get(state);
-            if (pending !== undefined) {
-                return yield pending;
-            }
-            const attempt = this.attempts.get(state);
-            if (attempt === undefined) {
-                throw new Error("Unknown OAuth state.");
-            }
-            const run = this.finishAttempt(state, attempt, code);
-            this.finishing.set(state, run);
-            return yield run;
-        });
+    async complete(state, code) {
+        if (this.aborted.has(state)) {
+            throw new Error("Unknown OAuth state.");
+        }
+        const pending = this.finishing.get(state);
+        if (pending !== undefined) {
+            return await pending;
+        }
+        const attempt = this.attempts.get(state);
+        if (attempt === undefined) {
+            throw new Error("Unknown OAuth state.");
+        }
+        const run = this.finishAttempt(state, attempt, code);
+        this.finishing.set(state, run);
+        return await run;
     }
-    finishAttempt(state, attempt, code) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield attempt.finish(code);
-                this.attempts.delete(state);
-                if (!this.aborted.has(state)) {
-                    this.completed.set(state, attempt);
-                }
-                return {
-                    connection: attempt.connection,
-                    sessionId: attempt.sessionId,
-                    callId: attempt.callId,
-                };
-            }
-            finally {
-                this.finishing.delete(state);
-            }
-        });
+    async finishAttempt(state, attempt, code) {
+        try {
+            await attempt.finish(code);
+            this.attempts.delete(state);
+            if (!this.aborted.has(state)) {
+                this.completed.set(state, attempt);
+            }
+            return {
+                connection: attempt.connection,
+                sessionId: attempt.sessionId,
+                callId: attempt.callId,
+            };
+        }
+        finally {
+            this.finishing.delete(state);
+        }
     }
     fileStore() {
-        var _a;
-        (_a = this.store) !== null && _a !== void 0 ? _a : (this.store = new FileMcpOAuthStore());
+        this.store ??= new FileMcpOAuthStore();
         return this.store;
     }
-    persistFor(connection, resourceUrl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            var _c, _d;
-            const target = (_c = this.secrets) !== null && _c !== void 0 ? _c : resolveHostedMcpOauthSecretsTarget((_d = this.secretsBind) !== null && _d !== void 0 ? _d : {});
-            if (target === undefined) {
-                return;
-            }
-            const store = this.fileStore();
-            const tokens = yield store.loadTokens(connection, resourceUrl);
-            if (tokens === undefined || tokens.access_token.trim() === "") {
-                return;
-            }
-            const client = yield store.loadClientInformation(connection, resourceUrl);
+    async persistFor(connection, resourceUrl) {
+        const target = this.secrets ?? resolveHostedMcpOauthSecretsTarget(this.secretsBind ?? {});
+        if (target === undefined) {
+            return;
+        }
+        const store = this.fileStore();
+        const tokens = await store.loadTokens(connection, resourceUrl);
+        if (tokens === undefined || tokens.access_token.trim() === "") {
+            return;
+        }
+        const client = await store.loadClientInformation(connection, resourceUrl);
+        try {
+            const names = await upsertHostMcpOauthSecrets({
+                connection,
+                tokens,
+                clientId: client?.client_id,
+                target,
+            });
+            this.logger?.(`${LOG_PREFIX} MCP OAuth tokens stored on the deployment (${names.join(", ")}).`);
+        }
+        catch (error) {
+            this.logger?.(`${LOG_PREFIX} MCP OAuth persist failed for "${connection}": ${describeError(error)}`);
+        }
+    }
+    async handleCallback(request) {
+        const url = new URL(request.url);
+        const code = url.searchParams.get("code");
+        const state = url.searchParams.get("state") ?? "";
+        if (this.aborted.has(state)) {
+            return oauthHtml(404, "<h1>Not found</h1>");
+        }
+        if (this.completed.has(state)) {
+            return oauthHtml(200, "<h1>Authorized</h1><p>Return to the agent.</p>");
+        }
+        if (!this.attempts.has(state)) {
+            return oauthHtml(404, "<h1>Not found</h1>");
+        }
+        if (code !== null && code !== "") {
             try {
-                const names = yield upsertHostMcpOauthSecrets({
-                    connection,
-                    tokens,
-                    clientId: client === null || client === void 0 ? void 0 : client.client_id,
-                    target,
-                });
-                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.call(this, `${LOG_PREFIX} MCP OAuth tokens stored on the deployment (${names.join(", ")}).`);
+                await this.complete(state, code);
             }
-            catch (error) {
-                (_b = this.logger) === null || _b === void 0 ? void 0 : _b.call(this, `${LOG_PREFIX} MCP OAuth persist failed for "${connection}": ${describeError(error)}`);
+            catch {
+                return oauthHtml(400, "<h1>Authorization failed</h1>");
             }
-        });
-    }
-    handleCallback(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const url = new URL(request.url);
-            const code = url.searchParams.get("code");
-            const state = (_a = url.searchParams.get("state")) !== null && _a !== void 0 ? _a : "";
             if (this.aborted.has(state)) {
                 return oauthHtml(404, "<h1>Not found</h1>");
             }
-            if (this.completed.has(state)) {
-                return oauthHtml(200, "<h1>Authorized</h1><p>Return to the agent.</p>");
-            }
-            if (!this.attempts.has(state)) {
-                return oauthHtml(404, "<h1>Not found</h1>");
-            }
-            if (code !== null && code !== "") {
-                try {
-                    yield this.complete(state, code);
-                }
-                catch (_b) {
-                    return oauthHtml(400, "<h1>Authorization failed</h1>");
-                }
-                if (this.aborted.has(state)) {
-                    return oauthHtml(404, "<h1>Not found</h1>");
-                }
-                return oauthHtml(200, "<h1>Authorized</h1><p>Return to the agent.</p>");
-            }
-            return oauthHtml(400, "<h1>Authorization failed</h1>");
-        });
+            return oauthHtml(200, "<h1>Authorized</h1><p>Return to the agent.</p>");
+        }
+        return oauthHtml(400, "<h1>Authorization failed</h1>");
     }
 }
 function oauthHtml(status, body) {

package/dist/internal/mcp-oauth-persist.js

@@ -4,46 +4,34 @@
  * provider. Resolve the `--store` client at persist time so v2 freeze
  * bind can drop the key after listen.
  */
-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 { AGENT_SERVE_DEPLOYMENT_ID_ENV_VAR } from "../storage-backends/cursor-hosted.js";
 import { cursorExternalApiUrl, resolveApiKeySync } from "./cursor/credentials.js";
 import { AgentServeDeployClient, parseAgentServeMcpGatewayUrl } from "./deploy-client.js";
 import { mcpOauthSecretNames } from "./mcp-oauth.js";
 function mcpOauthSecretsPayload(args) {
-    var _a, _b;
     const names = mcpOauthSecretNames(args.connection);
     const secrets = [
         { name: names.accessToken, value: args.tokens.access_token },
     ];
-    const refresh = (_a = args.tokens.refresh_token) === null || _a === void 0 ? void 0 : _a.trim();
+    const refresh = args.tokens.refresh_token?.trim();
     if (refresh !== undefined && refresh !== "") {
         secrets.push({ name: names.refreshToken, value: refresh });
     }
-    const clientId = (_b = args.clientId) === null || _b === void 0 ? void 0 : _b.trim();
+    const clientId = args.clientId?.trim();
     if (clientId !== undefined && clientId !== "") {
         secrets.push({ name: names.clientId, value: clientId });
     }
     return secrets;
 }
-export function upsertHostMcpOauthSecrets(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const payload = mcpOauthSecretsPayload(args);
-        if (payload.length === 0) {
-            return [];
-        }
-        return yield args.target.client.setSecrets({
-            teamId: args.target.teamId,
-            slug: args.target.slug,
-            secrets: payload,
-        });
+export async function upsertHostMcpOauthSecrets(args) {
+    const payload = mcpOauthSecretsPayload(args);
+    if (payload.length === 0) {
+        return [];
+    }
+    return await args.target.client.setSecrets({
+        teamId: args.target.teamId,
+        slug: args.target.slug,
+        secrets: payload,
     });
 }
 /**
@@ -52,10 +40,8 @@ export function upsertHostMcpOauthSecrets(args) {
  * Self-hosted / no deployment / unsigned: undefined.
  */
 export function resolveHostedMcpOauthSecretsTarget(args = {}) {
-    var _a;
-    var _b, _c;
-    const env = (_b = args.env) !== null && _b !== void 0 ? _b : process.env;
-    const deploymentId = (_a = env[AGENT_SERVE_DEPLOYMENT_ID_ENV_VAR]) === null || _a === void 0 ? void 0 : _a.trim();
+    const env = args.env ?? process.env;
+    const deploymentId = env[AGENT_SERVE_DEPLOYMENT_ID_ENV_VAR]?.trim();
     if (deploymentId === undefined || deploymentId === "") {
         return undefined;
     }
@@ -64,8 +50,8 @@ export function resolveHostedMcpOauthSecretsTarget(args = {}) {
         return undefined;
     }
     const fromUrl = args.cloudToolsUrl === undefined ? undefined : parseAgentServeMcpGatewayUrl(args.cloudToolsUrl);
-    const slug = args.slug !== undefined && args.slug !== "" ? args.slug : fromUrl === null || fromUrl === void 0 ? void 0 : fromUrl.slug;
-    const teamId = (_c = parseTeamId(args.team)) !== null && _c !== void 0 ? _c : fromUrl === null || fromUrl === void 0 ? void 0 : fromUrl.teamId;
+    const slug = args.slug !== undefined && args.slug !== "" ? args.slug : fromUrl?.slug;
+    const teamId = parseTeamId(args.team) ?? fromUrl?.teamId;
     if (slug === undefined || teamId === undefined) {
         return undefined;
     }