@cursor/july 0.1.26 → 0.1.28

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

@@ -1,789 +0,0 @@
-/**
- * `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();
-  });
-});