@cursor/july 0.1.19 → 0.1.21

package/src/internal/cursor-account-mcp-auth.test.ts

@@ -0,0 +1,310 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type {
+  AvailableMcpServer,
+  McpConnectorStatus,
+} from "./cursor/backend-client.js";
+import {
+  authorizeCursorAccountConnectors,
+  mcpOauthRedirectUri,
+} from "./cursor-account-mcp-auth.js";
+
+const SA_ID = "sa_deploy_1";
+const TEAM_ID = 7;
+
+function status(overrides: Partial<McpConnectorStatus>): McpConnectorStatus {
+  return {
+    id: 1,
+    requiresAuth: false,
+    ...overrides,
+  };
+}
+
+function makeBackend(args: {
+  available: AvailableMcpServer[];
+  statuses: McpConnectorStatus[][];
+}) {
+  let call = 0;
+  const checkCalls: Array<{
+    serverIds: number[];
+    serviceAccountId: string;
+  }> = [];
+  return {
+    checkCalls,
+    client: {
+      getAvailableMcpServers: vi.fn(async () => args.available),
+      checkHttpMcpStatus: vi.fn(
+        async (input: {
+          serverIds: number[];
+          oauthRedirectUri: string;
+          serviceAccountId: string;
+        }) => {
+          checkCalls.push({
+            serverIds: input.serverIds,
+            serviceAccountId: input.serviceAccountId,
+          });
+          const result =
+            args.statuses[Math.min(call, args.statuses.length - 1)];
+          call += 1;
+          return result ?? [];
+        }
+      ),
+    },
+  };
+}
+
+function collect() {
+  const lines: string[] = [];
+  return { lines, write: (text: string) => void lines.push(text) };
+}
+
+describe("authorizeCursorAccountConnectors", () => {
+  it("skips already-authorized connectors without opening a browser", async () => {
+    const backend = makeBackend({
+      available: [{ id: 1, name: "Datadog", isTeamServer: true }],
+      statuses: [[status({ id: 1, requiresAuth: false })]],
+    });
+    const opened: string[] = [];
+    const out = collect();
+
+    const result = await authorizeCursorAccountConnectors({
+      backendClient: backend.client,
+      teamId: TEAM_ID,
+      slug: "jenny",
+      serviceAccountId: SA_ID,
+      connectionName: "cursor",
+      interactive: true,
+      out: out.write,
+      err: out.write,
+      openBrowserImpl: (url) => void opened.push(url),
+      sleep: async () => {},
+    });
+
+    expect(result).toEqual({
+      authorized: ["Datadog"],
+      pending: [],
+      errored: [],
+    });
+    expect(opened).toEqual([]);
+    expect(backend.checkCalls[0]).toEqual({
+      serverIds: [1],
+      serviceAccountId: SA_ID,
+    });
+  });
+
+  it("opens the minted authUrl and polls until the token is stored", async () => {
+    const backend = makeBackend({
+      available: [{ id: 1, name: "Datadog", isTeamServer: true }],
+      statuses: [
+        [
+          status({
+            id: 1,
+            requiresAuth: true,
+            authUrl: "https://auth.example/1",
+          }),
+        ],
+        [
+          status({
+            id: 1,
+            requiresAuth: true,
+            authUrl: "https://auth.example/1",
+          }),
+        ],
+        [status({ id: 1, requiresAuth: false })],
+      ],
+    });
+    const opened: string[] = [];
+    const out = collect();
+
+    const result = await authorizeCursorAccountConnectors({
+      backendClient: backend.client,
+      teamId: TEAM_ID,
+      slug: "jenny",
+      serviceAccountId: SA_ID,
+      connectionName: "cursor",
+      interactive: true,
+      out: out.write,
+      err: out.write,
+      openBrowserImpl: (url) => void opened.push(url),
+      sleep: async () => {},
+      pollIntervalMs: 1,
+      pollTimeoutMs: 1000,
+    });
+
+    expect(opened).toEqual(["https://auth.example/1"]);
+    expect(result.authorized).toEqual(["Datadog"]);
+    expect(result.pending).toEqual([]);
+    // Initial probe + two polls, all SA-scoped.
+    expect(backend.checkCalls.length).toBe(3);
+    expect(
+      backend.checkCalls.every((call) => call.serviceAccountId === SA_ID)
+    ).toBe(true);
+    expect(out.lines.join("")).toContain("as yourself");
+  });
+
+  it("reports pending without opening anything when not interactive", async () => {
+    const backend = makeBackend({
+      available: [{ id: 1, name: "Datadog", isTeamServer: true }],
+      statuses: [
+        [
+          status({
+            id: 1,
+            requiresAuth: true,
+            authUrl: "https://auth.example/1",
+          }),
+        ],
+      ],
+    });
+    const opened: string[] = [];
+    const out = collect();
+
+    const result = await authorizeCursorAccountConnectors({
+      backendClient: backend.client,
+      teamId: TEAM_ID,
+      slug: "jenny",
+      serviceAccountId: SA_ID,
+      connectionName: "cursor",
+      interactive: false,
+      out: out.write,
+      err: out.write,
+      openBrowserImpl: (url) => void opened.push(url),
+      sleep: async () => {},
+    });
+
+    expect(opened).toEqual([]);
+    expect(result.pending).toEqual(["Datadog"]);
+  });
+
+  it("filters to the connection's servers and warns on unmatched names", async () => {
+    const backend = makeBackend({
+      available: [
+        { id: 1, name: "Datadog", isTeamServer: true },
+        { id: 2, name: "Linear", isTeamServer: true },
+        { id: 3, name: "Personal", isTeamServer: false },
+      ],
+      statuses: [[status({ id: 1, requiresAuth: false })]],
+    });
+    const out = collect();
+    const err = collect();
+
+    const result = await authorizeCursorAccountConnectors({
+      backendClient: backend.client,
+      teamId: TEAM_ID,
+      slug: "jenny",
+      serviceAccountId: SA_ID,
+      connectionName: "cursor",
+      servers: ["datadog", "Nope"],
+      interactive: true,
+      out: out.write,
+      err: err.write,
+      openBrowserImpl: () => {},
+      sleep: async () => {},
+    });
+
+    expect(backend.checkCalls[0]?.serverIds).toEqual([1]);
+    expect(err.lines.join("")).toContain('"Nope"');
+    expect(result.authorized).toEqual(["Datadog"]);
+  });
+
+  it("never selects personal (non-team) connectors", async () => {
+    const backend = makeBackend({
+      available: [{ id: 3, name: "Personal", isTeamServer: false }],
+      statuses: [[]],
+    });
+    const err = collect();
+
+    const result = await authorizeCursorAccountConnectors({
+      backendClient: backend.client,
+      teamId: TEAM_ID,
+      slug: "jenny",
+      serviceAccountId: SA_ID,
+      connectionName: "cursor",
+      interactive: true,
+      out: err.write,
+      err: err.write,
+      openBrowserImpl: () => {},
+      sleep: async () => {},
+    });
+
+    expect(backend.client.checkHttpMcpStatus).not.toHaveBeenCalled();
+    expect(result).toEqual({ authorized: [], pending: [], errored: [] });
+  });
+
+  it("gives up after the poll timeout and reports the connector pending", async () => {
+    const backend = makeBackend({
+      available: [{ id: 1, name: "Datadog", isTeamServer: true }],
+      statuses: [
+        [
+          status({
+            id: 1,
+            requiresAuth: true,
+            authUrl: "https://auth.example/1",
+          }),
+        ],
+      ],
+    });
+    const out = collect();
+
+    const result = await authorizeCursorAccountConnectors({
+      backendClient: backend.client,
+      teamId: TEAM_ID,
+      slug: "jenny",
+      serviceAccountId: SA_ID,
+      connectionName: "cursor",
+      interactive: true,
+      out: out.write,
+      err: out.write,
+      openBrowserImpl: () => {},
+      sleep: async () => {},
+      pollIntervalMs: 1,
+      pollTimeoutMs: 3,
+    });
+
+    expect(result.pending).toEqual(["Datadog"]);
+    expect(result.authorized).toEqual([]);
+  });
+
+  it("surfaces backend probe errors per connector", async () => {
+    const backend = makeBackend({
+      available: [{ id: 1, name: "Datadog", isTeamServer: true }],
+      statuses: [
+        [status({ id: 1, requiresAuth: true, error: "probe exploded" })],
+      ],
+    });
+    const err = collect();
+
+    const result = await authorizeCursorAccountConnectors({
+      backendClient: backend.client,
+      teamId: TEAM_ID,
+      slug: "jenny",
+      serviceAccountId: SA_ID,
+      connectionName: "cursor",
+      interactive: true,
+      out: err.write,
+      err: err.write,
+      openBrowserImpl: () => {},
+      sleep: async () => {},
+    });
+
+    expect(result.errored).toEqual([
+      { name: "Datadog", error: "probe exploded" },
+    ]);
+  });
+});
+
+describe("mcpOauthRedirectUri", () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("defaults to the production dashboard callback", () => {
+    vi.stubEnv("MCP_OAUTH_REDIRECT_URI", "");
+    expect(mcpOauthRedirectUri()).toBe(
+      "https://www.cursor.com/agents/mcp/oauth/callback"
+    );
+  });
+
+  it("honors the MCP_OAUTH_REDIRECT_URI override", () => {
+    vi.stubEnv("MCP_OAUTH_REDIRECT_URI", "https://localhost:4443/cb");
+    expect(mcpOauthRedirectUri()).toBe("https://localhost:4443/cb");
+  });
+});