@cursor/july 0.1.25 → 0.1.27

package/src/channels/slack/slack.test.ts

@@ -1,391 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { SLACK_LOADING_MESSAGE_MAX_LEN } from "./constants.js";
-import {
-  buildSlackManifest,
-  computeStreamAppend,
-  createSlackLogger,
-  credentialsFromEnv,
-  envPrefixFromName,
-  extractGithubPrRef,
-  parseAppMentionEvent,
-  parseDirectMessageEvent,
-  SLACK_EXTERNAL_APP_MANAGEMENT_URL,
-  slackChannel,
-  slackContinuationKey,
-  slackEnvKeys,
-  slackTextToMarkdown,
-  slackThreadPermalink,
-  truncateTypingStatus,
-  tryResolveAppToken,
-  tryResolveBotToken,
-} from "./index.js";
-
-describe("slackContinuationKey", () => {
-  it("joins channel and thread", () => {
-    expect(slackContinuationKey("C123", "1719.000")).toBe("C123:1719.000");
-  });
-});
-
-describe("slackThreadPermalink", () => {
-  it("prefers the client thread deep link when team is known", () => {
-    expect(
-      slackThreadPermalink({
-        teamId: "T1",
-        channelId: "C9",
-        threadTs: "1783451265.725729",
-      })
-    ).toBe("https://app.slack.com/client/T1/C9/thread/C9-1783451265.725729");
-  });
-
-  it("falls back to archives permalink without team", () => {
-    expect(
-      slackThreadPermalink({
-        channelId: "C9",
-        threadTs: "1783451265.725729",
-      })
-    ).toBe(
-      "https://app.slack.com/archives/C9/p1783451265725729?thread_ts=1783451265.725729"
-    );
-  });
-});
-
-describe("createSlackLogger", () => {
-  it("formats levels and fields", () => {
-    const lines: string[] = [];
-    const log = createSlackLogger((line) => lines.push(line));
-    log.info("inbound", { kind: "app_mention", channel: "C9" });
-    log.warn("chat.startStream unavailable", { error: "missing_scope" });
-    expect(lines[0]).toBe(
-      "[agentkit/slack] inbound kind=app_mention channel=C9"
-    );
-    expect(lines[1]).toBe(
-      "[agentkit/slack] warn chat.startStream unavailable error=missing_scope"
-    );
-  });
-});
-
-describe("inbound parsers", () => {
-  it("parses app_mention", () => {
-    const message = parseAppMentionEvent({
-      type: "event_callback",
-      team_id: "T1",
-      event: {
-        type: "app_mention",
-        user: "U1",
-        text: "<@Ubot> hi there",
-        ts: "1.0",
-        channel: "C9",
-      },
-    });
-    expect(message).not.toBeNull();
-    expect(message?.channelId).toBe("C9");
-    expect(message?.threadTs).toBe("1.0");
-    expect(message?.markdown).toContain("hi there");
-    expect(message?.teamId).toBe("T1");
-  });
-
-  it("parses DMs and drops bot messages", () => {
-    const dm = parseDirectMessageEvent({
-      type: "event_callback",
-      team_id: "T1",
-      event: {
-        type: "message",
-        channel_type: "im",
-        user: "U1",
-        text: "hello",
-        ts: "2.0",
-        channel: "D1",
-      },
-    });
-    expect(dm?.markdown).toBe("hello");
-
-    const bot = parseDirectMessageEvent({
-      type: "event_callback",
-      event: {
-        type: "message",
-        channel_type: "im",
-        bot_id: "B1",
-        text: "noop",
-        ts: "2.0",
-        channel: "D1",
-      },
-    });
-    expect(bot).toBeNull();
-  });
-
-  it("drops bot-authored app_mention events", () => {
-    expect(
-      parseAppMentionEvent({
-        type: "event_callback",
-        event: {
-          type: "app_mention",
-          bot_id: "B1",
-          text: "<@Ubot> loop",
-          ts: "1.0",
-          channel: "C9",
-        },
-      })
-    ).toBeNull();
-  });
-});
-
-describe("slackTextToMarkdown", () => {
-  it("strips user mentions", () => {
-    expect(slackTextToMarkdown("<@U123> please help")).toBe(
-      "@U123 please help"
-    );
-  });
-});
-
-describe("buildSlackManifest", () => {
-  it("enables Socket Mode without request_url", () => {
-    const manifest = buildSlackManifest({
-      name: "Weather Bot",
-      env: "dev",
-    });
-    expect(manifest.display_information.name).toBe("Weather Bot (dev)");
-    expect(manifest.features.bot_user.display_name).toContain("dev");
-    expect(manifest.settings.socket_mode_enabled).toBe(true);
-    expect(
-      (manifest.settings.event_subscriptions as { request_url?: string })
-        .request_url
-    ).toBeUndefined();
-    expect(manifest.oauth_config.scopes.bot).toContain("chat:write");
-    expect(manifest.settings.event_subscriptions.bot_events).toContain(
-      "app_mention"
-    );
-    expect(manifest.settings.interactivity.is_enabled).toBe(false);
-  });
-
-  it("hides tokens and Slack-side installs, pointing management at Cursor", () => {
-    for (const env of ["dev", "prod"] as const) {
-      expect(
-        buildSlackManifest({ name: "Weather Bot", env }).settings
-          .managed_app_settings
-      ).toEqual({
-        is_install_from_slack_disabled: true,
-        external_app_management_url: SLACK_EXTERNAL_APP_MANAGEMENT_URL,
-      });
-    }
-    expect(SLACK_EXTERNAL_APP_MANAGEMENT_URL).toBe(
-      "https://cursor.com/dashboard/deployed-agents"
-    );
-  });
-
-  it("omits managed_app_settings for hand-imported manifests", () => {
-    const manifest = buildSlackManifest({
-      name: "Weather Bot",
-      env: "prod",
-      managedByCursor: false,
-    });
-    expect("managed_app_settings" in manifest.settings).toBe(false);
-  });
-
-  it("pins Benny's Slack app to benny-dev with org deploy", () => {
-    for (const env of ["dev", "prod"] as const) {
-      const manifest = buildSlackManifest({
-        name: "Benny",
-        env,
-        channelPosts: true,
-      });
-      expect(manifest.display_information.name).toBe("benny-dev");
-      expect(manifest.features.bot_user.display_name).toBe("benny-dev");
-      expect(manifest.settings.org_deploy_enabled).toBe(true);
-      expect(manifest.settings.socket_mode_enabled).toBe(true);
-      expect(manifest.settings.token_rotation_enabled).toBe(false);
-      expect(manifest.settings.is_mcp_enabled).toBe(false);
-    }
-    expect(
-      buildSlackManifest({ name: "benny", env: "prod" }).features.bot_user
-        .display_name
-    ).toBe("benny-dev");
-  });
-
-  it("enables interactivity when opted in", () => {
-    const manifest = buildSlackManifest({
-      name: "Weather Bot",
-      env: "prod",
-      interactivity: true,
-    });
-    expect(manifest.settings.interactivity.is_enabled).toBe(true);
-  });
-
-  it("omits channel-post events by default and adds them when opted in", () => {
-    const defaults = buildSlackManifest({ name: "Bot", env: "dev" });
-    expect(defaults.settings.event_subscriptions.bot_events).not.toContain(
-      "message.channels"
-    );
-
-    const watching = buildSlackManifest({
-      name: "Bot",
-      env: "dev",
-      channelPosts: true,
-    });
-    expect(watching.settings.event_subscriptions.bot_events).toContain(
-      "message.channels"
-    );
-    expect(watching.settings.event_subscriptions.bot_events).toContain(
-      "message.groups"
-    );
-  });
-
-  it("defaults the description from the name and honors an explicit one", () => {
-    const bare = buildSlackManifest({ name: "Bot", env: "prod" });
-    expect(bare.display_information.description).toBe(
-      "Bot — an AI agent built with Cursor"
-    );
-    expect(bare.features.assistant_view?.assistant_description).toBe(
-      "Bot — an AI agent built with Cursor"
-    );
-
-    const described = buildSlackManifest({
-      name: "Bot",
-      env: "prod",
-      description: "Does things",
-    });
-    expect(described.display_information.description).toBe("Does things");
-    expect(described.features.assistant_view?.assistant_description).toBe(
-      "Does things"
-    );
-  });
-
-  it("keeps the default description inside Slack's 140-char bound", () => {
-    const manifest = buildSlackManifest({
-      name: "x".repeat(200),
-      env: "prod",
-    });
-    expect(manifest.display_information.description).toHaveLength(140);
-    expect(manifest.display_information.description).toContain(
-      "an AI agent built with Cursor"
-    );
-  });
-});
-
-describe("slackChannel engagement", () => {
-  it("rejects an empty channelPosts allowlist", () => {
-    expect(() =>
-      slackChannel({
-        engagement: { channelPosts: { allow: [" "] } },
-      })
-    ).toThrow(/allow must list at least one channel/);
-  });
-
-  it("surfaces watched channels in channel meta", () => {
-    const channel = slackChannel({
-      engagement: { channelPosts: { allow: ["#issues-glass", "C123"] } },
-    });
-    expect(channel.meta?.kind).toBe("slack");
-    expect(channel.meta?.slackChannelPosts).toEqual(["#issues-glass", "C123"]);
-
-    const plain = slackChannel();
-    expect(plain.meta?.slackChannelPosts).toBeUndefined();
-  });
-});
-
-describe("socket mode event payload", () => {
-  it("parses app_mention from the event body Slack delivers over Socket Mode", () => {
-    const message = parseAppMentionEvent({
-      type: "event_callback",
-      team_id: "T1",
-      event_id: "EvSOCKET1",
-      event: {
-        type: "app_mention",
-        user: "U1",
-        text: "<@Ubot> via socket hello",
-        ts: "9.1",
-        channel: "C9",
-      },
-    });
-    expect(message?.markdown).toContain("via socket hello");
-    expect(message?.channelId).toBe("C9");
-  });
-});
-
-describe("computeStreamAppend", () => {
-  it("returns full text when nothing was posted", () => {
-    expect(computeStreamAppend(null, "Hello")).toBe("Hello");
-    expect(computeStreamAppend("", "Hello")).toBe("Hello");
-  });
-
-  it("returns the unsent suffix", () => {
-    expect(computeStreamAppend("Hello", "Hello world")).toBe(" world");
-  });
-
-  it("returns empty when text does not extend lastPosted", () => {
-    expect(computeStreamAppend("Hello", "Hi there")).toBe("");
-  });
-});
-
-describe("truncateTypingStatus", () => {
-  it("keeps loading_messages under Slack's 51-char limit", () => {
-    const long = "a".repeat(80);
-    const truncated = truncateTypingStatus(long);
-    expect(truncated.length).toBe(SLACK_LOADING_MESSAGE_MAX_LEN);
-    expect(truncated.endsWith("…")).toBe(true);
-  });
-});
-
-describe("env prefixes", () => {
-  it("normalizes agent names", () => {
-    expect(envPrefixFromName("bugbot-cloud")).toBe("BUGBOT_CLOUD");
-    expect(envPrefixFromName("security-reviewer")).toBe("SECURITY_REVIEWER");
-  });
-
-  it("builds per-agent env keys", () => {
-    expect(slackEnvKeys("BUGBOT")).toEqual({
-      bot: "BUGBOT_SLACK_BOT_TOKEN",
-      app: "BUGBOT_SLACK_APP_TOKEN",
-    });
-    expect(slackEnvKeys()).toEqual({
-      bot: "SLACK_BOT_TOKEN",
-      app: "SLACK_APP_TOKEN",
-    });
-  });
-
-  it("does not fall through to shared tokens for prefixed credentials", async () => {
-    const previousBot = process.env.SLACK_BOT_TOKEN;
-    const previousApp = process.env.SLACK_APP_TOKEN;
-    process.env.SLACK_BOT_TOKEN = "xoxb-shared";
-    process.env.SLACK_APP_TOKEN = "xapp-shared";
-    delete process.env.BUGBOT_SLACK_BOT_TOKEN;
-    delete process.env.BUGBOT_SLACK_APP_TOKEN;
-    try {
-      const credentials = credentialsFromEnv("BUGBOT");
-      expect(await tryResolveBotToken(credentials)).toBeUndefined();
-      expect(await tryResolveAppToken(credentials)).toBeUndefined();
-    } finally {
-      if (previousBot === undefined) {
-        delete process.env.SLACK_BOT_TOKEN;
-      } else {
-        process.env.SLACK_BOT_TOKEN = previousBot;
-      }
-      if (previousApp === undefined) {
-        delete process.env.SLACK_APP_TOKEN;
-      } else {
-        process.env.SLACK_APP_TOKEN = previousApp;
-      }
-    }
-  });
-});
-
-describe("extractGithubPrRef", () => {
-  it("parses URLs and owner/repo#N", () => {
-    expect(
-      extractGithubPrRef("please review https://github.com/acme/widget/pull/42")
-    ).toEqual({
-      owner: "acme",
-      repo: "widget",
-      number: 42,
-      url: "https://github.com/acme/widget/pull/42",
-      label: "acme/widget#42",
-    });
-    expect(extractGithubPrRef("drive acme/widget#7 for me")).toEqual({
-      owner: "acme",
-      repo: "widget",
-      number: 7,
-      url: "https://github.com/acme/widget/pull/7",
-      label: "acme/widget#7",
-    });
-    expect(extractGithubPrRef("no pr here")).toBeUndefined();
-  });
-});

package/src/channels/slack/stop.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { isWholeMessageStop, stripLeadingSlackMentions } from "./stop.js";
-
-describe("isWholeMessageStop", () => {
-  it("matches bare stop and @mention stop", () => {
-    expect(isWholeMessageStop("stop")).toBe(true);
-    expect(isWholeMessageStop("STOP")).toBe(true);
-    expect(isWholeMessageStop("<@Ubot> stop")).toBe(true);
-    expect(isWholeMessageStop("<@Ubot>  stop  ")).toBe(true);
-  });
-
-  it("does not match embedded stop", () => {
-    expect(isWholeMessageStop("please stop investigating")).toBe(false);
-    expect(isWholeMessageStop("<@Ubot> stop the deploy")).toBe(false);
-    expect(isWholeMessageStop("")).toBe(false);
-  });
-});
-
-describe("stripLeadingSlackMentions", () => {
-  it("strips repeated leading mentions", () => {
-    expect(stripLeadingSlackMentions("<@A> <@B> stop")).toBe("stop");
-  });
-});

package/src/channels/slack/thread-context.test.ts

@@ -1,202 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import * as slackApi from "./api.js";
-import {
-  findLastBotMessageTs,
-  formatSlackThreadContextBlock,
-  formatSlackThreadDeltaBlock,
-  loadSlackThreadContextBlock,
-  mergeThreadMessagesByTs,
-  selectThreadDeltaMessages,
-  trimThreadMessagesForPrompt,
-} from "./thread-context.js";
-
-describe("formatSlackThreadContextBlock", () => {
-  it("formats parent then replies and excludes the triggering message", () => {
-    const block = formatSlackThreadContextBlock(
-      [
-        {
-          ts: "1.0",
-          bot_id: "B1",
-          username: "Datadog",
-          text: "parent alert",
-        },
-        { ts: "2.0", user: "U1", text: "looking" },
-        { ts: "3.0", user: "U2", text: "@jenny what happened?" },
-      ],
-      { excludeTs: "3.0" }
-    );
-    expect(block).toContain("<slack_thread>");
-    expect(block).toContain("[parent] bot:B1 (Datadog) @ 1.0:");
-    expect(block).toContain("parent alert");
-    expect(block).toContain("[reply] U1 @ 2.0:");
-    expect(block).not.toContain("what happened?");
-    expect(block).toContain("</slack_thread>");
-  });
-
-  it("labels parent by thread ts even when earlier rows are filtered", () => {
-    const block = formatSlackThreadContextBlock(
-      [
-        { ts: "1.0", user: "U1", text: "" },
-        { ts: "2.0", user: "U2", text: "actual parent" },
-        { ts: "3.0", user: "U3", text: "reply" },
-      ],
-      { threadTs: "2.0", excludeTs: "3.0" }
-    );
-    expect(block).toContain("[parent] U2 @ 2.0:");
-    expect(block).not.toContain("[reply] U3 @ 3.0:");
-    expect(block).not.toContain("[parent] U3");
-  });
-
-  it("keeps the thread root plus the newest replies when over the limit", () => {
-    const messages = [{ ts: "1.0", user: "U0", text: "root" }];
-    for (let i = 2; i <= 60; i++) {
-      messages.push({ ts: `${i}.0`, user: "U1", text: `reply ${i}` });
-    }
-    const trimmed = trimThreadMessagesForPrompt(messages, {
-      threadTs: "1.0",
-      limit: 50,
-    });
-    expect(trimmed[0]).toMatchObject({ ts: "1.0" });
-    expect(trimmed.at(-1)).toMatchObject({ ts: "60.0" });
-    expect(trimmed).toHaveLength(50);
-  });
-
-  it("returns undefined when nothing usable remains", () => {
-    expect(
-      formatSlackThreadContextBlock([{ ts: "1.0", text: "only me" }], {
-        excludeTs: "1.0",
-      })
-    ).toBeUndefined();
-  });
-
-  it("truncates oversized blocks", () => {
-    const block = formatSlackThreadContextBlock(
-      [
-        {
-          ts: "1.0",
-          user: "U1",
-          text: "x".repeat(500),
-        },
-      ],
-      { maxChars: 120 }
-    );
-    expect(block).toBeDefined();
-    expect(block!.length).toBeLessThanOrEqual(200);
-    expect(block).toContain("truncated");
-    expect(block).toContain("</slack_thread>");
-  });
-});
-
-describe("thread delta helpers", () => {
-  it("finds the latest bot message ts", () => {
-    expect(
-      findLastBotMessageTs([
-        { ts: "1.0", user: "U1", text: "human" },
-        { ts: "1.5", bot_id: "B1", text: "bot a" },
-        { ts: "2.0", user: "U2", text: "human 2" },
-        { ts: "2.5", bot_id: "B1", text: "bot b" },
-      ])
-    ).toBe("2.5");
-  });
-
-  it("restricts watermark to the agent bot when identity is provided", () => {
-    expect(
-      findLastBotMessageTs(
-        [
-          { ts: "1.0", bot_id: "BDD", text: "datadog" },
-          { ts: "1.5", bot_id: "BJENNY", text: "jenny" },
-          { ts: "2.0", user: "U1", text: "human" },
-          { ts: "2.5", bot_id: "BDD", text: "datadog again" },
-        ],
-        { botId: "BJENNY" }
-      )
-    ).toBe("1.5");
-  });
-
-  it("merges missing triggering ask by ts", () => {
-    const merged = mergeThreadMessagesByTs(
-      [{ ts: "1.0", user: "U0", text: "root" }],
-      [{ ts: "2.0", user: "U1", text: "lagging ask" }]
-    );
-    expect(merged.map((m) => m.ts)).toEqual(["1.0", "2.0"]);
-  });
-
-  it("formats slack_thread_delta after watermark", () => {
-    const delta = selectThreadDeltaMessages(
-      [
-        { ts: "1.0", bot_id: "B1", text: "bot" },
-        { ts: "2.0", user: "U1", text: "ask" },
-      ],
-      { afterTs: "1.0", excludeTs: "2.0" }
-    );
-    expect(delta).toHaveLength(0);
-    const block = formatSlackThreadDeltaBlock(
-      [
-        { ts: "1.0", bot_id: "B1", text: "bot" },
-        { ts: "2.0", user: "U1", text: "ask" },
-        { ts: "3.0", user: "U2", text: "more" },
-      ],
-      { afterTs: "1.0", excludeTs: "2.0" }
-    );
-    expect(block).toContain("<slack_thread_delta>");
-    expect(block).toContain("more");
-    expect(block).not.toContain("ask");
-  });
-});
-
-describe("loadSlackThreadContextBlock", () => {
-  it("soft-fails without a bot token", async () => {
-    await expect(
-      loadSlackThreadContextBlock({
-        botToken: undefined,
-        channelId: "C1",
-        threadTs: "1.0",
-      })
-    ).resolves.toBeUndefined();
-  });
-
-  it("calls conversations.replies and formats the result", async () => {
-    const spy = vi.spyOn(slackApi, "callSlackApiSoft").mockResolvedValue({
-      ok: true,
-      messages: [
-        { ts: "1.0", user: "Ubot", text: "alert body" },
-        { ts: "2.0", user: "U1", text: "mention" },
-      ],
-      has_more: false,
-    });
-    const block = await loadSlackThreadContextBlock({
-      botToken: "xoxb-test",
-      channelId: "C1",
-      threadTs: "1.0",
-      excludeTs: "2.0",
-    });
-    expect(spy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        operation: "conversations.replies",
-        body: expect.objectContaining({
-          channel: "C1",
-          ts: "1.0",
-          inclusive: true,
-        }),
-      })
-    );
-    expect(block).toContain("alert body");
-    expect(block).not.toContain("mention");
-    spy.mockRestore();
-  });
-
-  it("soft-fails when Slack returns not-ok", async () => {
-    const spy = vi.spyOn(slackApi, "callSlackApiSoft").mockResolvedValue({
-      ok: false,
-      error: "channel_not_found",
-    });
-    await expect(
-      loadSlackThreadContextBlock({
-        botToken: "xoxb-test",
-        channelId: "C1",
-        threadTs: "1.0",
-      })
-    ).resolves.toBeUndefined();
-    spy.mockRestore();
-  });
-});