@cursor/july 0.1.24 → 0.1.26

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

@@ -0,0 +1,301 @@
+import { describe, expect, it, vi } from "vitest";
+import type { ArtifactsApi, 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;
+}
+
+function testArtifacts(): ArtifactsApi {
+  return {
+    tag: async () => {
+      throw new Error("artifacts not configured in test");
+    },
+    list: async () => [],
+  };
+}
+
+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(),
+      artifacts: testArtifacts(),
+    });
+
+    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("hands the artifacts facade to the mention handler binding", async () => {
+    const tags: Array<Parameters<ArtifactsApi["tag"]>[0]> = [];
+    const artifacts: ArtifactsApi = {
+      tag: async (input) => {
+        tags.push(input);
+        return {
+          id: `art_${tags.length}`,
+          kind: input.kind ?? "artifact",
+          key: input.key,
+          data: input.data,
+          source: "host",
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+        };
+      },
+      list: async () => [],
+    };
+    const { runtime, send } = setup({
+      onAppMention: async (ctx) => {
+        await ctx.artifacts.tag({ key: "from-relay", data: "r" });
+        return null;
+      },
+    });
+    await dispatchCursorSlackEnvelope({
+      runtime,
+      envelope: envelope(),
+      send,
+      host: fakeHost(),
+      artifacts,
+    });
+    expect(tags).toEqual([{ key: "from-relay", data: "r" }]);
+  });
+
+  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(),
+      artifacts: testArtifacts(),
+    });
+    await dispatchCursorSlackEnvelope({
+      runtime,
+      envelope: envelope({ eventId: "Ev3" }),
+      send,
+      host: fakeHost(),
+      artifacts: testArtifacts(),
+    });
+    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(),
+      artifacts: testArtifacts(),
+    });
+    await dispatchCursorSlackEnvelope({
+      runtime,
+      envelope: envelope({ eventId: "EvDup" }),
+      send,
+      host: fakeHost(),
+      artifacts: testArtifacts(),
+    });
+    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(),
+      artifacts: testArtifacts(),
+    });
+    expect(sent).toHaveLength(1);
+    expect(sent[0].options.continuationToken).toBe("C0100:111.222");
+    expect(sent[0].message).toContain("and tomorrow?");
+  });
+});

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

@@ -12,7 +12,7 @@
  * dispatches relayed envelopes through the pack's normal inbound path.
  */
 
-import type { HostContext, SendMessageFn } from "../../types.js";
+import type { ArtifactsApi, HostContext, SendMessageFn } from "../../types.js";
 import { dispatchInboundMessage } from "./dispatch.js";
 import type { EventIdDedupe } from "./event-id-dedupe.js";
 import { slackTextToMarkdown } from "./inbound.js";
@@ -114,6 +114,7 @@ export async function dispatchCursorSlackEnvelope(args: {
   envelope: CursorSlackEnvelope;
   send: SendMessageFn;
   host: HostContext;
+  artifacts: ArtifactsApi;
   hasContinuationSession?: (continuationToken: string) => Promise<boolean>;
   isContinuationBusy?: (continuationToken: string) => Promise<boolean>;
   getContinuationLastBotMessageTs?: (
@@ -167,6 +168,7 @@ export async function dispatchCursorSlackEnvelope(args: {
     send: args.send,
     credentials: runtime.credentials,
     host: args.host,
+    artifacts: args.artifacts,
     log,
     evalCommandsEnabled: runtime.options.evalCommands !== false,
     cursorAgentName: envelope.agentName,

package/src/channels/slack/defaults.final-post.test.ts

@@ -0,0 +1,182 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type {
+  ChannelEventContext,
+  ChannelEventHandlers,
+  SessionContext,
+  SessionEvent,
+} from "../../types.js";
+import type { SlackChannelState } from "./types.js";
+
+const mocks = vi.hoisted(() => ({
+  postMessage: vi.fn(),
+  updateMessage: vi.fn(),
+  setThreadStatus: vi.fn(),
+  startChatStream: vi.fn(),
+  appendChatStream: vi.fn(),
+  stopChatStream: vi.fn(),
+}));
+
+vi.mock("./api.js", () => ({
+  postMessage: mocks.postMessage,
+  updateMessage: mocks.updateMessage,
+  setThreadStatus: mocks.setThreadStatus,
+  startChatStream: mocks.startChatStream,
+  appendChatStream: mocks.appendChatStream,
+  stopChatStream: mocks.stopChatStream,
+  truncateTypingStatus: (text: string) => text.slice(0, 50),
+}));
+
+vi.mock("./assistant.js", () => ({
+  firstNonEmptyLine: (text: string) =>
+    text
+      .split("\n")
+      .map((line) => line.trim())
+      .find((line) => line.length > 0),
+  maybeSetSuggestedPrompts: vi.fn(),
+}));
+
+import { buildDefaultEvents } from "./defaults.js";
+
+let eventIndex = 0;
+
+function evt<T extends SessionEvent["type"]>(
+  partial: Omit<Extract<SessionEvent, { type: T }>, "index" | "at"> &
+    Partial<Pick<SessionEvent, "index" | "at">>
+): Extract<SessionEvent, { type: T }> {
+  return {
+    index: eventIndex++,
+    at: new Date().toISOString(),
+    ...partial,
+  } as Extract<SessionEvent, { type: T }>;
+}
+
+function channelOf(
+  state: SlackChannelState
+): ChannelEventContext<SlackChannelState> {
+  return {
+    channelId: "slack",
+    state,
+    continuationToken: null,
+    setContinuationToken: async () => {},
+  };
+}
+
+const sessionCtx: SessionContext = {
+  session: {
+    id: "s1",
+    channelId: "slack",
+    mode: "chat",
+    auth: null,
+  },
+};
+
+describe("buildDefaultEvents streaming:false (cursorAccount)", () => {
+  let handlers: ChannelEventHandlers<SlackChannelState>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    eventIndex = 0;
+    mocks.postMessage.mockResolvedValue({ ts: "9.9" });
+    mocks.setThreadStatus.mockResolvedValue(undefined);
+    handlers = buildDefaultEvents({ streaming: false });
+  });
+
+  it("uses setStatus for thinking and a single final postMessage", async () => {
+    const channel = channelOf({
+      channelId: "C1",
+      threadTs: "1.0",
+      teamId: "T1",
+      triggeringUserId: "U1",
+      pendingToolCallMessage: null,
+      lastReasoningTypingAtMs: null,
+      lastReasoningTypingStatus: null,
+      streamTs: null,
+      streamChannelId: null,
+      lastPostedText: null,
+    });
+
+    await handlers["turn.started"]!(
+      evt({
+        type: "turn.started",
+        sessionId: "s1",
+        turnId: "t1",
+        data: {},
+      }),
+      channel,
+      sessionCtx
+    );
+    expect(mocks.startChatStream).not.toHaveBeenCalled();
+    expect(mocks.postMessage).not.toHaveBeenCalled();
+    expect(mocks.setThreadStatus).toHaveBeenCalledWith(
+      expect.objectContaining({ status: "Working…" })
+    );
+
+    await handlers["actions.requested"]!(
+      evt({
+        type: "actions.requested",
+        sessionId: "s1",
+        turnId: "t1",
+        data: {
+          calls: [{ callId: "c1", toolName: "get_weather", args: {} }],
+        },
+      }),
+      channel,
+      sessionCtx
+    );
+    expect(mocks.updateMessage).not.toHaveBeenCalled();
+    expect(mocks.setThreadStatus).toHaveBeenCalledWith(
+      expect.objectContaining({ status: "Running get_weather…" })
+    );
+
+    await handlers["message.completed"]!(
+      evt({
+        type: "message.completed",
+        sessionId: "s1",
+        turnId: "t1",
+        data: { text: "Sunny in SF", finishReason: "stop" },
+      }),
+      channel,
+      sessionCtx
+    );
+    expect(mocks.updateMessage).not.toHaveBeenCalled();
+    expect(mocks.postMessage).toHaveBeenCalledTimes(1);
+    expect(mocks.postMessage).toHaveBeenCalledWith(
+      expect.objectContaining({ text: "Sunny in SF" })
+    );
+  });
+
+  it("posts the scrubbed turn.failed reason into the thread", async () => {
+    const channel = channelOf({
+      channelId: "C1",
+      threadTs: "1.0",
+      teamId: "T1",
+      triggeringUserId: "U1",
+      pendingToolCallMessage: null,
+      lastReasoningTypingAtMs: null,
+      lastReasoningTypingStatus: null,
+      streamTs: null,
+      streamChannelId: null,
+      lastPostedText: null,
+    });
+
+    await handlers["turn.failed"]!(
+      evt({
+        type: "turn.failed",
+        sessionId: "s1",
+        turnId: "t1",
+        data: {
+          message: String.raw`Authentication error at C:\Users\alice\secret and /home/ubuntu/secret`,
+        },
+      }),
+      channel,
+      sessionCtx
+    );
+
+    expect(mocks.postMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        text: "I hit an error while handling your request: Authentication error at [path] and [path]",
+        threadTs: "1.0",
+      })
+    );
+  });
+});