@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/cli-mcp.js

@@ -25,15 +25,6 @@
  * stdout is reserved for the MCP wire in serve mode; all logging goes to
  * stderr.
  */
-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 { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -52,7 +43,7 @@ const ACCESS_EXPIRY_LEEWAY_MS = 5 * 60 * 1000;
  * ~55s, so a healthy turn always responds well inside this; past it the
  * engine is unreachable or hung.
  */
-const REQUEST_TIMEOUT_MS = 120000;
+const REQUEST_TIMEOUT_MS = 120_000;
 /** Attempts per message (initial + retries after refresh/backoff). */
 const FORWARD_ATTEMPTS = 3;
 /**
@@ -62,123 +53,117 @@ const FORWARD_ATTEMPTS = 3;
  * A plain 500 is ambiguous and is surfaced to the client instead.
  */
 const RETRYABLE_STATUSES = new Set([401, 403, 404, 417, 502, 503, 504]);
-export function cmdMcp(subcommand, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const err = (_a = options.err) !== null && _a !== void 0 ? _a : defaultErr;
-        if (subcommand === undefined) {
-            return cmdMcpServe(options);
-        }
-        if (subcommand === "install") {
-            return cmdMcpInstall(options);
-        }
-        if (subcommand === "oauth") {
-            const connection = options.oauthConnection;
-            if (connection === undefined || connection.trim() === "") {
-                err(`Usage: ${CLI} mcp oauth <connection> [--dir .] [--store] [--slug <slug>] [--team <id>]\n` +
-                    `Authorize defineConnection({ url, oauth: true }) (host PKCE).\n` +
-                    `--store upserts MCP_OAUTH_<NAME>_* secrets on the hosted deployment.\n`);
-                return 1;
-            }
-            const { cmdMcpOauth } = yield import("./cli-mcp-oauth.js");
-            return cmdMcpOauth({
-                dir: options.dir,
-                connection,
-                store: options.store,
-                slug: options.slug,
-                team: options.team,
-                apiKey: options.apiKey,
-            });
+export async function cmdMcp(subcommand, options) {
+    const err = options.err ?? defaultErr;
+    if (subcommand === undefined) {
+        return cmdMcpServe(options);
+    }
+    if (subcommand === "install") {
+        return cmdMcpInstall(options);
+    }
+    if (subcommand === "oauth") {
+        const connection = options.oauthConnection;
+        if (connection === undefined || connection.trim() === "") {
+            err(`Usage: ${CLI} mcp oauth <connection> [--dir .] [--store] [--slug <slug>] [--team <id>]\n` +
+                `Authorize defineConnection({ url, oauth: true }) (host PKCE).\n` +
+                `--store upserts MCP_OAUTH_<NAME>_* secrets on the hosted deployment.\n`);
+            return 1;
         }
-        err(`Unknown mcp subcommand "${subcommand}".\n` +
-            `Usage: ${CLI} mcp [install|oauth <connection>] --prod [--slug <slug>] | --url <baseUrl>\n`);
-        return 1;
-    });
+        const { cmdMcpOauth } = await import("./cli-mcp-oauth.js");
+        return cmdMcpOauth({
+            dir: options.dir,
+            connection,
+            store: options.store,
+            slug: options.slug,
+            team: options.team,
+            apiKey: options.apiKey,
+        });
+    }
+    err(`Unknown mcp subcommand "${subcommand}".\n` +
+        `Usage: ${CLI} mcp [install|oauth <connection>] --prod [--slug <slug>] | --url <baseUrl>\n`);
+    return 1;
 }
 // ============================================================================
 // serve mode: stdio ↔ /v1/mcp
 // ============================================================================
-export function cmdMcpServe(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e;
-        const err = (_a = options.err) !== null && _a !== void 0 ? _a : defaultErr;
-        const source = buildTargetSource(options, err);
-        if (typeof source === "string") {
-            err(`${source}\n`);
-            return 1;
-        }
-        // Resolve eagerly: a bad slug / signed-out host / stopped deployment fails
-        // fast in the client's MCP server logs instead of on the first tool call.
-        let initial;
-        try {
-            initial = yield source.get();
-        }
-        catch (error) {
-            err(`${describeError(error)}\n`);
-            return 1;
-        }
-        err(`${LOG_PREFIX} mcp: proxying stdio <-> ${initial.mcpUrl}\n`);
-        const stdin = (_b = options.stdin) !== null && _b !== void 0 ? _b : process.stdin;
-        const stdout = (_c = options.stdout) !== null && _c !== void 0 ? _c : process.stdout;
-        const fetchImpl = (_d = options.fetchImpl) !== null && _d !== void 0 ? _d : fetch;
-        const sleep = (_e = options.sleep) !== null && _e !== void 0 ? _e : defaultSleep;
-        const pending = new Set();
-        const handleLine = (line) => __awaiter(this, void 0, void 0, function* () {
-            const outcome = yield forwardMessage({ source, fetchImpl, sleep, line });
-            if (outcome.kind === "empty") {
+export async function cmdMcpServe(options) {
+    const err = options.err ?? defaultErr;
+    const source = buildTargetSource(options, err);
+    if (typeof source === "string") {
+        err(`${source}\n`);
+        return 1;
+    }
+    // Resolve eagerly: a bad slug / signed-out host / stopped deployment fails
+    // fast in the client's MCP server logs instead of on the first tool call.
+    let initial;
+    try {
+        initial = await source.get();
+    }
+    catch (error) {
+        err(`${describeError(error)}\n`);
+        return 1;
+    }
+    err(`${LOG_PREFIX} mcp: proxying stdio <-> ${initial.mcpUrl}\n`);
+    const stdin = options.stdin ?? process.stdin;
+    const stdout = options.stdout ?? process.stdout;
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const sleep = options.sleep ?? defaultSleep;
+    const pending = new Set();
+    const handleLine = async (line) => {
+        const outcome = await forwardMessage({ source, fetchImpl, sleep, line });
+        if (outcome.kind === "empty") {
+            return;
+        }
+        if (outcome.kind === "json") {
+            writeWireBody(stdout, outcome.body, line, err);
+            return;
+        }
+        emitFailure(stdout, line, outcome.message, err);
+    };
+    await new Promise(done => {
+        let buffer = "";
+        const enqueueLine = (raw) => {
+            const line = raw.trim();
+            if (line === "") {
                 return;
             }
-            if (outcome.kind === "json") {
-                writeWireBody(stdout, outcome.body, line, err);
+            const task = handleLine(line)
+                .catch((error) => {
+                err(`${LOG_PREFIX} mcp: ${describeError(error)}\n`);
+            })
+                .finally(() => {
+                pending.delete(task);
+            });
+            pending.add(task);
+        };
+        const onChunk = (chunk) => {
+            buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+            let newline = buffer.indexOf("\n");
+            while (newline !== -1) {
+                const line = buffer.slice(0, newline);
+                buffer = buffer.slice(newline + 1);
+                newline = buffer.indexOf("\n");
+                enqueueLine(line);
+            }
+        };
+        let finished = false;
+        const finish = () => {
+            if (finished) {
                 return;
             }
-            emitFailure(stdout, line, outcome.message, err);
-        });
-        yield new Promise(done => {
-            let buffer = "";
-            const enqueueLine = (raw) => {
-                const line = raw.trim();
-                if (line === "") {
-                    return;
-                }
-                const task = handleLine(line)
-                    .catch((error) => {
-                    err(`${LOG_PREFIX} mcp: ${describeError(error)}\n`);
-                })
-                    .finally(() => {
-                    pending.delete(task);
-                });
-                pending.add(task);
-            };
-            const onChunk = (chunk) => {
-                buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-                let newline = buffer.indexOf("\n");
-                while (newline !== -1) {
-                    const line = buffer.slice(0, newline);
-                    buffer = buffer.slice(newline + 1);
-                    newline = buffer.indexOf("\n");
-                    enqueueLine(line);
-                }
-            };
-            let finished = false;
-            const finish = () => {
-                if (finished) {
-                    return;
-                }
-                finished = true;
-                enqueueLine(buffer);
-                buffer = "";
-                done();
-            };
-            stdin.on("data", onChunk);
-            stdin.once("end", finish);
-            stdin.once("close", finish);
-            stdin.once("error", finish);
-        });
-        // Drain in-flight turns so piped one-shot usage still sees its replies.
-        yield Promise.allSettled([...pending]);
-        return 0;
+            finished = true;
+            enqueueLine(buffer);
+            buffer = "";
+            done();
+        };
+        stdin.on("data", onChunk);
+        stdin.once("end", finish);
+        stdin.once("close", finish);
+        stdin.once("error", finish);
     });
+    // Drain in-flight turns so piped one-shot usage still sees its replies.
+    await Promise.allSettled([...pending]);
+    return 0;
 }
 /** Returns a usage error string when the target flags are invalid. */
 function buildTargetSource(options, err) {
@@ -210,13 +195,12 @@ function createStaticTargetSource(baseUrl, bearerToken) {
     };
 }
 function createProdTargetSource(options, err) {
-    var _a, _b;
-    const resolveImpl = (_a = options.resolveProdTargetImpl) !== null && _a !== void 0 ? _a : resolveProdTarget;
-    const now = (_b = options.now) !== null && _b !== void 0 ? _b : Date.now;
+    const resolveImpl = options.resolveProdTargetImpl ?? resolveProdTarget;
+    const now = options.now ?? Date.now;
     let cached;
     let inFlight;
-    const resolveFresh = () => __awaiter(this, void 0, void 0, function* () {
-        const prod = yield resolveImpl({
+    const resolveFresh = async () => {
+        const prod = await resolveImpl({
             dir: options.dir,
             cwd: options.cwd,
             slug: options.slug,
@@ -234,7 +218,7 @@ function createProdTargetSource(options, err) {
             target.expiresAtMs = expiresAtMs;
         }
         return target;
-    });
+    };
     return {
         canRefresh: true,
         invalidate() {
@@ -262,68 +246,69 @@ function createProdTargetSource(options, err) {
         },
     };
 }
-function forwardMessage(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { source, fetchImpl, sleep, line } = args;
-        let lastFailure = "request failed";
-        for (let attempt = 0; attempt < FORWARD_ATTEMPTS; attempt++) {
-            if (attempt > 0) {
-                yield sleep(500 * attempt);
-            }
-            let target;
-            try {
-                target = yield source.get();
-            }
-            catch (error) {
-                lastFailure = describeError(error);
-                continue;
-            }
-            let response;
-            try {
-                response = yield fetchImpl(target.mcpUrl, {
-                    method: "POST",
-                    headers: Object.assign(Object.assign({}, target.headers), { "content-type": "application/json", 
-                        // The streamable-HTTP server transport 406s unless the client
-                        // accepts both, even in JSON response mode.
-                        accept: "application/json, text/event-stream" }),
-                    body: line,
-                    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
-                });
-            }
-            catch (error) {
-                source.invalidate();
-                if (isTimeoutError(error)) {
-                    // The turn may have started; retrying could double-send it.
-                    return {
-                        kind: "failed",
-                        message: `no response within ${REQUEST_TIMEOUT_MS / 1000}s (the agent may still be processing; check its sessions)`,
-                    };
-                }
-                lastFailure = `request failed: ${describeError(error)}`;
-                continue;
+async function forwardMessage(args) {
+    const { source, fetchImpl, sleep, line } = args;
+    let lastFailure = "request failed";
+    for (let attempt = 0; attempt < FORWARD_ATTEMPTS; attempt++) {
+        if (attempt > 0) {
+            await sleep(500 * attempt);
+        }
+        let target;
+        try {
+            target = await source.get();
+        }
+        catch (error) {
+            lastFailure = describeError(error);
+            continue;
+        }
+        let response;
+        try {
+            response = await fetchImpl(target.mcpUrl, {
+                method: "POST",
+                headers: {
+                    ...target.headers,
+                    "content-type": "application/json",
+                    // The streamable-HTTP server transport 406s unless the client
+                    // accepts both, even in JSON response mode.
+                    accept: "application/json, text/event-stream",
+                },
+                body: line,
+                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            });
+        }
+        catch (error) {
+            source.invalidate();
+            if (isTimeoutError(error)) {
+                // The turn may have started; retrying could double-send it.
+                return {
+                    kind: "failed",
+                    message: `no response within ${REQUEST_TIMEOUT_MS / 1000}s (the agent may still be processing; check its sessions)`,
+                };
             }
-            if (response.status === 202) {
-                // Notification/response-only message: nothing to relay.
-                yield response.text().catch(() => "");
+            lastFailure = `request failed: ${describeError(error)}`;
+            continue;
+        }
+        if (response.status === 202) {
+            // Notification/response-only message: nothing to relay.
+            await response.text().catch(() => "");
+            return { kind: "empty" };
+        }
+        const text = await response.text().catch(() => "");
+        if (response.ok) {
+            if (text.trim() === "") {
                 return { kind: "empty" };
             }
-            const text = yield response.text().catch(() => "");
-            if (response.ok) {
-                if (text.trim() === "") {
-                    return { kind: "empty" };
-                }
-                return { kind: "json", body: text };
-            }
-            lastFailure = `upstream HTTP ${response.status}${text.trim() === "" ? "" : `: ${truncateForLog(text)}`}`;
-            if (RETRYABLE_STATUSES.has(response.status)) {
-                // Auth/expiry/hibernation shaped: re-mint credentials and retry.
-                source.invalidate();
-                continue;
-            }
-            return { kind: "failed", message: lastFailure };
+            return { kind: "json", body: text };
+        }
+        lastFailure = `upstream HTTP ${response.status}${text.trim() === "" ? "" : `: ${truncateForLog(text)}`}`;
+        if (RETRYABLE_STATUSES.has(response.status)) {
+            // Auth/expiry/hibernation shaped: re-mint credentials and retry.
+            source.invalidate();
+            continue;
         }
         return { kind: "failed", message: lastFailure };
-    });
+    }
+    return { kind: "failed", message: lastFailure };
 }
 /**
  * Relay an upstream JSON body onto the stdio wire. The body is re-serialized
@@ -335,7 +320,7 @@ function writeWireBody(stdout, body, inboundLine, err) {
     try {
         parsed = JSON.parse(body);
     }
-    catch (_a) {
+    catch {
         emitFailure(stdout, inboundLine, `upstream returned a non-JSON payload: ${truncateForLog(body)}`, err);
         return;
     }
@@ -365,7 +350,7 @@ function requestIdsOf(line) {
     try {
         parsed = JSON.parse(line);
     }
-    catch (_a) {
+    catch {
         return [];
     }
     const messages = Array.isArray(parsed) ? parsed : [parsed];
@@ -380,108 +365,105 @@ function requestIdsOf(line) {
     }
     return ids;
 }
-export function cmdMcpInstall(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
-        const err = (_a = options.err) !== null && _a !== void 0 ? _a : defaultErr;
-        const stdout = (_b = options.stdout) !== null && _b !== void 0 ? _b : process.stdout;
-        if (options.prod === true && options.url !== undefined) {
-            err("--prod and --url are mutually exclusive\n");
+export async function cmdMcpInstall(options) {
+    const err = options.err ?? defaultErr;
+    const stdout = options.stdout ?? process.stdout;
+    if (options.prod === true && options.url !== undefined) {
+        err("--prod and --url are mutually exclusive\n");
+        return 1;
+    }
+    if (options.remote === true) {
+        if (options.prod !== true) {
+            err("--remote requires --prod (the hosted deployment MCP gateway)\n");
             return 1;
         }
-        if (options.remote === true) {
-            if (options.prod !== true) {
-                err("--remote requires --prod (the hosted deployment MCP gateway)\n");
-                return 1;
-            }
-            return cmdMcpInstallRemote(options);
-        }
-        let name;
-        let entry;
-        if (options.prod === true) {
-            let slug;
-            try {
-                slug = resolveProdSlug({
-                    dir: options.dir,
-                    cwd: options.cwd,
-                    slug: options.slug,
-                });
-            }
-            catch (error) {
-                err(`${describeError(error)}\n`);
-                return 1;
-            }
-            // Verify the deployment resolves before writing config that cannot work.
-            const resolveImpl = (_c = options.resolveProdTargetImpl) !== null && _c !== void 0 ? _c : resolveProdTarget;
-            try {
-                yield resolveImpl({
-                    dir: options.dir,
-                    cwd: options.cwd,
-                    slug,
-                    team: options.team,
-                    apiKey: options.apiKey,
-                    fetchImpl: options.fetchImpl,
-                    err,
-                });
-            }
-            catch (error) {
-                err(`${describeError(error)}\n`);
-                if (error instanceof ProdTargetError && error.notFound) {
-                    err(`Deploy it first: ${CLI} deploy --slug ${slug}\n`);
-                }
-                return 1;
-            }
-            name = resolveServerName(options.name, slug);
-            const args = ["mcp", "--prod", "--slug", slug];
-            if (options.team !== undefined && options.team !== "") {
-                args.push("--team", options.team);
-            }
-            entry = { command: CLI, args };
-        }
-        else if (options.url !== undefined) {
-            const base = normalizeBaseUrl(options.url);
-            if (typeof base !== "string") {
-                err(`${base.error}\n`);
-                return 1;
-            }
-            const derived = (_d = options.name) !== null && _d !== void 0 ? _d : deriveNameFromUrl(base);
-            if (derived === undefined) {
-                err(`Could not derive a server name from ${base}; pass --name <serverName>.\n`);
-                return 1;
-            }
-            name = resolveServerName(derived, derived);
-            const args = ["mcp", "--url", base];
-            if (options.bearerToken !== undefined && options.bearerToken !== "") {
-                args.push("--bearer-token", options.bearerToken);
-                err("note: --bearer-token is written to mcp.json in plain text; prefer --prod for hosted agents\n");
-            }
-            entry = { command: CLI, args };
+        return cmdMcpInstallRemote(options);
+    }
+    let name;
+    let entry;
+    if (options.prod === true) {
+        let slug;
+        try {
+            slug = resolveProdSlug({
+                dir: options.dir,
+                cwd: options.cwd,
+                slug: options.slug,
+            });
         }
-        else {
-            err(`${CLI} mcp install requires --prod (hosted deployment) or --url <baseUrl>\n`);
+        catch (error) {
+            err(`${describeError(error)}\n`);
             return 1;
         }
-        if (options.print === true) {
-            stdout.write(`${JSON.stringify({ mcpServers: { [name]: entry } }, null, 2)}\n`);
-            return 0;
-        }
-        const path = cursorMcpJsonPath();
+        // Verify the deployment resolves before writing config that cannot work.
+        const resolveImpl = options.resolveProdTargetImpl ?? resolveProdTarget;
         try {
-            yield upsertMcpJsonEntry(path, name, entry);
+            await resolveImpl({
+                dir: options.dir,
+                cwd: options.cwd,
+                slug,
+                team: options.team,
+                apiKey: options.apiKey,
+                fetchImpl: options.fetchImpl,
+                err,
+            });
         }
         catch (error) {
             err(`${describeError(error)}\n`);
+            if (error instanceof ProdTargetError && error.notFound) {
+                err(`Deploy it first: ${CLI} deploy --slug ${slug}\n`);
+            }
             return 1;
         }
-        if (options.json === true) {
-            stdout.write(`${JSON.stringify({ ok: true, path, name, entry })}\n`);
-            return 0;
+        name = resolveServerName(options.name, slug);
+        const args = ["mcp", "--prod", "--slug", slug];
+        if (options.team !== undefined && options.team !== "") {
+            args.push("--team", options.team);
         }
-        stdout.write(`Installed MCP server "${name}" in ${path}\n` +
-            `  ${entry.command} ${entry.args.join(" ")}\n` +
-            "Cursor watches this file; the server appears without a restart.\n");
+        entry = { command: CLI, args };
+    }
+    else if (options.url !== undefined) {
+        const base = normalizeBaseUrl(options.url);
+        if (typeof base !== "string") {
+            err(`${base.error}\n`);
+            return 1;
+        }
+        const derived = options.name ?? deriveNameFromUrl(base);
+        if (derived === undefined) {
+            err(`Could not derive a server name from ${base}; pass --name <serverName>.\n`);
+            return 1;
+        }
+        name = resolveServerName(derived, derived);
+        const args = ["mcp", "--url", base];
+        if (options.bearerToken !== undefined && options.bearerToken !== "") {
+            args.push("--bearer-token", options.bearerToken);
+            err("note: --bearer-token is written to mcp.json in plain text; prefer --prod for hosted agents\n");
+        }
+        entry = { command: CLI, args };
+    }
+    else {
+        err(`${CLI} mcp install requires --prod (hosted deployment) or --url <baseUrl>\n`);
+        return 1;
+    }
+    if (options.print === true) {
+        stdout.write(`${JSON.stringify({ mcpServers: { [name]: entry } }, null, 2)}\n`);
         return 0;
-    });
+    }
+    const path = cursorMcpJsonPath();
+    try {
+        await upsertMcpJsonEntry(path, name, entry);
+    }
+    catch (error) {
+        err(`${describeError(error)}\n`);
+        return 1;
+    }
+    if (options.json === true) {
+        stdout.write(`${JSON.stringify({ ok: true, path, name, entry })}\n`);
+        return 0;
+    }
+    stdout.write(`Installed MCP server "${name}" in ${path}\n` +
+        `  ${entry.command} ${entry.args.join(" ")}\n` +
+        "Cursor watches this file; the server appears without a restart.\n");
+    return 0;
 }
 /**
  * `mcp install --prod --remote` — write a REMOTE HTTP entry pointing at the
@@ -496,135 +478,128 @@ export function cmdMcpInstall(options) {
  * (Glass) can instead use the session gateway surface with no header at all
  * once first-party session attachment ships (see PR follow-ups).
  */
-function cmdMcpInstallRemote(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c;
-        const err = (_a = options.err) !== null && _a !== void 0 ? _a : defaultErr;
-        const stdout = (_b = options.stdout) !== null && _b !== void 0 ? _b : process.stdout;
-        let slug;
-        try {
-            slug = resolveProdSlug({
-                dir: options.dir,
-                cwd: options.cwd,
-                slug: options.slug,
-            });
-        }
-        catch (error) {
-            err(`${describeError(error)}\n`);
-            return 1;
-        }
-        const resolveAuthImpl = (_c = options.resolveDeployAuthImpl) !== null && _c !== void 0 ? _c : resolveDeployAuth;
-        const auth = yield resolveAuthImpl({
-            team: options.team,
-            apiKey: options.apiKey,
-            fetchImpl: options.fetchImpl,
-            err,
+async function cmdMcpInstallRemote(options) {
+    const err = options.err ?? defaultErr;
+    const stdout = options.stdout ?? process.stdout;
+    let slug;
+    try {
+        slug = resolveProdSlug({
+            dir: options.dir,
+            cwd: options.cwd,
+            slug: options.slug,
         });
-        if (typeof auth === "number") {
-            return auth;
-        }
-        try {
-            yield rejectV2ForLegacyCommand({
-                client: auth.client,
-                teamId: auth.teamId,
-                slug,
-            });
+    }
+    catch (error) {
+        err(`${describeError(error)}\n`);
+        return 1;
+    }
+    const resolveAuthImpl = options.resolveDeployAuthImpl ?? resolveDeployAuth;
+    const auth = await resolveAuthImpl({
+        team: options.team,
+        apiKey: options.apiKey,
+        fetchImpl: options.fetchImpl,
+        err,
+    });
+    if (typeof auth === "number") {
+        return auth;
+    }
+    try {
+        await rejectV2ForLegacyCommand({
+            client: auth.client,
+            teamId: auth.teamId,
+            slug,
+        });
+    }
+    catch (error) {
+        err(`${describeError(error)}\n`);
+        return 1;
+    }
+    // Verify the deployment resolves before writing config that cannot work.
+    // A 403 here is team membership or cloud-agent entitlement, not an
+    // admin-tier read. Still write the entry: calling the gateway only
+    // needs the API key.
+    try {
+        await auth.client.getDeployment({ teamId: auth.teamId, slug });
+    }
+    catch (error) {
+        if (error instanceof DeployApiError && error.status === 403) {
+            err(`Could not verify deployment "${slug}" (not authorized for this team); writing the entry anyway.\n`);
         }
-        catch (error) {
+        else {
             err(`${describeError(error)}\n`);
-            return 1;
-        }
-        // Verify the deployment resolves before writing config that cannot work.
-        // A 403 here is team membership or cloud-agent entitlement, not an
-        // admin-tier read. Still write the entry: calling the gateway only
-        // needs the API key.
-        try {
-            yield auth.client.getDeployment({ teamId: auth.teamId, slug });
-        }
-        catch (error) {
-            if (error instanceof DeployApiError && error.status === 403) {
-                err(`Could not verify deployment "${slug}" (not authorized for this team); writing the entry anyway.\n`);
-            }
-            else {
-                err(`${describeError(error)}\n`);
-                if (error instanceof DeployApiError && error.status === 404) {
-                    err(`Deploy it first: ${CLI} deploy --slug ${slug}\n`);
-                }
-                return 1;
+            if (error instanceof DeployApiError && error.status === 404) {
+                err(`Deploy it first: ${CLI} deploy --slug ${slug}\n`);
             }
-        }
-        const name = resolveServerName(options.name, slug);
-        const url = auth.client.mcpGatewayUrl(auth.teamId, slug);
-        const entry = {
-            url,
-            headers: { Authorization: `Bearer ${auth.apiKey}` },
-        };
-        if (options.print === true) {
-            stdout.write(`${JSON.stringify({ mcpServers: { [name]: entry } }, null, 2)}\n`);
-            return 0;
-        }
-        const path = cursorMcpJsonPath();
-        try {
-            yield upsertMcpJsonEntry(path, name, entry);
-        }
-        catch (error) {
-            err(`${describeError(error)}\n`);
             return 1;
         }
-        err("note: the API key is written to mcp.json in plain text; it is a durable " +
-            "credential for a remote MCP host that cannot spawn the stdio proxy.\n");
-        if (options.json === true) {
-            stdout.write(`${JSON.stringify({ ok: true, path, name, entry })}\n`);
-            return 0;
-        }
-        stdout.write(`Installed remote MCP server "${name}" in ${path}\n` +
-            `  ${url}\n` +
-            "Cursor watches this file; the server appears without a restart.\n");
+    }
+    const name = resolveServerName(options.name, slug);
+    const url = auth.client.mcpGatewayUrl(auth.teamId, slug);
+    const entry = {
+        url,
+        headers: { Authorization: `Bearer ${auth.apiKey}` },
+    };
+    if (options.print === true) {
+        stdout.write(`${JSON.stringify({ mcpServers: { [name]: entry } }, null, 2)}\n`);
         return 0;
-    });
+    }
+    const path = cursorMcpJsonPath();
+    try {
+        await upsertMcpJsonEntry(path, name, entry);
+    }
+    catch (error) {
+        err(`${describeError(error)}\n`);
+        return 1;
+    }
+    err("note: the API key is written to mcp.json in plain text; it is a durable " +
+        "credential for a remote MCP host that cannot spawn the stdio proxy.\n");
+    if (options.json === true) {
+        stdout.write(`${JSON.stringify({ ok: true, path, name, entry })}\n`);
+        return 0;
+    }
+    stdout.write(`Installed remote MCP server "${name}" in ${path}\n` +
+        `  ${url}\n` +
+        "Cursor watches this file; the server appears without a restart.\n");
+    return 0;
 }
 /** `~/.cursor/mcp.json` — the user-level Cursor MCP config. */
-export function cursorMcpJsonPath(home) {
-    var _a;
-    if (home === void 0) { home = (_a = process.env.HOME) !== null && _a !== void 0 ? _a : homedir(); }
+export function cursorMcpJsonPath(home = process.env.HOME ?? homedir()) {
     const resolved = home.trim() === "" ? homedir() : home;
     return join(resolved, ".cursor", "mcp.json");
 }
-function upsertMcpJsonEntry(path, name, entry) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let root = {};
-        let raw;
+async function upsertMcpJsonEntry(path, name, entry) {
+    let root = {};
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch {
+        raw = undefined;
+    }
+    if (raw !== undefined && raw.trim() !== "") {
+        let parsed;
         try {
-            raw = yield readFile(path, "utf8");
+            parsed = JSON.parse(raw);
         }
-        catch (_a) {
-            raw = undefined;
+        catch (error) {
+            throw new Error(`${path} is not valid JSON (${describeError(error)}); fix it and re-run.`);
         }
-        if (raw !== undefined && raw.trim() !== "") {
-            let parsed;
-            try {
-                parsed = JSON.parse(raw);
-            }
-            catch (error) {
-                throw new Error(`${path} is not valid JSON (${describeError(error)}); fix it and re-run.`);
-            }
-            if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-                throw new Error(`${path} must contain a JSON object; fix it and re-run.`);
-            }
-            root = parsed;
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error(`${path} must contain a JSON object; fix it and re-run.`);
         }
-        const existing = root.mcpServers;
-        const servers = existing !== null && typeof existing === "object" && !Array.isArray(existing)
-            ? existing
-            : {};
-        servers[name] = entry;
-        root.mcpServers = servers;
-        yield mkdir(dirname(path), { recursive: true });
-        yield writeFile(path, `${JSON.stringify(root, null, 2)}\n`, "utf8");
-    });
+        root = parsed;
+    }
+    const existing = root.mcpServers;
+    const servers = existing !== null && typeof existing === "object" && !Array.isArray(existing)
+        ? existing
+        : {};
+    servers[name] = entry;
+    root.mcpServers = servers;
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(root, null, 2)}\n`, "utf8");
 }
 function resolveServerName(name, fallback) {
-    const trimmed = name === null || name === void 0 ? void 0 : name.trim();
+    const trimmed = name?.trim();
     if (trimmed !== undefined && trimmed !== "") {
         return trimmed;
     }
@@ -657,7 +632,7 @@ function normalizeBaseUrl(raw) {
     try {
         parsed = new URL(raw);
     }
-    catch (_a) {
+    catch {
         return { error: `invalid --url: ${raw}` };
     }
     if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {