@cursor/july 0.1.19 → 0.1.21

package/src/internal/cursor-slack-relay.test.ts

@@ -0,0 +1,525 @@
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import type { CursorSlackEnvelope } from "../channels/slack/cursor-account.js";
+import { slackChannel } from "../channels/slack/slack-channel.js";
+import { httpChannel } from "../channels.js";
+import type {
+  AgentProject,
+  AgentServeHandle,
+  ChannelDefinition,
+} from "../types.js";
+import { RelayOffsetStore } from "./cursor-event-relay.js";
+import {
+  CursorSlackRelay,
+  type CursorSlackRelayEvent,
+  createCursorSlackApiCaller,
+  formatCursorSlackEventLog,
+} from "./cursor-slack-relay.js";
+import type { AgentRunner } from "./sdk-runner.js";
+import { startServer } from "./server.js";
+
+interface RecordedRequest {
+  method: string;
+  url: string;
+  body?: unknown;
+}
+
+/**
+ * Minimal fake of the /v0/slack-events surface: records requests and serves
+ * a scripted queue of poll responses. Registration echoes the requested
+ * agents as subscribed on one workspace.
+ */
+function fakeBackend(script: {
+  anchorOffset?: string;
+  polls?: Array<{
+    events: CursorSlackRelayEvent[];
+    nextOffset: string;
+    gapDetected?: boolean;
+  }>;
+  registrationFailures?: number;
+  apiResponses?: Record<string, unknown>;
+}) {
+  const requests: RecordedRequest[] = [];
+  const polls = [...(script.polls ?? [])];
+  let registrationFailures = script.registrationFailures ?? 0;
+  const fetchImpl: typeof fetch = async (input, init) => {
+    const url = String(input);
+    const method = init?.method ?? "GET";
+    const body =
+      typeof init?.body === "string"
+        ? (JSON.parse(init.body) as unknown)
+        : undefined;
+    requests.push({ method, url, ...(body === undefined ? {} : { body }) });
+
+    if (url.includes("/v0/slack-events/subscriptions")) {
+      if (registrationFailures > 0) {
+        registrationFailures -= 1;
+        return new Response("storage unavailable", { status: 503 });
+      }
+      return jsonResponse({
+        workspaces: [{ slackTeamId: "T0TEST", isSubscribed: true }],
+        agents: (
+          (body as { agents?: Array<{ name: string }> })?.agents ?? []
+        ).map((agent) => ({ name: agent.name, isSubscribed: true })),
+        expiresAt: new Date().toISOString(),
+      });
+    }
+    if (url.includes("/v0/slack-events/api")) {
+      const request = body as { method?: string };
+      return jsonResponse(
+        script.apiResponses?.[request.method ?? ""] ?? {
+          ok: true,
+          ts: "999.111",
+        }
+      );
+    }
+    if (url.includes("after=%24") || url.includes("after=$")) {
+      return jsonResponse({
+        events: [],
+        nextOffset: script.anchorOffset ?? "",
+        gapDetected: false,
+      });
+    }
+    const page = polls.shift() ?? {
+      events: [],
+      nextOffset: "",
+      gapDetected: false,
+    };
+    return jsonResponse(page);
+  };
+  return { requests, fetchImpl };
+}
+
+function jsonResponse(body: unknown): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+function envelope(
+  offset: string,
+  overrides: Partial<CursorSlackEnvelope> = {}
+): CursorSlackRelayEvent {
+  return {
+    offset,
+    eventName: "app_mention",
+    slackTeamId: "T0TEST",
+    channelId: "C0100",
+    channelType: "channel",
+    threadTs: "111.222",
+    messageTs: "111.222",
+    slackUserId: "U0AAA",
+    text: "what's the weather?",
+    agentName: "Benny",
+    consumerId: "consumer-under-test",
+    matchedBy: "name",
+    eventId: `Ev${offset}`,
+    receivedAtMs: Date.now(),
+    ...overrides,
+  };
+}
+
+async function waitFor(
+  predicate: () => boolean,
+  timeoutMs = 2_000
+): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (!predicate()) {
+    if (Date.now() > deadline) {
+      throw new Error("waitFor timed out");
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+}
+
+describe("formatCursorSlackEventLog", () => {
+  it("names the agent, match kind, and thread", () => {
+    expect(
+      formatCursorSlackEventLog({
+        eventName: "app_mention",
+        agentName: "Benny",
+        matchedBy: "name",
+        channelId: "C0100",
+        threadTs: "111.222",
+        receivedAtMs: Date.parse("2026-07-14T16:00:00.000Z"),
+        eventId: "Ev1",
+      })
+    ).toBe(
+      "app_mention → Benny (name) in C0100/111.222 received=2026-07-14T16:00:00.000Z (Ev1)"
+    );
+  });
+});
+
+describe("createCursorSlackApiCaller", () => {
+  it("POSTs the method, args, agent name, and consumer id; returns the body", async () => {
+    const backend = fakeBackend({
+      apiResponses: { "chat.postMessage": { ok: true, ts: "123.456" } },
+    });
+    const call = createCursorSlackApiCaller({
+      baseUrl: "https://api2.example/",
+      apiKey: "key_1",
+      agentName: "Benny",
+      consumerId: "consumer-1",
+      fetchImpl: backend.fetchImpl,
+    });
+    const result = await call("chat.postMessage", {
+      channel: "C0100",
+      markdown_text: "hi",
+      thread_ts: "111.222",
+    });
+    expect(result).toEqual({ ok: true, ts: "123.456" });
+    expect(backend.requests).toHaveLength(1);
+    expect(backend.requests[0]).toMatchObject({
+      method: "POST",
+      url: "https://api2.example/v0/slack-events/api",
+      body: {
+        method: "chat.postMessage",
+        arguments: {
+          channel: "C0100",
+          markdown_text: "hi",
+          thread_ts: "111.222",
+        },
+        agentName: "Benny",
+        consumerId: "consumer-1",
+      },
+    });
+  });
+
+  it("soft-fails Slack-style when the backend is unreachable", async () => {
+    const call = createCursorSlackApiCaller({
+      baseUrl: "https://api2.example",
+      apiKey: "key_1",
+      agentName: "Benny",
+      consumerId: "consumer-1",
+      fetchImpl: async () => {
+        throw new Error("ECONNREFUSED");
+      },
+    });
+    expect(await call("chat.postMessage", {})).toEqual({
+      ok: false,
+      error: "cursor_backend_unreachable",
+    });
+  });
+});
+
+describe("CursorSlackRelay", () => {
+  let dir: string;
+  let relay: CursorSlackRelay | undefined;
+
+  afterEach(async () => {
+    await relay?.stop();
+    relay = undefined;
+    if (dir !== undefined) {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  async function makeRelay(
+    backend: ReturnType<typeof fakeBackend>,
+    options?: {
+      dispatch?: (e: CursorSlackRelayEvent) => Promise<void>;
+      logger?: (line: string) => void;
+      agents?: Array<{ name: string; iconEmoji?: string }>;
+    }
+  ): Promise<{ dispatched: CursorSlackRelayEvent[]; consumerId: string }> {
+    const dispatched: CursorSlackRelayEvent[] = [];
+    relay = new CursorSlackRelay({
+      baseUrl: "https://api2.example",
+      apiKey: "key",
+      agents: options?.agents ?? [{ name: "Benny", iconEmoji: ":robot:" }],
+      stateDir: dir,
+      dispatch:
+        options?.dispatch ??
+        (async (e) => {
+          dispatched.push(e);
+        }),
+      logger: options?.logger ?? (() => {}),
+      fetchImpl: backend.fetchImpl,
+      pollWaitMs: 0,
+    });
+    const consumerId = await relay.resolveConsumerId();
+    relay.start();
+    return { dispatched, consumerId };
+  }
+
+  it("registers before consuming, anchors, dispatches in order, persists offset + consumer id", async () => {
+    dir = await mkdtemp(join(tmpdir(), "cursor-slack-"));
+    const store = new RelayOffsetStore(dir);
+    const backendProbe = fakeBackend({});
+    // Resolve the consumer id first so the scripted poll can carry it.
+    const probe = new CursorSlackRelay({
+      baseUrl: "https://api2.example",
+      apiKey: "key",
+      agents: [{ name: "Benny" }],
+      stateDir: dir,
+      dispatch: async () => {},
+      logger: () => {},
+      fetchImpl: backendProbe.fetchImpl,
+    });
+    const consumerId = await probe.resolveConsumerId();
+
+    const backend = fakeBackend({
+      anchorOffset: "100-0",
+      polls: [
+        {
+          events: [
+            envelope("101-0", { consumerId }),
+            envelope("102-0", {
+              consumerId,
+              eventName: "message",
+              matchedBy: "thread",
+              messageTs: "111.333",
+            }),
+          ],
+          nextOffset: "102-0",
+        },
+      ],
+    });
+    const { dispatched } = await makeRelay(backend);
+
+    await waitFor(() => dispatched.length === 2);
+    expect(dispatched.map((e) => e.eventName)).toEqual([
+      "app_mention",
+      "message",
+    ]);
+    await waitFor(() =>
+      backend.requests.some((r) => r.url.includes("after=102-0"))
+    );
+    await relay?.stop();
+    relay = undefined;
+
+    expect(await store.load()).toBe("102-0");
+
+    // Consumption is registration-gated: the first request is the PUT.
+    expect(backend.requests[0]?.method).toBe("PUT");
+    expect(backend.requests[0]?.body).toMatchObject({
+      consumerId,
+      agents: [{ name: "Benny", iconEmoji: ":robot:" }],
+    });
+    expect((await readFile(join(dir, "consumer-id"), "utf8")).trim()).toBe(
+      consumerId
+    );
+  });
+
+  it("skips sibling consumers' events and unknown agents but advances the offset", async () => {
+    dir = await mkdtemp(join(tmpdir(), "cursor-slack-"));
+    const probeBackend = fakeBackend({});
+    const probe = new CursorSlackRelay({
+      baseUrl: "https://api2.example",
+      apiKey: "key",
+      agents: [{ name: "Benny" }],
+      stateDir: dir,
+      dispatch: async () => {},
+      logger: () => {},
+      fetchImpl: probeBackend.fetchImpl,
+    });
+    const consumerId = await probe.resolveConsumerId();
+
+    const backend = fakeBackend({
+      anchorOffset: "0-1",
+      polls: [
+        {
+          events: [
+            // Another host (consumer) on the same principal stream.
+            envelope("1-0", { consumerId: "other-host" }),
+            // Our consumer id but an agent we did not register.
+            envelope("2-0", { consumerId, agentName: "Stranger" }),
+            // Ours.
+            envelope("3-0", { consumerId }),
+          ],
+          nextOffset: "3-0",
+        },
+      ],
+    });
+    const { dispatched } = await makeRelay(backend);
+
+    await waitFor(() => dispatched.length === 1);
+    expect(dispatched[0]?.offset).toBe("3-0");
+    await relay?.stop();
+    relay = undefined;
+    const store = new RelayOffsetStore(dir);
+    expect(await store.load()).toBe("3-0");
+  });
+
+  it("deregisters its agents on clean stop", async () => {
+    dir = await mkdtemp(join(tmpdir(), "cursor-slack-"));
+    const backend = fakeBackend({ anchorOffset: "1-0" });
+    const { consumerId } = await makeRelay(backend);
+    await waitFor(() => backend.requests.some((r) => r.method === "GET"));
+
+    await relay?.stop();
+    relay = undefined;
+
+    const lastPut = backend.requests.filter((r) => r.method === "PUT").at(-1);
+    expect(lastPut?.body).toEqual({ consumerId, agents: [] });
+  });
+
+  it("retries registration until it succeeds before any consumption", async () => {
+    dir = await mkdtemp(join(tmpdir(), "cursor-slack-"));
+    const probeBackend = fakeBackend({});
+    const probe = new CursorSlackRelay({
+      baseUrl: "https://api2.example",
+      apiKey: "key",
+      agents: [{ name: "Benny" }],
+      stateDir: dir,
+      dispatch: async () => {},
+      logger: () => {},
+      fetchImpl: probeBackend.fetchImpl,
+    });
+    const consumerId = await probe.resolveConsumerId();
+    const backend = fakeBackend({
+      anchorOffset: "10-0",
+      polls: [
+        { events: [envelope("11-0", { consumerId })], nextOffset: "11-0" },
+      ],
+      registrationFailures: 1,
+    });
+    const { dispatched } = await makeRelay(backend);
+
+    await waitFor(() => dispatched.length === 1, 10_000);
+    const firstGetIndex = backend.requests.findIndex((r) => r.method === "GET");
+    const successfulPutIndex = backend.requests.findIndex(
+      (r, index) => r.method === "PUT" && index > 0
+    );
+    expect(successfulPutIndex).toBeGreaterThan(0);
+    expect(firstGetIndex).toBeGreaterThan(successfulPutIndex);
+  });
+});
+
+describe("serve with cursor-account Slack channels", () => {
+  const savedEnv: Record<string, string | undefined> = {};
+  let stateRoot: string | undefined;
+  let handle: AgentServeHandle | undefined;
+
+  const runner: AgentRunner = {
+    async runTurn() {
+      return { status: "finished", result: "unused" };
+    },
+  };
+
+  function fixture(): AgentProject {
+    return {
+      rootDir: "/tmp/cursor-slack-fixture",
+      agentDir: "/tmp/cursor-slack-fixture/agent",
+      name: "slack-fixture",
+      agent: {
+        name: "slack-fixture",
+        runtime: "local",
+        tools: [],
+        skills: [],
+        connections: [],
+        subagents: [],
+        seedFiles: [],
+      },
+      httpChannel: httpChannel(),
+      channels: [
+        {
+          id: "slack",
+          // Same erasure discovery performs when loading authored channels.
+          definition: slackChannel({
+            cursorAccount: true,
+            agentName: "Benny",
+          }) as unknown as ChannelDefinition,
+        },
+      ],
+      schedules: [],
+      hooks: [],
+      abs: [],
+      diagnostics: [],
+    };
+  }
+
+  beforeEach(() => {
+    for (const key of [
+      "CURSOR_API_KEY",
+      "CURSOR_API_BASE_URL",
+      "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;
+    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("refuses to serve when the host is not signed in to Cursor", async () => {
+    const root = await mkdtemp(join(tmpdir(), "agent-serve-cursor-slack-"));
+    stateRoot = root;
+    await expect(
+      startServer([{ slug: "", project: fixture() }], {
+        port: 0,
+        stateRoot: root,
+        playground: false,
+        runner,
+      })
+    ).rejects.toThrow(
+      /cursorAccount: true[\s\S]*signed in to Cursor[\s\S]*agentkit login/
+    );
+  });
+
+  it("starts the relay when a credential is present", async () => {
+    const root = await mkdtemp(join(tmpdir(), "agent-serve-cursor-slack-"));
+    stateRoot = root;
+    process.env.CURSOR_API_KEY = "crsr_env";
+    // Point at a closed local port so the background relay fails fast and
+    // hermetically instead of reaching the real backend.
+    process.env.CURSOR_API_BASE_URL = "http://127.0.0.1:9";
+    const logs: string[] = [];
+    handle = await startServer([{ slug: "", project: fixture() }], {
+      port: 0,
+      stateRoot: root,
+      playground: false,
+      runner,
+      logger: (line) => logs.push(line),
+    });
+    expect(
+      logs.some(
+        (line) =>
+          line.includes("cursor-slack: relaying Slack for") &&
+          line.includes("Benny")
+      )
+    ).toBe(true);
+  });
+
+  it("rejects duplicate registered agent names across mounts", async () => {
+    const root = await mkdtemp(join(tmpdir(), "agent-serve-cursor-slack-"));
+    stateRoot = root;
+    process.env.CURSOR_API_KEY = "crsr_env";
+    process.env.CURSOR_API_BASE_URL = "http://127.0.0.1:9";
+    const projectA = fixture();
+    const projectB = fixture();
+    await expect(
+      startServer(
+        [
+          { slug: "a", project: projectA },
+          { slug: "b", project: projectB },
+        ],
+        {
+          port: 0,
+          stateRoot: root,
+          playground: false,
+          runner,
+        }
+      )
+    ).rejects.toThrow(/register the Slack name "Benny"/);
+  });
+});

package/src/internal/deploy-source.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, it } from "vitest";
+import {
+  agentPathRelativeToGitRoot,
+  type GitRunner,
+  httpsGitRepoUrlFromRemote,
+  inferDeployGitSource,
+} from "./deploy-source.js";
+
+describe("httpsGitRepoUrlFromRemote", () => {
+  it("normalizes https, ssh, and git@ remotes", () => {
+    expect(
+      httpsGitRepoUrlFromRemote("https://github.com/acme/agents.git")
+    ).toBe("https://github.com/acme/agents");
+    expect(httpsGitRepoUrlFromRemote("git@github.com:acme/agents.git")).toBe(
+      "https://github.com/acme/agents"
+    );
+    expect(
+      httpsGitRepoUrlFromRemote("ssh://git@github.com/acme/agents.git")
+    ).toBe("https://github.com/acme/agents");
+    expect(
+      httpsGitRepoUrlFromRemote("ssh://git@github.com:22/acme/agents.git")
+    ).toBe("https://github.com/acme/agents");
+  });
+
+  it("normalizes GitHub org-scoped SSH remotes (org-NNNN@github.com:…)", () => {
+    expect(
+      httpsGitRepoUrlFromRemote(
+        "org-96667180@github.com:anysphere/everysphere.git"
+      )
+    ).toBe("https://github.com/anysphere/everysphere");
+  });
+
+  it("rejects unusable remotes", () => {
+    expect(httpsGitRepoUrlFromRemote("")).toBeUndefined();
+    expect(httpsGitRepoUrlFromRemote("not-a-url")).toBeUndefined();
+    expect(httpsGitRepoUrlFromRemote("https://github.com/")).toBeUndefined();
+  });
+});
+
+describe("agentPathRelativeToGitRoot", () => {
+  it("returns a posix-relative path for nested dirs and omits the root", () => {
+    expect(
+      agentPathRelativeToGitRoot(
+        "/repo/packages/agent-serve/examples/approval-buddy",
+        "/repo"
+      )
+    ).toBe("packages/agent-serve/examples/approval-buddy");
+    expect(agentPathRelativeToGitRoot("/repo", "/repo")).toBeUndefined();
+  });
+
+  it("returns undefined when dir is outside the repo", () => {
+    expect(
+      agentPathRelativeToGitRoot("/elsewhere/agent", "/repo")
+    ).toBeUndefined();
+  });
+});
+
+describe("inferDeployGitSource", () => {
+  it("assembles repo, ref, and path from git probes", async () => {
+    const git: GitRunner = async (args) => {
+      const key = args.join(" ");
+      switch (key) {
+        case "rev-parse --show-toplevel":
+          return "/repo";
+        case "remote get-url origin":
+          return "git@github.com:acme/agents.git";
+        case "rev-parse --abbrev-ref HEAD":
+          return "main";
+        default:
+          return undefined;
+      }
+    };
+    await expect(
+      inferDeployGitSource("/repo/examples/weather-agent", { git })
+    ).resolves.toEqual({
+      gitRepoUrl: "https://github.com/acme/agents",
+      gitRef: "main",
+      agentPath: "examples/weather-agent",
+    });
+  });
+
+  it("pins a detached HEAD to the commit SHA", async () => {
+    const git: GitRunner = async (args) => {
+      const key = args.join(" ");
+      switch (key) {
+        case "rev-parse --show-toplevel":
+          return "/repo";
+        case "remote get-url origin":
+          return "https://github.com/acme/agents.git";
+        case "rev-parse --abbrev-ref HEAD":
+          return "HEAD";
+        case "rev-parse HEAD":
+          return "abcdef0123456789";
+        default:
+          return undefined;
+      }
+    };
+    await expect(inferDeployGitSource("/repo", { git })).resolves.toEqual({
+      gitRepoUrl: "https://github.com/acme/agents",
+      gitRef: "abcdef0123456789",
+      agentPath: undefined,
+    });
+  });
+
+  it("returns empty when not inside a git checkout", async () => {
+    const git: GitRunner = async () => undefined;
+    await expect(inferDeployGitSource("/tmp/agent", { git })).resolves.toEqual(
+      {}
+    );
+  });
+});