@cursor/july 0.1.26 → 0.1.27

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

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