@cursor/bdk 0.2.9 → 0.2.11

package/dist/internal/cursor/store-api-client.js

@@ -5,15 +5,6 @@
  * errors, and bounded retries. Availability requires both a compatible
  * transport and a managed store, resolved lazily for each call.
  */
-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 { MEMORY_APPEND_MAX_RECORD_BYTES, memoryAppendResponseSchema, memoryReadResponseSchema, STORE_API_MEMORY_APPEND_CALL, STORE_API_MEMORY_READ_CALL, STORE_API_PATH, STORE_API_PROTOCOL_VERSION, serializedRecordBytes, } from "../store-api-protocol.js";
 import { resolveCursorApiBaseUrl, resolveCursorApiFetch, resolveCursorApiKey, } from "./cursor-api-transport.js";
 import { resolveDeploymentStoreSourceIdSync, resolveStoreProtocolSync, storeProtocolEnablesStoreApi, } from "./hosted-store-secrets.js";
@@ -32,35 +23,34 @@ export class StoreApiCallError extends Error {
  * A 429 whose Retry-After exceeds the cap gives up immediately.
  */
 const STORE_API_MAX_ATTEMPTS = 3;
-const STORE_API_MAX_BACKOFF_MS = 2000;
+const STORE_API_MAX_BACKOFF_MS = 2_000;
 /**
  * Hard deadline per request. Hydration runs at the head of the session
  * dispatch chain, so a stalled connection must not delay every queued
  * handler.
  */
-const STORE_API_FETCH_TIMEOUT_MS = 15000;
+const STORE_API_FETCH_TIMEOUT_MS = 15_000;
 function backoffMs(attempt, random) {
-    return Math.min(200 * Math.pow(2, attempt) * (0.5 + random()), STORE_API_MAX_BACKOFF_MS);
+    return Math.min(200 * 2 ** attempt * (0.5 + random()), STORE_API_MAX_BACKOFF_MS);
 }
 /** True when managed store operations are available. */
 export function isStoreApiLaneEnabled(options = {}) {
-    var _a, _b, _c;
-    var _d, _e, _f;
-    const protocol = (_d = (_a = options.resolveStoreProtocol) === null || _a === void 0 ? void 0 : _a.call(options)) !== null && _d !== void 0 ? _d : resolveStoreProtocolSync();
+    const protocol = options.resolveStoreProtocol?.() ?? resolveStoreProtocolSync();
     if (!storeProtocolEnablesStoreApi(protocol)) {
         return false;
     }
-    const sourceId = (_c = ((_f = (_e = (_b = options.resolveStoreSourceId) === null || _b === void 0 ? void 0 : _b.call(options)) !== null && _e !== void 0 ? _e : options.storeSourceId) !== null && _f !== void 0 ? _f : resolveDeploymentStoreSourceIdSync())) === null || _c === void 0 ? void 0 : _c.trim();
+    const sourceId = (options.resolveStoreSourceId?.() ??
+        options.storeSourceId ??
+        resolveDeploymentStoreSourceIdSync())?.trim();
     return sourceId !== undefined && sourceId !== "";
 }
 export function createStoreApiClient(options = {}) {
-    var _a, _b;
-    const sleep = (_a = options.sleep) !== null && _a !== void 0 ? _a : ((ms) => new Promise(resolve => setTimeout(resolve, ms)));
-    const random = (_b = options.random) !== null && _b !== void 0 ? _b : Math.random;
+    const sleep = options.sleep ?? ((ms) => new Promise(resolve => setTimeout(resolve, ms)));
+    const random = options.random ?? Math.random;
     /** One POST of a versioned envelope; returns the parsed 2xx body. */
-    const postOnce = (call, envelope) => __awaiter(this, void 0, void 0, function* () {
+    const postOnce = async (call, envelope) => {
         const fetchImpl = resolveCursorApiFetch(options);
-        return yield fetchImpl(`${resolveCursorApiBaseUrl(options)}${STORE_API_PATH}/${call}`, {
+        return await fetchImpl(`${resolveCursorApiBaseUrl(options)}${STORE_API_PATH}/${call}`, {
             method: "POST",
             headers: {
                 Authorization: `Bearer ${resolveCursorApiKey(options)}`,
@@ -69,39 +59,38 @@ export function createStoreApiClient(options = {}) {
             body: JSON.stringify(envelope),
             signal: AbortSignal.timeout(STORE_API_FETCH_TIMEOUT_MS),
         });
-    });
+    };
     /** The response's `Retry-After` in ms, when present and numeric. */
     const retryAfterDelayMs = (response) => {
-        var _a;
-        const header = (_a = response.headers.get("retry-after")) === null || _a === void 0 ? void 0 : _a.trim();
+        const header = response.headers.get("retry-after")?.trim();
         const seconds = header === undefined || header === "" ? Number.NaN : Number(header);
-        return Number.isFinite(seconds) ? seconds * 1000 : undefined;
+        return Number.isFinite(seconds) ? seconds * 1_000 : undefined;
     };
-    const describeErrorBody = (response) => __awaiter(this, void 0, void 0, function* () {
+    const describeErrorBody = async (response) => {
         try {
-            const parsed = (yield response.json());
-            if (typeof (parsed === null || parsed === void 0 ? void 0 : parsed.error) === "string") {
+            const parsed = (await response.json());
+            if (typeof parsed?.error === "string") {
                 return parsed.error;
             }
         }
-        catch (_a) {
+        catch {
             // Non-JSON error body; the status is the message.
         }
         return `HTTP ${response.status}`;
-    });
-    const callApi = (call, envelope) => __awaiter(this, void 0, void 0, function* () {
+    };
+    const callApi = async (call, envelope) => {
         let lastFailure;
         // A shed's Retry-After (when within the cap) overrides the next jittered
         // backoff; cleared before every attempt.
         let nextDelayMs;
         for (let attempt = 0; attempt < STORE_API_MAX_ATTEMPTS; attempt += 1) {
             if (attempt > 0) {
-                yield sleep(nextDelayMs !== null && nextDelayMs !== void 0 ? nextDelayMs : backoffMs(attempt, random));
+                await sleep(nextDelayMs ?? backoffMs(attempt, random));
             }
             nextDelayMs = undefined;
             let response;
             try {
-                response = yield postOnce(call, envelope);
+                response = await postOnce(call, envelope);
             }
             catch (error) {
                 lastFailure = new StoreApiCallError("unavailable", `store api ${call} transport failure: ${error instanceof Error ? error.message : String(error)}`);
@@ -109,15 +98,15 @@ export function createStoreApiClient(options = {}) {
             }
             if (response.ok) {
                 try {
-                    return (yield response.json());
+                    return (await response.json());
                 }
-                catch (_a) {
+                catch {
                     throw new StoreApiCallError("bad_response", `store api ${call} answered non-JSON (${response.status})`, response.status);
                 }
             }
             if (response.status === 429) {
                 const retryDelayMs = retryAfterDelayMs(response);
-                const shed = new StoreApiCallError("shed", `store api ${call} shed: ${yield describeErrorBody(response)}`, response.status);
+                const shed = new StoreApiCallError("shed", `store api ${call} shed: ${await describeErrorBody(response)}`, response.status);
                 if (retryDelayMs !== undefined && retryDelayMs > STORE_API_MAX_BACKOFF_MS) {
                     // A long Retry-After is an explicit instruction to stop retrying.
                     throw shed;
@@ -135,70 +124,66 @@ export function createStoreApiClient(options = {}) {
                 if (retryDelayMs !== undefined) {
                     nextDelayMs = Math.min(retryDelayMs, STORE_API_MAX_BACKOFF_MS);
                 }
-                lastFailure = new StoreApiCallError("unavailable", `store api ${call} failed: ${yield describeErrorBody(response)}`, response.status);
+                lastFailure = new StoreApiCallError("unavailable", `store api ${call} failed: ${await describeErrorBody(response)}`, response.status);
                 continue;
             }
             // Any other 4xx is deterministic; retrying re-sends the same refusal.
-            throw new StoreApiCallError("rejected", `store api ${call} rejected: ${yield describeErrorBody(response)}`, response.status);
+            throw new StoreApiCallError("rejected", `store api ${call} rejected: ${await describeErrorBody(response)}`, response.status);
         }
-        throw lastFailure !== null && lastFailure !== void 0 ? lastFailure : new StoreApiCallError("unavailable", "no attempt ran");
-    });
+        throw lastFailure ?? new StoreApiCallError("unavailable", "no attempt ran");
+    };
     return {
-        memoryAppend(payload) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const recordBytes = serializedRecordBytes(payload.record);
-                if (recordBytes > MEMORY_APPEND_MAX_RECORD_BYTES) {
-                    // The server-side controller enforces the same cap; checking here
-                    // spares a doomed request and fails with the same typed shape.
-                    throw new StoreApiCallError("rejected", `memory.append record is ${recordBytes} serialized bytes; the cap is ${MEMORY_APPEND_MAX_RECORD_BYTES}`);
-                }
-                const body = yield callApi(STORE_API_MEMORY_APPEND_CALL, {
-                    v: STORE_API_PROTOCOL_VERSION,
-                    call: STORE_API_MEMORY_APPEND_CALL,
-                    payload,
-                });
-                if (!memoryAppendResponseSchema.safeParse(body).success) {
-                    throw new StoreApiCallError("bad_response", "unexpected memory.append response shape");
-                }
+        async memoryAppend(payload) {
+            const recordBytes = serializedRecordBytes(payload.record);
+            if (recordBytes > MEMORY_APPEND_MAX_RECORD_BYTES) {
+                // The server-side controller enforces the same cap; checking here
+                // spares a doomed request and fails with the same typed shape.
+                throw new StoreApiCallError("rejected", `memory.append record is ${recordBytes} serialized bytes; the cap is ${MEMORY_APPEND_MAX_RECORD_BYTES}`);
+            }
+            const body = await callApi(STORE_API_MEMORY_APPEND_CALL, {
+                v: STORE_API_PROTOCOL_VERSION,
+                call: STORE_API_MEMORY_APPEND_CALL,
+                payload,
             });
+            if (!memoryAppendResponseSchema.safeParse(body).success) {
+                throw new StoreApiCallError("bad_response", "unexpected memory.append response shape");
+            }
         },
-        memoryReadContent(payload) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const body = yield callApi(STORE_API_MEMORY_READ_CALL, {
-                    v: STORE_API_PROTOCOL_VERSION,
-                    call: STORE_API_MEMORY_READ_CALL,
-                    payload,
-                });
-                const parsed = memoryReadResponseSchema.safeParse(body);
-                if (!parsed.success) {
-                    throw new StoreApiCallError("bad_response", "unexpected memory.read response shape");
-                }
-                if (parsed.data.journal === null) {
-                    return undefined;
-                }
-                // Fetch bulk bytes from the authorized URL. This read is not retried;
-                // the whole operation runs again at the next session start.
-                const fetchImpl = resolveCursorApiFetch(options);
-                let response;
-                try {
-                    response = yield fetchImpl(parsed.data.journal.url, {
-                        method: "GET",
-                        redirect: "manual",
-                        signal: AbortSignal.timeout(STORE_API_FETCH_TIMEOUT_MS),
-                    });
-                }
-                catch (error) {
-                    throw new StoreApiCallError("unavailable", `memory.read journal fetch transport failure: ${error instanceof Error ? error.message : String(error)}`);
-                }
-                if (response.status === 404) {
-                    // The snapshot raced a rotation or delete; absent is absent.
-                    return undefined;
-                }
-                if (!response.ok) {
-                    throw new StoreApiCallError("unavailable", `memory.read journal fetch failed (HTTP ${response.status})`, response.status);
-                }
-                return new Uint8Array(yield response.arrayBuffer());
+        async memoryReadContent(payload) {
+            const body = await callApi(STORE_API_MEMORY_READ_CALL, {
+                v: STORE_API_PROTOCOL_VERSION,
+                call: STORE_API_MEMORY_READ_CALL,
+                payload,
             });
+            const parsed = memoryReadResponseSchema.safeParse(body);
+            if (!parsed.success) {
+                throw new StoreApiCallError("bad_response", "unexpected memory.read response shape");
+            }
+            if (parsed.data.journal === null) {
+                return undefined;
+            }
+            // Fetch bulk bytes from the authorized URL. This read is not retried;
+            // the whole operation runs again at the next session start.
+            const fetchImpl = resolveCursorApiFetch(options);
+            let response;
+            try {
+                response = await fetchImpl(parsed.data.journal.url, {
+                    method: "GET",
+                    redirect: "manual",
+                    signal: AbortSignal.timeout(STORE_API_FETCH_TIMEOUT_MS),
+                });
+            }
+            catch (error) {
+                throw new StoreApiCallError("unavailable", `memory.read journal fetch transport failure: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (response.status === 404) {
+                // The snapshot raced a rotation or delete; absent is absent.
+                return undefined;
+            }
+            if (!response.ok) {
+                throw new StoreApiCallError("unavailable", `memory.read journal fetch failed (HTTP ${response.status})`, response.status);
+            }
+            return new Uint8Array(await response.arrayBuffer());
         },
     };
 }

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

@@ -12,19 +12,10 @@
  * account. Used by `agent-sdk mcp oauth <connection>` and the post-deploy
  * hook in `cli-deploy.ts`.
  */
-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 { LOG_PREFIX } from "./distribution.js";
 import { openBrowser } from "./mcp-oauth.js";
 import { sleep as defaultSleep } from "./sleep.js";
-const DEFAULT_POLL_INTERVAL_MS = 3000;
+const DEFAULT_POLL_INTERVAL_MS = 3_000;
 const DEFAULT_POLL_TIMEOUT_MS = 5 * 60 * 1000;
 /** Same default the dashboard uses; MCP_OAUTH_REDIRECT_URI overrides for dev. */
 export function mcpOauthRedirectUri() {
@@ -39,83 +30,80 @@ export function mcpOauthRedirectUri() {
  * Already-authorized connectors are skipped; the rest get a browser OAuth
  * each (sequentially), polled until the backend stores the token.
  */
-export function authorizeCursorAccountConnectors(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f;
-        const { backendClient, teamId, serviceAccountId, connectionName, out, err } = args;
-        const open = (_a = args.openBrowserImpl) !== null && _a !== void 0 ? _a : openBrowser;
-        const sleep = (_b = args.sleep) !== null && _b !== void 0 ? _b : defaultSleep;
-        const pollIntervalMs = (_c = args.pollIntervalMs) !== null && _c !== void 0 ? _c : DEFAULT_POLL_INTERVAL_MS;
-        const pollTimeoutMs = (_d = args.pollTimeoutMs) !== null && _d !== void 0 ? _d : DEFAULT_POLL_TIMEOUT_MS;
-        const redirectUri = mcpOauthRedirectUri();
-        // Team-scoped connectors only: the hosted bridge resolves the SA's team
-        // servers, so personal connectors can never apply to a deployment.
-        const available = (yield backendClient.getAvailableMcpServers({ teamId })).filter(server => server.isTeamServer);
-        const selected = selectConnectors(available, args.servers);
-        for (const missing of selected.unmatched) {
-            err(`${LOG_PREFIX} Connection "${connectionName}" lists connector ${JSON.stringify(missing)}, but the team has no such connector (dashboard → MCP).\n`);
+export async function authorizeCursorAccountConnectors(args) {
+    const { backendClient, teamId, serviceAccountId, connectionName, out, err } = args;
+    const open = args.openBrowserImpl ?? openBrowser;
+    const sleep = args.sleep ?? defaultSleep;
+    const pollIntervalMs = args.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const pollTimeoutMs = args.pollTimeoutMs ?? DEFAULT_POLL_TIMEOUT_MS;
+    const redirectUri = mcpOauthRedirectUri();
+    // Team-scoped connectors only: the hosted bridge resolves the SA's team
+    // servers, so personal connectors can never apply to a deployment.
+    const available = (await backendClient.getAvailableMcpServers({ teamId })).filter(server => server.isTeamServer);
+    const selected = selectConnectors(available, args.servers);
+    for (const missing of selected.unmatched) {
+        err(`${LOG_PREFIX} Connection "${connectionName}" lists connector ${JSON.stringify(missing)}, but the team has no such connector (dashboard → MCP).\n`);
+    }
+    if (selected.servers.length === 0) {
+        err(`${LOG_PREFIX} No matching team connectors for connection "${connectionName}".\n`);
+        return { authorized: [], pending: [], errored: [] };
+    }
+    const nameById = new Map(selected.servers.map(server => [server.id, server.name]));
+    const statuses = await backendClient.checkHttpMcpStatus({
+        serverIds: selected.servers.map(server => server.id),
+        oauthRedirectUri: redirectUri,
+        serviceAccountId,
+    });
+    const result = {
+        authorized: [],
+        pending: [],
+        errored: [],
+    };
+    for (const status of statuses) {
+        const name = nameById.get(status.id) ?? `#${status.id}`;
+        if (!status.requiresAuth) {
+            if (status.error !== undefined && status.error !== "") {
+                err(`${LOG_PREFIX} ${name}: ${status.error}\n`);
+                result.errored.push({ name, error: status.error });
+                continue;
+            }
+            out(`${LOG_PREFIX} ${name}: already authorized ✓\n`);
+            result.authorized.push(name);
+            continue;
+        }
+        if (status.authUrl === undefined || status.authUrl === "") {
+            const error = status.error ?? "no authorization URL was minted";
+            err(`${LOG_PREFIX} ${name}: ${error}\n`);
+            result.errored.push({ name, error });
+            continue;
         }
-        if (selected.servers.length === 0) {
-            err(`${LOG_PREFIX} No matching team connectors for connection "${connectionName}".\n`);
-            return { authorized: [], pending: [], errored: [] };
+        if (!args.interactive) {
+            result.pending.push(name);
+            continue;
         }
-        const nameById = new Map(selected.servers.map(server => [server.id, server.name]));
-        const statuses = yield backendClient.checkHttpMcpStatus({
-            serverIds: selected.servers.map(server => server.id),
-            oauthRedirectUri: redirectUri,
+        out(`${LOG_PREFIX} ${name}: authorization needed. You'll authorize ${name} as yourself; ` +
+            `anyone who can talk to this agent can act with that access.\n` +
+            `${LOG_PREFIX} Opening (or open manually):\n  ${status.authUrl}\n`);
+        open(status.authUrl);
+        const authorized = await pollUntilAuthorized({
+            backendClient,
+            serverId: status.id,
             serviceAccountId,
+            redirectUri,
+            sleep,
+            pollIntervalMs,
+            pollTimeoutMs,
         });
-        const result = {
-            authorized: [],
-            pending: [],
-            errored: [],
-        };
-        for (const status of statuses) {
-            const name = (_e = nameById.get(status.id)) !== null && _e !== void 0 ? _e : `#${status.id}`;
-            if (!status.requiresAuth) {
-                if (status.error !== undefined && status.error !== "") {
-                    err(`${LOG_PREFIX} ${name}: ${status.error}\n`);
-                    result.errored.push({ name, error: status.error });
-                    continue;
-                }
-                out(`${LOG_PREFIX} ${name}: already authorized ✓\n`);
-                result.authorized.push(name);
-                continue;
-            }
-            if (status.authUrl === undefined || status.authUrl === "") {
-                const error = (_f = status.error) !== null && _f !== void 0 ? _f : "no authorization URL was minted";
-                err(`${LOG_PREFIX} ${name}: ${error}\n`);
-                result.errored.push({ name, error });
-                continue;
-            }
-            if (!args.interactive) {
-                result.pending.push(name);
-                continue;
-            }
-            out(`${LOG_PREFIX} ${name}: authorization needed. You'll authorize ${name} as yourself; ` +
-                `anyone who can talk to this agent can act with that access.\n` +
-                `${LOG_PREFIX} Opening (or open manually):\n  ${status.authUrl}\n`);
-            open(status.authUrl);
-            const authorized = yield pollUntilAuthorized({
-                backendClient,
-                serverId: status.id,
-                serviceAccountId,
-                redirectUri,
-                sleep,
-                pollIntervalMs,
-                pollTimeoutMs,
-            });
-            if (authorized) {
-                out(`${LOG_PREFIX} ${name}: authorized ✓\n`);
-                result.authorized.push(name);
-            }
-            else {
-                err(`${LOG_PREFIX} ${name}: still waiting on authorization; giving up for now.\n`);
-                result.pending.push(name);
-            }
+        if (authorized) {
+            out(`${LOG_PREFIX} ${name}: authorized ✓\n`);
+            result.authorized.push(name);
         }
-        return result;
-    });
+        else {
+            err(`${LOG_PREFIX} ${name}: still waiting on authorization; giving up for now.\n`);
+            result.pending.push(name);
+        }
+    }
+    return result;
 }
 function selectConnectors(available, filter) {
     if (filter === undefined || filter.length === 0) {
@@ -126,7 +114,7 @@ function selectConnectors(available, filter) {
     const unmatched = [];
     for (const name of filter) {
         const wanted = name.trim().toLowerCase();
-        const matches = available.filter(server => { var _a; return server.name.toLowerCase() === wanted || ((_a = server.serverIdentifier) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === wanted; });
+        const matches = available.filter(server => server.name.toLowerCase() === wanted || server.serverIdentifier?.toLowerCase() === wanted);
         if (matches.length === 0) {
             unmatched.push(name);
             continue;
@@ -145,7 +133,7 @@ function uniqueConnectorMatch(available, identifier) {
     if (wanted === "") {
         return undefined;
     }
-    const byIdentifier = available.filter(server => { var _a; return ((_a = server.serverIdentifier) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === wanted; });
+    const byIdentifier = available.filter(server => server.serverIdentifier?.toLowerCase() === wanted);
     if (byIdentifier.length === 1) {
         return byIdentifier[0];
     }
@@ -164,78 +152,73 @@ function uniqueConnectorMatch(available, identifier) {
  * (local `serve` preflight). Failures return an empty map so the caller
  * can fall back to the dashboard URL.
  */
-export function probeConnectorAuthUrls(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const urls = new Map();
-        if (args.identifiers.length === 0) {
+export async function probeConnectorAuthUrls(args) {
+    const urls = new Map();
+    if (args.identifiers.length === 0) {
+        return urls;
+    }
+    try {
+        const available = await args.client.getAvailableMcpServers();
+        const matched = [];
+        const seen = new Set();
+        for (const identifier of args.identifiers) {
+            const match = uniqueConnectorMatch(available, identifier);
+            if (match === undefined || seen.has(match.id)) {
+                continue;
+            }
+            seen.add(match.id);
+            matched.push(match);
+        }
+        if (matched.length === 0) {
             return urls;
         }
-        try {
-            const available = yield args.client.getAvailableMcpServers();
-            const matched = [];
-            const seen = new Set();
-            for (const identifier of args.identifiers) {
-                const match = uniqueConnectorMatch(available, identifier);
-                if (match === undefined || seen.has(match.id)) {
-                    continue;
-                }
-                seen.add(match.id);
-                matched.push(match);
+        const statuses = await args.client.checkHttpMcpStatus({
+            serverIds: matched.map(server => server.id),
+            oauthRedirectUri: mcpOauthRedirectUri(),
+            serviceAccountId: args.serviceAccountId,
+        });
+        const statusById = new Map(statuses.map(status => [status.id, status]));
+        for (const identifier of args.identifiers) {
+            const match = uniqueConnectorMatch(available, identifier);
+            if (match === undefined) {
+                continue;
             }
-            if (matched.length === 0) {
-                return urls;
+            const authUrl = statusById.get(match.id)?.authUrl?.trim();
+            if (authUrl !== undefined && authUrl !== "") {
+                urls.set(identifier, authUrl);
             }
-            const statuses = yield args.client.checkHttpMcpStatus({
-                serverIds: matched.map(server => server.id),
-                oauthRedirectUri: mcpOauthRedirectUri(),
+        }
+        return urls;
+    }
+    catch {
+        return urls;
+    }
+}
+async function pollUntilAuthorized(args) {
+    const deadline = Date.now() + args.pollTimeoutMs;
+    // Each unauthorized probe is a full backend connect to the provider, so
+    // back off while the human works through the OAuth pages.
+    let intervalMs = args.pollIntervalMs;
+    const maxIntervalMs = Math.max(args.pollIntervalMs, 15_000);
+    while (Date.now() < deadline) {
+        await args.sleep(intervalMs);
+        intervalMs = Math.min(intervalMs * 1.5, maxIntervalMs);
+        let statuses;
+        try {
+            statuses = await args.backendClient.checkHttpMcpStatus({
+                serverIds: [args.serverId],
+                oauthRedirectUri: args.redirectUri,
                 serviceAccountId: args.serviceAccountId,
             });
-            const statusById = new Map(statuses.map(status => [status.id, status]));
-            for (const identifier of args.identifiers) {
-                const match = uniqueConnectorMatch(available, identifier);
-                if (match === undefined) {
-                    continue;
-                }
-                const authUrl = (_b = (_a = statusById.get(match.id)) === null || _a === void 0 ? void 0 : _a.authUrl) === null || _b === void 0 ? void 0 : _b.trim();
-                if (authUrl !== undefined && authUrl !== "") {
-                    urls.set(identifier, authUrl);
-                }
-            }
-            return urls;
         }
-        catch (_c) {
-            return urls;
+        catch {
+            // Transient probe errors; keep polling until the deadline.
+            continue;
         }
-    });
-}
-function pollUntilAuthorized(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const deadline = Date.now() + args.pollTimeoutMs;
-        // Each unauthorized probe is a full backend connect to the provider, so
-        // back off while the human works through the OAuth pages.
-        let intervalMs = args.pollIntervalMs;
-        const maxIntervalMs = Math.max(args.pollIntervalMs, 15000);
-        while (Date.now() < deadline) {
-            yield args.sleep(intervalMs);
-            intervalMs = Math.min(intervalMs * 1.5, maxIntervalMs);
-            let statuses;
-            try {
-                statuses = yield args.backendClient.checkHttpMcpStatus({
-                    serverIds: [args.serverId],
-                    oauthRedirectUri: args.redirectUri,
-                    serviceAccountId: args.serviceAccountId,
-                });
-            }
-            catch (_a) {
-                // Transient probe errors; keep polling until the deadline.
-                continue;
-            }
-            const status = statuses.find(entry => entry.id === args.serverId);
-            if (status !== undefined && !status.requiresAuth) {
-                return true;
-            }
+        const status = statuses.find(entry => entry.id === args.serverId);
+        if (status !== undefined && !status.requiresAuth) {
+            return true;
         }
-        return false;
-    });
+    }
+    return false;
 }

package/dist/internal/cursor-agent-template.js

@@ -29,7 +29,7 @@ export function readCursorAgentTemplate(rootDir) {
         const stamp = pkg.cursorAgentTemplate;
         return typeof stamp === "string" ? stamp : undefined;
     }
-    catch (_a) {
+    catch {
         return undefined;
     }
 }