@cursor/july 0.1.26 → 0.1.28

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

@@ -1,525 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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(
-      {}
-    );
-  });
-});