@cursor/july 0.1.20 → 0.1.21

package/src/internal/cursor-account.integration.test.ts

@@ -0,0 +1,441 @@
+/**
+ * Integration: the Cursor account MCP bridge over the real wire path.
+ *
+ * A fake Cursor backend (real HTTP server) implements the API-key exchange
+ * plus ListSandMcpTools / ExecuteSandMcpTool. An agent with a
+ * `cursorAccount` connection is served; its (mock) runner behaves like the
+ * harness and connects a real MCP SDK client to the resolved bridge URL,
+ * lists the account tools, and calls one. Everything in between — startup
+ * credential resolution, bridge mounting, loopback+secret route auth,
+ * catalog listing, backend execution — is the production code path.
+ */
+
+import { once } from "node:events";
+import { mkdtemp, rm } 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 { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { z } from "zod";
+import { defineChannel, httpChannel, POST } from "../channels.js";
+import type {
+  AgentProject,
+  AgentServeHandle,
+  DiscoveredConnection,
+  RunnerTurnRequest,
+} from "../types.js";
+import type { AgentRunner } from "./sdk-runner.js";
+import { startServer } from "./server.js";
+
+function makeProject(
+  name: string,
+  connections: DiscoveredConnection[]
+): AgentProject {
+  return {
+    rootDir: `/tmp/cursor-account-fixture-${name}`,
+    agentDir: `/tmp/cursor-account-fixture-${name}/agent`,
+    name,
+    agent: {
+      name,
+      runtime: "local",
+      tools: [],
+      skills: [],
+      connections,
+      subagents: [],
+      seedFiles: [],
+    },
+    httpChannel: httpChannel(),
+    channels: [],
+    schedules: [],
+    hooks: [],
+    abs: [],
+    diagnostics: [],
+  };
+}
+
+function fakeJwt(): string {
+  const claims = Buffer.from(
+    JSON.stringify({ exp: Math.floor(Date.now() / 1000) + 3600 })
+  ).toString("base64url");
+  return `header.${claims}.signature`;
+}
+
+interface FakeBackend {
+  url: string;
+  close: () => Promise<void>;
+  exchanges: number;
+  executions: Array<Record<string, unknown>>;
+}
+
+/** Real HTTP server standing in for api2.cursor.sh. */
+async function startFakeBackend(): Promise<FakeBackend> {
+  const state: Pick<FakeBackend, "exchanges" | "executions"> = {
+    exchanges: 0,
+    executions: [],
+  };
+  const server: Server = createServer((req, res) => {
+    let raw = "";
+    req.on("data", (chunk: Buffer) => {
+      raw += chunk.toString("utf8");
+    });
+    req.on("end", () => {
+      const respond = (status: number, body: unknown): void => {
+        res.writeHead(status, { "content-type": "application/json" });
+        res.end(JSON.stringify(body));
+      };
+      if (req.url === "/auth/exchange_user_api_key") {
+        state.exchanges++;
+        if (req.headers.authorization !== "Bearer crsr_integration") {
+          respond(401, {});
+          return;
+        }
+        respond(200, { accessToken: fakeJwt(), refreshToken: "r" });
+        return;
+      }
+      if (req.url === "/aiserver.v1.DashboardService/ListSandMcpTools") {
+        respond(200, {
+          servers: [
+            {
+              serverIdentifier: "Linear",
+              status: "connected",
+              tools: [
+                {
+                  name: "Linear-list_issues",
+                  description: "List Linear issues.",
+                  inputSchema: {
+                    type: "object",
+                    properties: { query: { type: "string" } },
+                  },
+                },
+              ],
+            },
+          ],
+        });
+        return;
+      }
+      if (req.url === "/aiserver.v1.DashboardService/ExecuteSandMcpTool") {
+        state.executions.push(JSON.parse(raw) as Record<string, unknown>);
+        respond(200, {
+          result: {
+            success: {
+              content: [{ text: { text: "ENG-42: fix the flaky test" } }],
+              isError: false,
+            },
+          },
+        });
+        return;
+      }
+      respond(404, { message: `no handler for ${req.url ?? ""}` });
+    });
+  });
+  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}`,
+    close: async () => {
+      server.close();
+      server.closeAllConnections();
+    },
+    get exchanges() {
+      return state.exchanges;
+    },
+    get executions() {
+      return state.executions;
+    },
+  };
+}
+
+const savedEnv: Record<string, string | undefined> = {};
+
+describe("Cursor account MCP connections (integration)", () => {
+  let stateRoot: string | undefined;
+  let handle: AgentServeHandle | undefined;
+  let backend: FakeBackend | undefined;
+
+  beforeEach(() => {
+    for (const key of [
+      "CURSOR_API_BASE_URL",
+      "CURSOR_API_KEY",
+      "AGENT_SERVE_CONFIG_DIR",
+    ]) {
+      savedEnv[key] = process.env[key];
+      delete process.env[key];
+    }
+    // No stored login can leak in from the developer's machine.
+    process.env.AGENT_SERVE_CONFIG_DIR = "/nonexistent-agent-serve-config";
+  });
+
+  afterEach(async () => {
+    await handle?.close();
+    handle = undefined;
+    await backend?.close();
+    backend = undefined;
+    if (stateRoot !== undefined) {
+      await rm(stateRoot, { recursive: true, force: true });
+      stateRoot = undefined;
+    }
+    for (const [key, value] of Object.entries(savedEnv)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+
+  it("exposes account connector tools to local turns through the bridge", async () => {
+    stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-account-"));
+    backend = await startFakeBackend();
+    process.env.CURSOR_API_BASE_URL = backend.url;
+    process.env.CURSOR_API_KEY = "crsr_integration";
+
+    const runner: AgentRunner = {
+      async runTurn(request: RunnerTurnRequest) {
+        const bridge = request.mcpServers.cursor;
+        if (bridge === undefined || !("url" in bridge)) {
+          throw new Error("cursor account transport was not resolved to a URL");
+        }
+        // Reach the bridge exactly like the harness would: a real MCP
+        // client with the resolved URL + headers.
+        const client = new Client({ name: "harness", version: "0.0.0" });
+        const transport = new StreamableHTTPClientTransport(
+          new URL(bridge.url),
+          { requestInit: { headers: bridge.headers } }
+        );
+        await client.connect(transport);
+        try {
+          const listed = await client.listTools();
+          const result = (await client.callTool({
+            name: "Linear-list_issues",
+            arguments: { query: "flaky" },
+          })) as { content: Array<{ type: string; text: string }> };
+          return {
+            status: "finished",
+            result: `${listed.tools.map((tool) => tool.name).join(",")} → ${result.content[0]?.text ?? ""}`,
+          };
+        } finally {
+          await client.close();
+        }
+      },
+    };
+
+    const logs: string[] = [];
+    handle = await startServer(
+      [
+        {
+          slug: "triage",
+          project: makeProject("triage", [
+            {
+              name: "cursor",
+              transport: { cursorAccount: true, servers: ["Linear"] },
+            },
+          ]),
+        },
+      ],
+      {
+        port: 0,
+        stateRoot,
+        runner,
+        playground: false,
+        logger: (line) => {
+          logs.push(line);
+        },
+      }
+    );
+
+    const base = `${handle.url}/triage`;
+    const response = await fetch(`${base}/v1/session`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ message: "list my linear issues" }),
+    });
+    expect(response.status).toBe(200);
+    const { sessionId } = (await response.json()) as { sessionId: string };
+
+    // Wait for the turn to complete.
+    let result: string | undefined;
+    for (let i = 0; i < 200 && result === undefined; i++) {
+      const events = await fetch(
+        `${base}/v1/session/${sessionId}/events?format=json`
+      );
+      const body = (await events.json()) as {
+        events: Array<{ type: string; data: Record<string, unknown> }>;
+      };
+      result = body.events.find((event) => event.type === "turn.completed")
+        ?.data.result as string | undefined;
+      if (result === undefined) {
+        await new Promise((resolve) => setTimeout(resolve, 25));
+      }
+    }
+
+    expect(result).toBe("Linear-list_issues → ENG-42: fix the flaky test");
+    // The backend executed the tool with the account credential (exchanged
+    // exactly once) and the fully-qualified backend tool name.
+    expect(backend.exchanges).toBe(1);
+    expect(backend.executions).toHaveLength(1);
+    expect(backend.executions[0]).toMatchObject({
+      serverIdentifier: "Linear",
+      toolName: "Linear-list_issues",
+      args: { query: "flaky" },
+    });
+    // Startup preflight logged the connector status.
+    expect(
+      logs.some((line) =>
+        line.includes('Cursor account MCP connection "cursor"')
+      )
+    ).toBe(true);
+  });
+
+  it("serves host-side ctx.host.mcp calls through the same bridge", async () => {
+    stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-account-host-"));
+    backend = await startFakeBackend();
+    process.env.CURSOR_API_BASE_URL = backend.url;
+    process.env.CURSOR_API_KEY = "crsr_integration";
+
+    const runner: AgentRunner = {
+      async runTurn() {
+        return { status: "finished", result: "unused" };
+      },
+    };
+    handle = await startServer(
+      [
+        {
+          slug: "triage",
+          project: makeProject("triage", [
+            { name: "cursor", transport: { cursorAccount: true } },
+          ]),
+        },
+      ],
+      { port: 0, stateRoot, runner, playground: false }
+    );
+
+    // The host MCP registry resolves the same loopback bridge (used by
+    // server tools' ctx.host.mcp and channel handlers).
+    const engineHost = handle.agents[0];
+    expect(engineHost).toBeDefined();
+    const mcpResponse = await fetch(
+      `${handle.url}/triage/v1/cursor-account/cursor/mcp`,
+      { method: "POST" }
+    );
+    // Without the boot secret the bridge refuses — even from loopback.
+    expect(mcpResponse.status).toBe(401);
+  });
+
+  it("keeps hostOnly connections off SDK turns but callable via host.mcp", async () => {
+    stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-account-hostonly-"));
+    backend = await startFakeBackend();
+    process.env.CURSOR_API_BASE_URL = backend.url;
+    process.env.CURSOR_API_KEY = "crsr_integration";
+
+    let seenMcpServers: RunnerTurnRequest["mcpServers"] | undefined;
+    const runner: AgentRunner = {
+      async runTurn(request: RunnerTurnRequest) {
+        seenMcpServers = request.mcpServers;
+        return { status: "finished", result: "done" };
+      },
+    };
+
+    const project = makeProject("triage", [
+      {
+        name: "cursor",
+        transport: { cursorAccount: true, servers: ["Linear"] },
+        hostOnly: true,
+      },
+    ]);
+    // The host-side surface: a channel route handler reaching the same
+    // connection through host.mcp (identical registry to server tools'
+    // ctx.host.mcp).
+    project.channels = [
+      {
+        id: "ops",
+        definition: defineChannel({
+          routes: [
+            POST("/probe", {
+              bodySchema: z.object({}),
+              handler: async (_req, { host }) => {
+                const result = await host.mcp.callTool(
+                  "cursor",
+                  "Linear-list_issues",
+                  { query: "flaky" }
+                );
+                return Response.json(result);
+              },
+            }),
+          ],
+        }),
+      },
+    ];
+
+    handle = await startServer([{ slug: "triage", project }], {
+      port: 0,
+      stateRoot,
+      runner,
+      playground: false,
+    });
+    const base = `${handle.url}/triage`;
+
+    // 1. A model turn never sees the host-only connection.
+    const response = await fetch(`${base}/v1/session`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ message: "try to reach anytool directly" }),
+    });
+    expect(response.status).toBe(200);
+    const { sessionId } = (await response.json()) as { sessionId: string };
+    let finished = false;
+    for (let i = 0; i < 200 && !finished; i++) {
+      const events = await fetch(
+        `${base}/v1/session/${sessionId}/events?format=json`
+      );
+      const body = (await events.json()) as {
+        events: Array<{ type: string }>;
+      };
+      finished = body.events.some((event) => event.type === "turn.completed");
+      if (!finished) {
+        await new Promise((resolve) => setTimeout(resolve, 25));
+      }
+    }
+    expect(finished).toBe(true);
+    expect(seenMcpServers).toBeDefined();
+    expect(seenMcpServers?.cursor).toBeUndefined();
+    expect(backend.executions).toHaveLength(0);
+
+    // 2. Host-side callers still reach the bridge (and the backend).
+    const probe = await fetch(`${base}/v1/channels/ops/probe`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: "{}",
+    });
+    expect(probe.status).toBe(200);
+    const result = (await probe.json()) as {
+      content: Array<{ type: string; text?: string }>;
+    };
+    expect(result.content[0]?.text).toContain("ENG-42");
+    expect(backend.executions).toHaveLength(1);
+    expect(backend.executions[0]).toMatchObject({
+      serverIdentifier: "Linear",
+      toolName: "Linear-list_issues",
+    });
+  });
+
+  it("refuses to start with account MCP connections but no credentials", async () => {
+    stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-account-nocreds-"));
+    await expect(
+      startServer(
+        [
+          {
+            slug: "triage",
+            project: makeProject("triage", [
+              { name: "cursor", transport: { cursorAccount: true } },
+            ]),
+          },
+        ],
+        { port: 0, stateRoot, playground: false }
+      )
+    ).rejects.toThrow(/not signed in to Cursor[\s\S]*agentkit login/);
+  });
+});