@cursor/july 0.1.20 → 0.1.21

package/src/internal/cli-mcp.test.ts

@@ -0,0 +1,789 @@
+/**
+ * `agentkit mcp` — the stdio ↔ streamable-HTTP proxy and the
+ * `mcp install` config writer.
+ *
+ * Serve-mode tests drive the real wire path: raw newline-delimited JSON-RPC
+ * into the proxy, which POSTs to a real `startServer` MCP endpoint (mock
+ * runner) or a stub engine (prod credential refresh).
+ */
+
+import { once } from "node:events";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { createServer, type Server } from "node:http";
+import type { AddressInfo } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { PassThrough } from "node:stream";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { httpChannel } from "../channels.js";
+import type {
+  AgentProject,
+  AgentServeHandle,
+  RunnerTurnRequest,
+} from "../types.js";
+import type { resolveDeployAuth } from "./cli-deploy.js";
+import {
+  cmdMcp,
+  cmdMcpInstall,
+  cmdMcpServe,
+  cursorMcpJsonPath,
+  joinMcpPath,
+} from "./cli-mcp.js";
+import { AgentServeDeployClient } from "./deploy-client.js";
+import type { resolveProdTarget } from "./resolve-prod-target.js";
+import type { AgentRunner } from "./sdk-runner.js";
+import { startServer } from "./server.js";
+
+type ResolveProdTargetImpl = typeof resolveProdTarget;
+
+function makeProject(name: string): AgentProject {
+  return {
+    rootDir: `/tmp/mcp-cli-fixture-${name}`,
+    agentDir: `/tmp/mcp-cli-fixture-${name}/agent`,
+    name,
+    agent: {
+      name,
+      description: `The ${name} fixture agent.`,
+      runtime: "local",
+      tools: [],
+      skills: [],
+      connections: [],
+      subagents: [],
+      seedFiles: [],
+    },
+    httpChannel: httpChannel(),
+    channels: [],
+    schedules: [],
+    hooks: [],
+    abs: [],
+    diagnostics: [],
+  };
+}
+
+interface WireCapture {
+  sink: { write(chunk: string): unknown };
+  next: () => Promise<string>;
+  drained: () => string[];
+}
+
+function createWireCapture(): WireCapture {
+  const lines: string[] = [];
+  const waiters: Array<(line: string) => void> = [];
+  let buffer = "";
+  return {
+    sink: {
+      write(chunk: string): boolean {
+        buffer += chunk;
+        let index = buffer.indexOf("\n");
+        while (index !== -1) {
+          const line = buffer.slice(0, index);
+          buffer = buffer.slice(index + 1);
+          index = buffer.indexOf("\n");
+          const waiter = waiters.shift();
+          if (waiter !== undefined) {
+            waiter(line);
+          } else {
+            lines.push(line);
+          }
+        }
+        return true;
+      },
+    },
+    next: () => {
+      const line = lines.shift();
+      if (line !== undefined) {
+        return Promise.resolve(line);
+      }
+      return new Promise<string>((resolve, reject) => {
+        const timer = setTimeout(() => {
+          reject(new Error("timed out waiting for a wire line"));
+        }, 15_000);
+        waiters.push((value) => {
+          clearTimeout(timer);
+          resolve(value);
+        });
+      });
+    },
+    drained: () => [...lines],
+  };
+}
+
+interface ProxySession {
+  send: (message: Record<string, unknown>) => void;
+  next: () => Promise<Record<string, unknown>>;
+  stdoutLines: () => string[];
+  stderrText: () => string;
+  finish: () => Promise<number>;
+}
+
+function startProxySession(
+  options: Omit<Parameters<typeof cmdMcpServe>[0], "stdin" | "stdout" | "err">
+): ProxySession {
+  const stdin = new PassThrough();
+  const capture = createWireCapture();
+  const stderr: string[] = [];
+  const exit = cmdMcpServe({
+    ...options,
+    stdin,
+    stdout: capture.sink,
+    err: (text) => {
+      stderr.push(text);
+    },
+  });
+  return {
+    send: (message) => {
+      stdin.write(`${JSON.stringify(message)}\n`);
+    },
+    next: async () =>
+      JSON.parse(await capture.next()) as Record<string, unknown>,
+    stdoutLines: () => capture.drained(),
+    stderrText: () => stderr.join(""),
+    finish: async () => {
+      stdin.end();
+      return exit;
+    },
+  };
+}
+
+const INITIALIZE = {
+  jsonrpc: "2.0",
+  id: 0,
+  method: "initialize",
+  params: {
+    protocolVersion: "2025-06-18",
+    capabilities: {},
+    clientInfo: { name: "cli-mcp-test", version: "0.0.0" },
+  },
+};
+
+describe("joinMcpPath", () => {
+  it("appends /v1/mcp to an agent base URL, idempotently", () => {
+    expect(joinMcpPath("http://127.0.0.1:3000/weather")).toBe(
+      "http://127.0.0.1:3000/weather/v1/mcp"
+    );
+    expect(joinMcpPath("http://127.0.0.1:3000/weather/")).toBe(
+      "http://127.0.0.1:3000/weather/v1/mcp"
+    );
+    expect(joinMcpPath("http://127.0.0.1:3000/weather/v1/mcp")).toBe(
+      "http://127.0.0.1:3000/weather/v1/mcp"
+    );
+    expect(joinMcpPath("http://127.0.0.1:3000/weather?token=abc")).toBe(
+      "http://127.0.0.1:3000/weather/v1/mcp?token=abc"
+    );
+  });
+});
+
+describe("cmdMcpServe stdin framing", () => {
+  it("processes a final message when stdin ends without a trailing newline", async () => {
+    const stdin = new PassThrough();
+    const capture = createWireCapture();
+    const fetchImpl = vi.fn(async () =>
+      Response.json({ jsonrpc: "2.0", id: 3, result: { tools: [] } })
+    );
+    const exit = cmdMcpServe({
+      dir: ".",
+      url: "http://127.0.0.1:3000/helper",
+      stdin,
+      stdout: capture.sink,
+      fetchImpl,
+      sleep: async () => {},
+    });
+    stdin.write(
+      JSON.stringify({ jsonrpc: "2.0", id: 3, method: "tools/list" })
+    );
+    stdin.end();
+    expect(await exit).toBe(0);
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+    expect(fetchImpl).toHaveBeenCalledWith(
+      "http://127.0.0.1:3000/helper/v1/mcp",
+      expect.anything()
+    );
+    const response = JSON.parse(await capture.next()) as Record<
+      string,
+      unknown
+    >;
+    expect(response.id).toBe(3);
+  });
+});
+
+describe("cmdMcpServe --url against a served agent", () => {
+  let handle: AgentServeHandle | undefined;
+  let stateRoot: string | undefined;
+
+  afterEach(async () => {
+    await handle?.close();
+    handle = undefined;
+    if (stateRoot !== undefined) {
+      await rm(stateRoot, { recursive: true, force: true });
+      stateRoot = undefined;
+    }
+  });
+
+  it("proxies initialize, notifications, tools/list, and ask end-to-end", async () => {
+    stateRoot = await mkdtemp(join(tmpdir(), "agentkit-mcp-cli-"));
+    const runner: AgentRunner = {
+      async runTurn(request: RunnerTurnRequest) {
+        void request;
+        return { status: "finished", result: "the answer is 4" };
+      },
+    };
+    handle = await startServer(
+      [{ slug: "helper", project: makeProject("helper") }],
+      { port: 0, stateRoot, runner, playground: false, docs: false }
+    );
+
+    const session = startProxySession({
+      dir: ".",
+      url: `${handle.url}/helper`,
+    });
+
+    session.send(INITIALIZE);
+    const initResponse = await session.next();
+    expect(initResponse.id).toBe(0);
+    expect(initResponse).toHaveProperty("result.serverInfo.name", "helper");
+
+    // Notifications relay upstream (202) and produce no wire output.
+    session.send({ jsonrpc: "2.0", method: "notifications/initialized" });
+
+    session.send({ jsonrpc: "2.0", id: 1, method: "tools/list" });
+    const toolsResponse = await session.next();
+    expect(toolsResponse.id).toBe(1);
+    const tools = (
+      toolsResponse.result as { tools: Array<{ name: string }> }
+    ).tools.map((tool) => tool.name);
+    expect(tools).toContain("ask");
+    expect(tools).toContain("check");
+
+    session.send({
+      jsonrpc: "2.0",
+      id: 2,
+      method: "tools/call",
+      params: { name: "ask", arguments: { message: "What is 2+2?" } },
+    });
+    const askResponse = await session.next();
+    expect(askResponse.id).toBe(2);
+    const content = (askResponse.result as { content: Array<{ text: string }> })
+      .content;
+    const payload = JSON.parse(content[0]?.text ?? "{}") as {
+      status: string;
+      reply?: string;
+    };
+    expect(payload.status).toBe("completed");
+    expect(payload.reply).toBe("the answer is 4");
+
+    expect(await session.finish()).toBe(0);
+    expect(session.stdoutLines()).toEqual([]);
+    expect(session.stderrText()).toContain("proxying stdio <->");
+  }, 30_000);
+});
+
+interface StubMcpEngine {
+  url: string;
+  close: () => Promise<void>;
+  seenTokens: string[];
+  respondFor: (token: string) => void;
+}
+
+/**
+ * Engine stub that 401s unless the request carries the currently accepted
+ * port token, echoing a canned JSON-RPC response otherwise.
+ */
+async function startStubMcpEngine(): Promise<StubMcpEngine> {
+  const seenTokens: string[] = [];
+  let acceptedToken = "";
+  const server: Server = createServer((req, res) => {
+    let raw = "";
+    req.on("data", (chunk: Buffer) => {
+      raw += chunk.toString("utf8");
+    });
+    req.on("end", () => {
+      const token = String(req.headers["x-anyrun-port-token"] ?? "");
+      seenTokens.push(token);
+      if (token !== acceptedToken) {
+        res.writeHead(401, { "content-type": "application/json" });
+        res.end(JSON.stringify({ error: "expired engine access" }));
+        return;
+      }
+      const inbound = JSON.parse(raw) as { id?: unknown };
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          id: inbound.id ?? null,
+          result: { ok: true, token },
+        })
+      );
+    });
+  });
+  server.listen(0, "127.0.0.1");
+  await once(server, "listening");
+  const { port } = server.address() as AddressInfo;
+  return {
+    url: `http://127.0.0.1:${port}`,
+    seenTokens,
+    respondFor: (token) => {
+      acceptedToken = token;
+    },
+    close: () =>
+      new Promise<void>((resolvePromise, reject) =>
+        server.close((error) => (error ? reject(error) : resolvePromise()))
+      ),
+  };
+}
+
+describe("cmdMcpServe --prod credential lifecycle", () => {
+  let engine: StubMcpEngine | undefined;
+
+  afterEach(async () => {
+    await engine?.close();
+    engine = undefined;
+  });
+
+  it("re-mints engineAccess on 401 and retries the message", async () => {
+    engine = await startStubMcpEngine();
+    engine.respondFor("token-2");
+
+    let minted = 0;
+    const resolveImpl = vi.fn(async () => {
+      minted += 1;
+      return {
+        agentUrl: engine!.url,
+        headers: { "x-anyrun-port-token": `token-${minted}` },
+        slug: "weather",
+        expiresAt: "2099-01-01T00:00:00.000Z",
+      };
+    }) satisfies ResolveProdTargetImpl;
+
+    const session = startProxySession({
+      dir: ".",
+      prod: true,
+      slug: "weather",
+      resolveProdTargetImpl: resolveImpl,
+      sleep: async () => {},
+    });
+
+    session.send({ jsonrpc: "2.0", id: 5, method: "tools/list" });
+    const response = await session.next();
+    expect(response.id).toBe(5);
+    expect(response).toHaveProperty("result.token", "token-2");
+    // token-1 was rejected (401), invalidated, token-2 accepted.
+    expect(engine.seenTokens).toEqual(["token-1", "token-2"]);
+    expect(resolveImpl).toHaveBeenCalledTimes(2);
+
+    expect(await session.finish()).toBe(0);
+  });
+
+  it("proactively re-resolves near expiresAt", async () => {
+    engine = await startStubMcpEngine();
+    engine.respondFor("token-1");
+
+    let nowMs = Date.parse("2026-07-21T00:00:00.000Z");
+    const expiresAt = new Date(nowMs + 10 * 60 * 1000).toISOString();
+    let minted = 0;
+    const resolveImpl = vi.fn(async () => {
+      minted += 1;
+      if (minted === 2) {
+        engine!.respondFor("token-2");
+      }
+      return {
+        agentUrl: engine!.url,
+        headers: { "x-anyrun-port-token": `token-${minted}` },
+        slug: "weather",
+        expiresAt,
+      };
+    }) satisfies ResolveProdTargetImpl;
+
+    const session = startProxySession({
+      dir: ".",
+      prod: true,
+      slug: "weather",
+      resolveProdTargetImpl: resolveImpl,
+      now: () => nowMs,
+      sleep: async () => {},
+    });
+
+    session.send({ jsonrpc: "2.0", id: 1, method: "tools/list" });
+    expect((await session.next()).id).toBe(1);
+    expect(resolveImpl).toHaveBeenCalledTimes(1);
+
+    // Within the 5-minute leeway of expiry: the next message re-resolves.
+    nowMs += 6 * 60 * 1000;
+    session.send({ jsonrpc: "2.0", id: 2, method: "tools/list" });
+    const second = await session.next();
+    expect(second.id).toBe(2);
+    expect(second).toHaveProperty("result.token", "token-2");
+    expect(resolveImpl).toHaveBeenCalledTimes(2);
+
+    expect(await session.finish()).toBe(0);
+  });
+});
+
+describe("cmdMcpServe failure shaping", () => {
+  it("answers requests with a JSON-RPC error when the target is unreachable", async () => {
+    const session = startProxySession({
+      dir: ".",
+      // Port 9 (discard) refuses connections on loopback.
+      url: "http://127.0.0.1:9/helper",
+      sleep: async () => {},
+    });
+
+    session.send({ jsonrpc: "2.0", id: 7, method: "tools/list" });
+    const response = await session.next();
+    expect(response.id).toBe(7);
+    expect(response).toHaveProperty("error.code", -32000);
+    expect(String((response.error as { message: string }).message)).toContain(
+      "request failed"
+    );
+
+    // Notification failures log to stderr but never emit wire output.
+    session.send({ jsonrpc: "2.0", method: "notifications/initialized" });
+    expect(await session.finish()).toBe(0);
+    expect(session.stdoutLines()).toEqual([]);
+    expect(session.stderrText()).toContain("request failed");
+  });
+
+  it("rejects --prod with --url and requires a target", async () => {
+    const errText: string[] = [];
+    const both = await cmdMcpServe({
+      dir: ".",
+      prod: true,
+      url: "http://127.0.0.1:3000",
+      err: (text) => {
+        errText.push(text);
+      },
+    });
+    expect(both).toBe(1);
+    expect(errText.join("")).toContain("mutually exclusive");
+
+    const neither = await cmdMcpServe({
+      dir: ".",
+      err: (text) => {
+        errText.push(text);
+      },
+    });
+    expect(neither).toBe(1);
+    expect(errText.join("")).toContain("requires --prod");
+  });
+
+  it("rejects unknown subcommands", async () => {
+    const errText: string[] = [];
+    const code = await cmdMcp("uninstall", {
+      dir: ".",
+      err: (text) => {
+        errText.push(text);
+      },
+    });
+    expect(code).toBe(1);
+    expect(errText.join("")).toContain('Unknown mcp subcommand "uninstall"');
+  });
+});
+
+describe("cmdMcpInstall", () => {
+  let home: string | undefined;
+  const savedHome = process.env.HOME;
+
+  afterEach(async () => {
+    if (savedHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = savedHome;
+    }
+    if (home !== undefined) {
+      await rm(home, { recursive: true, force: true });
+      home = undefined;
+    }
+  });
+
+  async function withTempHome(): Promise<string> {
+    home = await mkdtemp(join(tmpdir(), "agentkit-mcp-home-"));
+    process.env.HOME = home;
+    return home;
+  }
+
+  it("writes a --url entry named after the mount slug", async () => {
+    const dir = await withTempHome();
+    const out = createWireCapture();
+    const code = await cmdMcpInstall({
+      dir: ".",
+      url: "http://127.0.0.1:3000/weather-agent/",
+      stdout: out.sink,
+      err: () => {},
+    });
+    expect(code).toBe(0);
+
+    const raw = await readFile(join(dir, ".cursor", "mcp.json"), "utf8");
+    expect(JSON.parse(raw)).toEqual({
+      mcpServers: {
+        "weather-agent": {
+          command: "agentkit",
+          args: ["mcp", "--url", "http://127.0.0.1:3000/weather-agent"],
+        },
+      },
+    });
+  });
+
+  it("requires --name when the URL has no path segment", async () => {
+    await withTempHome();
+    const errText: string[] = [];
+    const code = await cmdMcpInstall({
+      dir: ".",
+      url: "http://127.0.0.1:3000",
+      err: (text) => {
+        errText.push(text);
+      },
+    });
+    expect(code).toBe(1);
+    expect(errText.join("")).toContain("pass --name");
+  });
+
+  it("verifies the hosted deployment and pins slug + team in the args", async () => {
+    const dir = await withTempHome();
+    const resolveImpl = vi.fn(async () => ({
+      agentUrl: "http://127.0.0.1:4000",
+      headers: {},
+      slug: "weather",
+      expiresAt: "2099-01-01T00:00:00.000Z",
+    })) satisfies ResolveProdTargetImpl;
+
+    const code = await cmdMcpInstall({
+      dir: ".",
+      prod: true,
+      slug: "weather",
+      team: "42",
+      resolveProdTargetImpl: resolveImpl,
+      stdout: createWireCapture().sink,
+      err: () => {},
+    });
+    expect(code).toBe(0);
+    expect(resolveImpl).toHaveBeenCalledTimes(1);
+
+    const raw = await readFile(join(dir, ".cursor", "mcp.json"), "utf8");
+    expect(JSON.parse(raw)).toEqual({
+      mcpServers: {
+        weather: {
+          command: "agentkit",
+          args: ["mcp", "--prod", "--slug", "weather", "--team", "42"],
+        },
+      },
+    });
+  });
+
+  it("--remote writes a stable gateway URL with the API-key bearer", async () => {
+    const dir = await withTempHome();
+    const client = new AgentServeDeployClient({
+      backendUrl: "https://api.cursor.com",
+      apiKey: "crsr_test_key",
+      fetchImpl: (async () =>
+        new Response(
+          JSON.stringify({
+            id: 1,
+            slug: "jenny",
+            teamId: 42,
+            deploymentKind: "repo",
+            status: "running",
+            generation: 1,
+            engineAlias: "/internal/agent-serve/agents/asd_x/engine",
+          }),
+          { status: 200, headers: { "content-type": "application/json" } }
+        )) as unknown as typeof fetch,
+    });
+    const resolveDeployAuthImpl: typeof resolveDeployAuth = async () => ({
+      client,
+      teamId: 42,
+      apiKey: "crsr_test_key",
+      backendUrl: "https://api.cursor.com",
+    });
+
+    const code = await cmdMcpInstall({
+      dir: ".",
+      prod: true,
+      remote: true,
+      slug: "jenny",
+      resolveDeployAuthImpl,
+      stdout: createWireCapture().sink,
+      err: () => {},
+    });
+    expect(code).toBe(0);
+
+    const raw = await readFile(join(dir, ".cursor", "mcp.json"), "utf8");
+    expect(JSON.parse(raw)).toEqual({
+      mcpServers: {
+        jenny: {
+          url: "https://api.cursor.com/internal/agent-serve/mcp/42/jenny",
+          headers: { Authorization: "Bearer crsr_test_key" },
+        },
+      },
+    });
+  });
+
+  it("--remote still installs when the caller cannot read deployments", async () => {
+    // Reading deployments is admin-tier; calling the gateway only needs team
+    // membership, so a 403 preflight must not lock a member out.
+    const dir = await withTempHome();
+    const client = new AgentServeDeployClient({
+      backendUrl: "https://api.cursor.com",
+      apiKey: "crsr_member_key",
+      fetchImpl: (async () =>
+        new Response(JSON.stringify({ error: "Not authorized" }), {
+          status: 403,
+          headers: { "content-type": "application/json" },
+        })) as unknown as typeof fetch,
+    });
+    const resolveDeployAuthImpl: typeof resolveDeployAuth = async () => ({
+      client,
+      teamId: 42,
+      apiKey: "crsr_member_key",
+      backendUrl: "https://api.cursor.com",
+    });
+
+    const errText: string[] = [];
+    const code = await cmdMcpInstall({
+      dir: ".",
+      prod: true,
+      remote: true,
+      slug: "jenny",
+      resolveDeployAuthImpl,
+      stdout: createWireCapture().sink,
+      err: (text) => {
+        errText.push(text);
+      },
+    });
+    expect(code).toBe(0);
+    expect(errText.join("")).toContain("Could not verify");
+
+    const raw = await readFile(join(dir, ".cursor", "mcp.json"), "utf8");
+    expect(JSON.parse(raw).mcpServers.jenny.url).toBe(
+      "https://api.cursor.com/internal/agent-serve/mcp/42/jenny"
+    );
+  });
+
+  it("--remote requires --prod", async () => {
+    await withTempHome();
+    const errText: string[] = [];
+    const code = await cmdMcpInstall({
+      dir: ".",
+      remote: true,
+      slug: "jenny",
+      err: (text) => {
+        errText.push(text);
+      },
+    });
+    expect(code).toBe(1);
+    expect(errText.join("")).toContain("--remote requires --prod");
+  });
+
+  it("fails without writing when the deployment cannot be resolved", async () => {
+    const dir = await withTempHome();
+    const resolveImpl = vi.fn(async () => {
+      throw new Error('Deployment "weather" (team 42): Deployment not found');
+    }) satisfies ResolveProdTargetImpl;
+
+    const errText: string[] = [];
+    const code = await cmdMcpInstall({
+      dir: ".",
+      prod: true,
+      slug: "weather",
+      resolveProdTargetImpl: resolveImpl,
+      err: (text) => {
+        errText.push(text);
+      },
+    });
+    expect(code).toBe(1);
+    expect(errText.join("")).toContain("Deployment not found");
+    await expect(
+      readFile(join(dir, ".cursor", "mcp.json"), "utf8")
+    ).rejects.toThrow();
+  });
+
+  it("merges into an existing mcp.json without clobbering other servers", async () => {
+    const dir = await withTempHome();
+    const path = cursorMcpJsonPath();
+    await mkdir(join(dir, ".cursor"), { recursive: true });
+    await writeFile(
+      path,
+      `${JSON.stringify(
+        {
+          mcpServers: {
+            linear: { url: "https://mcp.linear.app/mcp" },
+          },
+          otherTopLevelKey: true,
+        },
+        null,
+        2
+      )}\n`,
+      "utf8"
+    );
+
+    const code = await cmdMcpInstall({
+      dir: ".",
+      url: "http://127.0.0.1:3000/helper",
+      stdout: createWireCapture().sink,
+      err: () => {},
+    });
+    expect(code).toBe(0);
+
+    const raw = JSON.parse(await readFile(path, "utf8")) as {
+      mcpServers: Record<string, unknown>;
+      otherTopLevelKey: boolean;
+    };
+    expect(raw.otherTopLevelKey).toBe(true);
+    expect(raw.mcpServers.linear).toEqual({
+      url: "https://mcp.linear.app/mcp",
+    });
+    expect(raw.mcpServers.helper).toEqual({
+      command: "agentkit",
+      args: ["mcp", "--url", "http://127.0.0.1:3000/helper"],
+    });
+  });
+
+  it("refuses to clobber an unparseable mcp.json", async () => {
+    const tempHome = await withTempHome();
+    await mkdir(join(tempHome, ".cursor"), { recursive: true });
+    const path = cursorMcpJsonPath();
+    await writeFile(path, "{ not json", "utf8");
+
+    const errText: string[] = [];
+    const code = await cmdMcpInstall({
+      dir: ".",
+      url: "http://127.0.0.1:3000/helper",
+      err: (text) => {
+        errText.push(text);
+      },
+    });
+    expect(code).toBe(1);
+    expect(errText.join("")).toContain("not valid JSON");
+    expect(await readFile(path, "utf8")).toBe("{ not json");
+  });
+
+  it("--print emits the entry without touching the filesystem", async () => {
+    const dir = await withTempHome();
+    const out = createWireCapture();
+    const lines: string[] = [];
+    const sink = {
+      write(chunk: string): boolean {
+        lines.push(chunk);
+        out.sink.write(chunk);
+        return true;
+      },
+    };
+    const code = await cmdMcpInstall({
+      dir: ".",
+      url: "http://127.0.0.1:3000/helper",
+      print: true,
+      stdout: sink,
+      err: () => {},
+    });
+    expect(code).toBe(0);
+    expect(JSON.parse(lines.join(""))).toEqual({
+      mcpServers: {
+        helper: {
+          command: "agentkit",
+          args: ["mcp", "--url", "http://127.0.0.1:3000/helper"],
+        },
+      },
+    });
+    await expect(
+      readFile(join(dir, ".cursor", "mcp.json"), "utf8")
+    ).rejects.toThrow();
+  });
+});