@cursor/july 0.1.16 → 0.1.17

package/src/internal/cli-mcp.ts

@@ -29,6 +29,8 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { resolveDeployAuth } from "./cli-deploy.js";
+import { DeployApiError } from "./deploy-client.js";
 import { CLI_COMMAND_NAME as CLI, LOG_PREFIX } from "./distribution.js";
 import {
   ProdTargetError,
@@ -77,9 +79,16 @@ export interface McpCliOptions {
   print?: boolean;
   /** `install`: machine-readable output. */
   json?: boolean;
+  /**
+   * `install --prod`: write a REMOTE HTTP entry pointing at the stable Cursor
+   * MCP gateway (`<api>/…/mcp/<team>/<slug>`) instead of the local stdio
+   * proxy. For remote-only MCP hosts (Glass) that cannot spawn stdio.
+   */
+  remote?: boolean;
   /** Injected seams for tests. */
   fetchImpl?: typeof fetch;
   resolveProdTargetImpl?: typeof resolveProdTarget;
+  resolveDeployAuthImpl?: typeof resolveDeployAuth;
   stdin?: NodeJS.ReadableStream;
   stdout?: { write(chunk: string): unknown };
   err?: (text: string) => void;
@@ -490,10 +499,9 @@ function requestIdsOf(line: string): Array<string | number> {
 // install: write the entry into ~/.cursor/mcp.json
 // ============================================================================
 
-interface McpJsonEntry {
-  command: string;
-  args: string[];
-}
+type McpJsonEntry =
+  | { command: string; args: string[] }
+  | { url: string; headers?: Record<string, string> };
 
 export async function cmdMcpInstall(options: McpCliOptions): Promise<number> {
   const err = options.err ?? defaultErr;
@@ -502,9 +510,16 @@ export async function cmdMcpInstall(options: McpCliOptions): Promise<number> {
     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;
+    }
+    return cmdMcpInstallRemote(options);
+  }
 
   let name: string;
-  let entry: McpJsonEntry;
+  let entry: { command: string; args: string[] };
   if (options.prod === true) {
     let slug: string;
     try {
@@ -598,6 +613,104 @@ export async function cmdMcpInstall(options: McpCliOptions): Promise<number> {
   return 0;
 }
 
+/**
+ * `mcp install --prod --remote` — write a REMOTE HTTP entry pointing at the
+ * stable Cursor MCP gateway for the hosted deployment, for MCP hosts that
+ * cannot spawn the stdio proxy (Glass / Sand). The gateway mints/refreshes
+ * engineAccess server-side, so the entry never carries a pod hostname or a
+ * short-lived port token — only the durable, stable gateway URL.
+ *
+ * Auth: this headless/CLI entry sends the `agentkit login` API key as a
+ * bearer against the user-API-key gateway surface. That key is written to
+ * `mcp.json` in plain text (flagged below); a signed-in Cursor client
+ * (Glass) can instead use the session gateway surface with no header at all
+ * once first-party session attachment ships (see PR follow-ups).
+ */
+async function cmdMcpInstallRemote(options: McpCliOptions): Promise<number> {
+  const err = options.err ?? defaultErr;
+  const stdout = options.stdout ?? process.stdout;
+
+  let slug: string;
+  try {
+    slug = resolveProdSlug({
+      dir: options.dir,
+      cwd: options.cwd,
+      slug: options.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;
+  }
+
+  // Verify the deployment resolves before writing config that cannot work.
+  // This read is admin-tier, but calling the gateway only needs team
+  // membership — so a 403 means "cannot verify", not "cannot use": warn and
+  // still write the entry rather than locking members out of their own agent.
+  try {
+    await auth.client.getDeployment({ teamId: auth.teamId, slug });
+  } catch (error) {
+    if (error instanceof DeployApiError && error.status === 403) {
+      err(
+        `Could not verify deployment "${slug}" (reading deployments needs team-admin); 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;
+    }
+  }
+
+  const name = resolveServerName(options.name, slug);
+  const url = auth.client.mcpGatewayUrl(auth.teamId, slug);
+  const entry: { url: string; headers?: Record<string, string> } = {
+    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: string = process.env.HOME ?? homedir()