@cursor/july 0.1.20 → 0.1.22

package/src/channels/slack/channel-watch.test.ts

@@ -0,0 +1,363 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  createChannelPostWatcher,
+  SlackChannelAllowlist,
+} from "./channel-watch.js";
+import {
+  parseChannelMessageEvent,
+  type SlackChannelMessageEvent,
+} from "./inbound.js";
+import type { SlackMessage } from "./types.js";
+
+function channelPostBody(args: {
+  channel?: string;
+  ts?: string;
+  threadTs?: string;
+  text?: string;
+  subtype?: string;
+  botId?: string;
+  channelType?: string;
+  user?: string | null;
+}): unknown {
+  return {
+    type: "event_callback",
+    event_id: "Ev1",
+    team_id: "T1",
+    event: {
+      type: "message",
+      channel: args.channel ?? "C123",
+      channel_type: args.channelType ?? "channel",
+      ts: args.ts ?? "100.1",
+      ...(args.threadTs === undefined ? {} : { thread_ts: args.threadTs }),
+      text: args.text ?? "new bug report",
+      ...(args.user === null ? {} : { user: args.user ?? "U1" }),
+      ...(args.subtype === undefined ? {} : { subtype: args.subtype }),
+      ...(args.botId === undefined ? {} : { bot_id: args.botId }),
+    },
+  };
+}
+
+describe("parseChannelMessageEvent", () => {
+  it("parses a top-level channel post", () => {
+    const parsed = parseChannelMessageEvent(channelPostBody({}));
+    expect(parsed).not.toBeNull();
+    expect(parsed?.kind).toBe("post");
+    if (parsed?.kind === "post") {
+      expect(parsed.message.channelId).toBe("C123");
+      expect(parsed.message.ts).toBe("100.1");
+      expect(parsed.message.threadTs).toBe("100.1");
+    }
+  });
+
+  it("parses private-channel (group) posts", () => {
+    const parsed = parseChannelMessageEvent(
+      channelPostBody({ channel: "G9", channelType: "group" })
+    );
+    expect(parsed?.kind).toBe("post");
+  });
+
+  it("drops bot-authored posts", () => {
+    expect(
+      parseChannelMessageEvent(channelPostBody({ botId: "B77" }))
+    ).toBeNull();
+  });
+
+  it("keeps bot-authored posts when includeBotAuthored is set", () => {
+    const parsed = parseChannelMessageEvent(channelPostBody({ botId: "B77" }), {
+      includeBotAuthored: true,
+    });
+    expect(parsed?.kind).toBe("post");
+    if (parsed?.kind === "post") {
+      expect(parsed.message.author?.isBot).toBe(true);
+      expect(parsed.message.author?.botId).toBe("B77");
+    }
+  });
+
+  it("keeps userless bot_message webhook posts when includeBotAuthored is set", () => {
+    const body = channelPostBody({
+      botId: "B77",
+      subtype: "bot_message",
+      user: null,
+      text: "PagerDuty: high error rate on api",
+    });
+    expect(parseChannelMessageEvent(body)).toBeNull();
+    const parsed = parseChannelMessageEvent(body, {
+      includeBotAuthored: true,
+    });
+    expect(parsed?.kind).toBe("post");
+    if (parsed?.kind === "post") {
+      expect(parsed.message.author).toEqual({
+        userId: "",
+        isBot: true,
+        botId: "B77",
+      });
+    }
+  });
+
+  it("recovers alert content from attachments when top-level text is empty", () => {
+    const parsed = parseChannelMessageEvent(
+      {
+        type: "event_callback",
+        team_id: "T1",
+        event: {
+          type: "message",
+          subtype: "bot_message",
+          channel: "C123",
+          channel_type: "channel",
+          ts: "100.1",
+          bot_id: "B77",
+          username: "Datadog",
+          text: "",
+          attachments: [
+            {
+              title:
+                "Triggered: [service-monitor prod:temporal-bugbot] High cache error rate",
+              title_link: "https://us5.datadoghq.com/monitors/19610160",
+              text: "Service temporal-bugbot has a high cache error rate.",
+            },
+          ],
+        },
+      },
+      { includeBotAuthored: true }
+    );
+    expect(parsed?.kind).toBe("post");
+    if (parsed?.kind === "post") {
+      expect(parsed.message.text).toBe("");
+      expect(parsed.message.body).toContain("temporal-bugbot");
+      // Raw body keeps the monitor link; markdown is the model-facing view.
+      expect(parsed.message.body).toContain(
+        "https://us5.datadoghq.com/monitors/19610160"
+      );
+      expect(parsed.message.markdown).toContain("High cache error rate");
+    }
+  });
+
+  it("drops DMs and unknown subtypes", () => {
+    expect(
+      parseChannelMessageEvent(
+        channelPostBody({ channel: "D5", channelType: "im" })
+      )
+    ).toBeNull();
+    expect(
+      parseChannelMessageEvent(channelPostBody({ subtype: "channel_join" }))
+    ).toBeNull();
+  });
+
+  it("parses message_changed into an edit with the new text", () => {
+    const parsed = parseChannelMessageEvent({
+      type: "event_callback",
+      event: {
+        type: "message",
+        subtype: "message_changed",
+        channel: "C123",
+        channel_type: "channel",
+        ts: "101.0",
+        message: { type: "message", ts: "100.1", text: "edited!", user: "U1" },
+      },
+    });
+    expect(parsed?.kind).toBe("edited");
+    if (parsed?.kind === "edited") {
+      expect(parsed.message.ts).toBe("100.1");
+      expect(parsed.message.text).toBe("edited!");
+    }
+  });
+
+  it("parses message_deleted into a deletion", () => {
+    const parsed = parseChannelMessageEvent({
+      type: "event_callback",
+      event: {
+        type: "message",
+        subtype: "message_deleted",
+        channel: "C123",
+        channel_type: "channel",
+        ts: "101.0",
+        deleted_ts: "100.1",
+      },
+    });
+    expect(parsed).toEqual({ kind: "deleted", channelId: "C123", ts: "100.1" });
+  });
+});
+
+describe("SlackChannelAllowlist", () => {
+  it("matches ids directly and names after resolution", () => {
+    const allowlist = new SlackChannelAllowlist(["C123", "#issues-glass"]);
+    expect(allowlist.matches("C123")).toBe(true);
+    expect(allowlist.matches("C999")).toBe(false);
+    expect(allowlist.unresolvedNames()).toEqual(["issues-glass"]);
+    allowlist.applyResolvedNames(new Map([["issues-glass", "C999"]]));
+    expect(allowlist.matches("C999")).toBe(true);
+  });
+
+  it("treats bare names as names, not ids", () => {
+    const allowlist = new SlackChannelAllowlist(["issues-glass"]);
+    expect(allowlist.unresolvedNames()).toEqual(["issues-glass"]);
+  });
+});
+
+describe("createChannelPostWatcher", () => {
+  const dispatched: Array<{ message: SlackMessage; eventId?: string }> = [];
+
+  function watcher(args?: {
+    posts?: "top-level" | "all";
+    debounceMs?: number;
+    includeBotPosts?: boolean;
+    botUserId?: string;
+    botId?: string;
+    allow?: string[];
+  }) {
+    return createChannelPostWatcher({
+      options: {
+        allow: args?.allow ?? ["C123"],
+        ...(args?.posts === undefined ? {} : { posts: args.posts }),
+        ...(args?.debounceMs === undefined
+          ? {}
+          : { debounceMs: args.debounceMs }),
+        ...(args?.includeBotPosts === undefined
+          ? {}
+          : { includeBotPosts: args.includeBotPosts }),
+      },
+      allowlist: new SlackChannelAllowlist(args?.allow ?? ["C123"]),
+      getBotUserId: () => args?.botUserId,
+      getBotId: () => args?.botId,
+      dispatch: (message, eventId) =>
+        dispatched.push(
+          eventId === undefined ? { message } : { message, eventId }
+        ),
+    });
+  }
+
+  function post(args: {
+    channel?: string;
+    ts?: string;
+    threadTs?: string;
+    text?: string;
+    subtype?: string;
+    botId?: string;
+    user?: string | null;
+  }): SlackChannelMessageEvent {
+    const parsed = parseChannelMessageEvent(channelPostBody(args), {
+      includeBotAuthored: true,
+    });
+    if (parsed === null) {
+      throw new Error("fixture did not parse");
+    }
+    return parsed;
+  }
+
+  beforeEach(() => {
+    dispatched.length = 0;
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("dispatches allowlisted top-level posts immediately by default", () => {
+    const w = watcher();
+    expect(w.handle(post({}), "Ev1")).toBe(true);
+    expect(dispatched).toHaveLength(1);
+    expect(dispatched[0]?.eventId).toBe("Ev1");
+  });
+
+  it("skips channels outside the allowlist", () => {
+    const w = watcher();
+    w.handle(post({ channel: "C999" }));
+    expect(dispatched).toHaveLength(0);
+  });
+
+  it("skips thread replies unless posts is 'all'", () => {
+    const w = watcher();
+    w.handle(post({ ts: "100.2", threadTs: "100.1" }));
+    expect(dispatched).toHaveLength(0);
+
+    const all = watcher({ posts: "all" });
+    all.handle(post({ ts: "100.2", threadTs: "100.1" }));
+    expect(dispatched).toHaveLength(1);
+  });
+
+  it("skips posts that mention the bot (app_mention path owns them)", () => {
+    const w = watcher({ botUserId: "UBOT" });
+    w.handle(post({ text: "<@UBOT> please triage" }));
+    expect(dispatched).toHaveLength(0);
+  });
+
+  it("skips bot-authored posts unless includeBotPosts is set", () => {
+    const w = watcher();
+    w.handle(post({ botId: "B77", user: null, subtype: "bot_message" }));
+    expect(dispatched).toHaveLength(0);
+
+    const withBots = watcher({
+      includeBotPosts: true,
+      botId: "BSELF",
+      botUserId: "UBOT",
+    });
+    withBots.handle(post({ botId: "B77", user: null, subtype: "bot_message" }));
+    expect(dispatched).toHaveLength(1);
+    expect(dispatched[0]?.message.author?.botId).toBe("B77");
+  });
+
+  it("skips bot-authored posts when includeBotPosts is on but bot identity is unknown", () => {
+    const w = watcher({ includeBotPosts: true });
+    w.handle(post({ botId: "B77", user: null, subtype: "bot_message" }));
+    expect(dispatched).toHaveLength(0);
+  });
+
+  it("always skips the watching bot's own posts (loop safety)", () => {
+    const w = watcher({
+      includeBotPosts: true,
+      botUserId: "UBOT",
+      botId: "BSELF",
+    });
+    w.handle(post({ botId: "BSELF", user: null, subtype: "bot_message" }));
+    expect(dispatched).toHaveLength(0);
+
+    // Same app posting with its bot user id attached.
+    w.handle(post({ botId: "B99", user: "UBOT" }));
+    expect(dispatched).toHaveLength(0);
+
+    // A different bot still dispatches.
+    w.handle(post({ botId: "B77", user: null, subtype: "bot_message" }));
+    expect(dispatched).toHaveLength(1);
+  });
+
+  it("debounces: edits update the pending text, deletes cancel", () => {
+    vi.useFakeTimers();
+    const w = watcher({ debounceMs: 1_000 });
+
+    w.handle(post({ ts: "100.1", text: "first" }));
+    expect(dispatched).toHaveLength(0);
+    const edit = parseChannelMessageEvent({
+      type: "event_callback",
+      event: {
+        type: "message",
+        subtype: "message_changed",
+        channel: "C123",
+        channel_type: "channel",
+        ts: "101.0",
+        message: { type: "message", ts: "100.1", text: "edited", user: "U1" },
+      },
+    });
+    if (edit === null) {
+      throw new Error("edit fixture did not parse");
+    }
+    w.handle(edit);
+    vi.advanceTimersByTime(1_000);
+    expect(dispatched).toHaveLength(1);
+    expect(dispatched[0]?.message.text).toBe("edited");
+
+    w.handle(post({ ts: "200.1", text: "will be deleted" }));
+    w.handle({ kind: "deleted", channelId: "C123", ts: "200.1" });
+    vi.advanceTimersByTime(5_000);
+    expect(dispatched).toHaveLength(1);
+
+    w.stop();
+  });
+
+  it("stop() cancels pending dispatches", () => {
+    vi.useFakeTimers();
+    const w = watcher({ debounceMs: 1_000 });
+    w.handle(post({}));
+    w.stop();
+    vi.advanceTimersByTime(5_000);
+    expect(dispatched).toHaveLength(0);
+  });
+});

package/src/channels/slack/cursor-account.test.ts

@@ -0,0 +1,253 @@
+import { describe, expect, it, vi } from "vitest";
+import type { HostContext, SendMessageFn } from "../../types.js";
+import {
+  type CursorSlackEnvelope,
+  createPendingSlackApiTransport,
+  dispatchCursorSlackEnvelope,
+  getSlackCursorAccountRuntime,
+} from "./cursor-account.js";
+import { slackChannel } from "./slack-channel.js";
+
+function envelope(
+  overrides: Partial<CursorSlackEnvelope> = {}
+): CursorSlackEnvelope {
+  return {
+    eventName: "app_mention",
+    slackTeamId: "T0TEST",
+    channelId: "C0100",
+    channelType: "channel",
+    threadTs: "111.222",
+    messageTs: "111.222",
+    slackUserId: "U0AAA",
+    text: "benny hello <@U0BBB>",
+    agentName: "Benny",
+    consumerId: "consumer-1",
+    matchedBy: "name",
+    eventId: "Ev1",
+    receivedAtMs: Date.now(),
+    ...overrides,
+  };
+}
+
+function fakeHost(): HostContext {
+  return {} as HostContext;
+}
+
+describe("slackChannel({ cursorAccount: true })", () => {
+  it("registers a runtime with a pending transport and no Socket Mode routes", () => {
+    const definition = slackChannel({ cursorAccount: true });
+    const runtime = getSlackCursorAccountRuntime(definition);
+    expect(runtime).toBeDefined();
+    expect(runtime?.transport.kind).toBe("api-transport");
+    expect(definition.meta?.slackCursorAccount).toBe(true);
+    // Plain socket-mode channels register nothing.
+    expect(
+      getSlackCursorAccountRuntime(slackChannel({ envPrefix: "X" }))
+    ).toBeUndefined();
+  });
+
+  it("rejects mixing cursorAccount with a dedicated Slack app credentials", () => {
+    expect(() =>
+      slackChannel({ cursorAccount: true, envPrefix: "BUGBOT" })
+    ).toThrow(/do not also set credentials\/envPrefix/);
+    expect(() =>
+      slackChannel({
+        cursorAccount: true,
+        credentials: { botToken: "xoxb-x" },
+      })
+    ).toThrow(/do not also set credentials\/envPrefix/);
+  });
+
+  it("rejects channelPosts, toolApprovals, interactivity, and mention/DM off", () => {
+    expect(() =>
+      slackChannel({
+        cursorAccount: true,
+        engagement: { channelPosts: { allow: ["C0TEST"] } },
+      })
+    ).toThrow(/channelPosts/);
+    // Approvals ride Socket Mode interactive envelopes; there is no relay
+    // tap over the Cursor connection, so both toggles reject at construction.
+    expect(() =>
+      slackChannel({
+        cursorAccount: true,
+        toolApprovals: true,
+      })
+    ).toThrow(/toolApprovals/);
+    expect(() =>
+      slackChannel({
+        cursorAccount: true,
+        interactivity: true,
+      })
+    ).toThrow(/interactivity/);
+    expect(() =>
+      slackChannel({
+        cursorAccount: true,
+        onBlockAction: () => null,
+      })
+    ).toThrow(/onBlockAction/);
+    expect(() =>
+      slackChannel({
+        cursorAccount: true,
+        engagement: { mentions: false },
+      })
+    ).toThrow(/mentions/);
+    expect(() =>
+      slackChannel({
+        cursorAccount: true,
+        engagement: { directMessages: false },
+      })
+    ).toThrow(/directMessages/);
+  });
+
+  it("rejects agentName values that contain whitespace", () => {
+    expect(() =>
+      slackChannel({
+        cursorAccount: true,
+        // Cast: string literals with spaces are a type error; runtime still
+        // guards dynamic / widened strings.
+        agentName: "Approval Buddy" as string,
+      })
+    ).toThrow(/single token with no whitespace/);
+  });
+
+  it("calls through the transport once bound, soft-failing before", async () => {
+    const transport = createPendingSlackApiTransport();
+    expect(await transport.call("chat.postMessage", {})).toEqual({
+      ok: false,
+      error: "cursor_slack_relay_not_started",
+    });
+    const calls: Array<{ method: string; args: Record<string, unknown> }> = [];
+    transport.bind(async (method, args) => {
+      calls.push({ method, args });
+      return { ok: true, ts: "1.2" };
+    });
+    expect(await transport.call("chat.postMessage", { channel: "C1" })).toEqual(
+      { ok: true, ts: "1.2" }
+    );
+    expect(calls).toEqual([
+      { method: "chat.postMessage", args: { channel: "C1" } },
+    ]);
+  });
+});
+
+describe("dispatchCursorSlackEnvelope", () => {
+  function setup(options?: Parameters<typeof slackChannel>[0]) {
+    const definition = slackChannel({
+      cursorAccount: true,
+      agentName: "Benny",
+      ...options,
+    });
+    const runtime = getSlackCursorAccountRuntime(definition);
+    if (runtime === undefined) {
+      throw new Error("runtime not registered");
+    }
+    const apiCalls: Array<{ method: string; args: Record<string, unknown> }> =
+      [];
+    runtime.transport.bind(async (method, args) => {
+      apiCalls.push({ method, args });
+      return { ok: true, ts: "999.111" };
+    });
+    const sent: Array<{ message: string; options: any }> = [];
+    const send: SendMessageFn = async (message, sendOptions) => {
+      sent.push({ message, options: sendOptions });
+      return {
+        id: "ses_1",
+        isNew: true,
+        channelId: "slack",
+        continuationToken: "next",
+      } as any;
+    };
+    return { runtime, apiCalls, sent, send };
+  }
+
+  it("dispatches a mention into a thread-keyed session and proxies thread setup calls", async () => {
+    const { runtime, apiCalls, sent, send } = setup();
+    await dispatchCursorSlackEnvelope({
+      runtime,
+      envelope: envelope(),
+      send,
+      host: fakeHost(),
+    });
+
+    expect(sent).toHaveLength(1);
+    expect(sent[0].options.continuationToken).toBe("C0100:111.222");
+    expect(sent[0].options.auth).toMatchObject({
+      authenticator: "slack",
+      principalId: "slack:T0TEST:C0100:111.222",
+    });
+    expect(sent[0].message).toContain("benny hello @U0BBB");
+    expect(sent[0].message).toContain("<slack_context>");
+
+    // Root message: title + typing go through the bound transport.
+    const methods = apiCalls.map((call) => call.method);
+    expect(methods).toContain("assistant.threads.setTitle");
+    expect(methods).toContain("assistant.threads.setStatus");
+  });
+
+  it("routes DMs to the direct-message handler", async () => {
+    const kinds: string[] = [];
+    const { runtime, send } = setup({
+      onAppMention: (ctx, message) => {
+        kinds.push("mention");
+        return null;
+      },
+      onDirectMessage: (ctx, message) => {
+        kinds.push("dm");
+        return null;
+      },
+    });
+    await dispatchCursorSlackEnvelope({
+      runtime,
+      envelope: envelope({
+        channelType: "im",
+        channelId: "D0200",
+        eventId: "Ev2",
+      }),
+      send,
+      host: fakeHost(),
+    });
+    await dispatchCursorSlackEnvelope({
+      runtime,
+      envelope: envelope({ eventId: "Ev3" }),
+      send,
+      host: fakeHost(),
+    });
+    expect(kinds).toEqual(["dm", "mention"]);
+  });
+
+  it("dedupes by Slack event id", async () => {
+    const { runtime, sent, send } = setup();
+    await dispatchCursorSlackEnvelope({
+      runtime,
+      envelope: envelope({ eventId: "EvDup" }),
+      send,
+      host: fakeHost(),
+    });
+    await dispatchCursorSlackEnvelope({
+      runtime,
+      envelope: envelope({ eventId: "EvDup" }),
+      send,
+      host: fakeHost(),
+    });
+    expect(sent).toHaveLength(1);
+  });
+
+  it("claimed-thread replies dispatch as mention-kind follow-ups on the same session key", async () => {
+    const { runtime, sent, send } = setup();
+    await dispatchCursorSlackEnvelope({
+      runtime,
+      envelope: envelope({
+        eventName: "message",
+        matchedBy: "thread",
+        messageTs: "111.333",
+        text: "and tomorrow?",
+        eventId: "Ev4",
+      }),
+      send,
+      host: fakeHost(),
+    });
+    expect(sent).toHaveLength(1);
+    expect(sent[0].options.continuationToken).toBe("C0100:111.222");
+    expect(sent[0].message).toContain("and tomorrow?");
+  });
+});