@cursor/july 0.1.26 → 0.1.28

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

@@ -1,301 +0,0 @@
-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/defaults.final-post.test.ts

@@ -1,182 +0,0 @@
-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",
-      })
-    );
-  });
-});