@copilotkit/channels-slack 0.1.0

package/dist/__tests__/reactions.test.js

@@ -0,0 +1,193 @@
+import { describe, it, expect, vi } from "vitest";
+import { decodeReaction } from "../interaction.js";
+describe("decodeReaction", () => {
+    it("maps a reaction_added event to an IncomingReaction", () => {
+        const evt = decodeReaction({
+            user: "U1",
+            reaction: "thumbsup",
+            item: { type: "message", channel: "C9", ts: "171.1" },
+        }, true);
+        expect(evt).toMatchObject({
+            rawEmoji: "thumbsup",
+            added: true,
+            user: { id: "U1" },
+            messageId: "171.1",
+            replyTarget: { channel: "C9" },
+        });
+        expect(evt.conversationKey).toBe("C9::171.1");
+    });
+    it("uses DM_SCOPE for direct-message channels", () => {
+        const evt = decodeReaction({
+            user: "U1",
+            reaction: "x",
+            item: { type: "message", channel: "D2", ts: "9.9" },
+        }, false);
+        expect(evt.added).toBe(false);
+        expect(evt.conversationKey).toBe("D2::dm");
+    });
+    it("threads the reply target under the reacted message in a channel", () => {
+        const evt = decodeReaction({
+            user: "U1",
+            reaction: "thumbsup",
+            item: { type: "message", channel: "C9", ts: "171.1" },
+        }, true);
+        expect(evt.replyTarget.threadTs).toBe("171.1");
+    });
+    it("carries the reactor id as recipientUserId on a channel reply target", () => {
+        // chat.startStream requires recipient_user_id when streaming to a channel.
+        // The reaction reply target must carry it (parity with onTurn) so a native
+        // channel stream started from a reaction does not fail and process-wide
+        // downgrade nativeStreamingOk.
+        const evt = decodeReaction({
+            user: "U1",
+            reaction: "thumbsup",
+            item: { type: "message", channel: "C9", ts: "171.1" },
+        }, true);
+        expect(evt.replyTarget.recipientUserId).toBe("U1");
+    });
+    it("keeps the reply target flat (no threadTs) for a DM reaction", () => {
+        const evt = decodeReaction({
+            user: "U1",
+            reaction: "x",
+            item: { type: "message", channel: "D2", ts: "9.9" },
+        }, false);
+        expect(evt.replyTarget.threadTs).toBeUndefined();
+    });
+    it("ignores non-message reaction items", () => {
+        expect(decodeReaction({ user: "U1", reaction: "x", item: { type: "file", file: "F1" } }, true)).toBeUndefined();
+    });
+});
+const BOT_USER_ID = "UBOT0001";
+/**
+ * A permissive fake Bolt app that records the `reaction_added`/`reaction_removed`
+ * handlers registered during `start()` and no-ops every other registration
+ * (message/event/action/view/command) the adapter and its sub-listeners attach.
+ */
+function makeFakeApp() {
+    const handlers = {};
+    const app = {
+        init: vi.fn().mockResolvedValue(undefined),
+        start: vi.fn().mockResolvedValue(undefined),
+        stop: vi.fn().mockResolvedValue(undefined),
+        event(name, handler) {
+            handlers[name] = handler;
+        },
+        message() { },
+        action() { },
+        view() { },
+        command() { },
+        assistant() { },
+        use() { },
+    };
+    return {
+        app,
+        fireReaction: (name, event) => handlers[name]?.({ event }),
+    };
+}
+function makeSink() {
+    return {
+        onTurn: vi.fn().mockResolvedValue(undefined),
+        onCommand: vi.fn().mockResolvedValue(undefined),
+        onInteraction: vi.fn().mockResolvedValue(undefined),
+        onReaction: vi.fn().mockResolvedValue(undefined),
+        onModalSubmit: vi.fn().mockResolvedValue(undefined),
+        onModalClose: vi.fn().mockResolvedValue(undefined),
+    };
+}
+describe("adapter reaction ingress loop guard", () => {
+    async function startWithFakes() {
+        const { SlackAdapter } = await import("../adapter.js");
+        // Disable the assistant middleware so start() takes the simplest listener path.
+        const adapter = new SlackAdapter({
+            botToken: "xoxb",
+            appToken: "xapp",
+            signingSecret: "s",
+            assistant: false,
+        });
+        const { app, fireReaction } = makeFakeApp();
+        adapter.app = app;
+        const usersInfo = vi.fn().mockResolvedValue({
+            user: {
+                id: "UHUMAN",
+                name: "humanuser",
+                real_name: "Human User",
+                profile: { email: "human@example.com" },
+            },
+        });
+        adapter.client = {
+            auth: {
+                test: vi
+                    .fn()
+                    .mockResolvedValue({ user_id: BOT_USER_ID, team_id: "T1" }),
+            },
+            users: { info: usersInfo },
+        };
+        const sink = makeSink();
+        await adapter.start(sink);
+        return { fireReaction, sink, usersInfo };
+    }
+    it("does NOT dispatch the bot's OWN reaction to sink.onReaction", async () => {
+        const { fireReaction, sink } = await startWithFakes();
+        await fireReaction("reaction_added", {
+            user: BOT_USER_ID,
+            reaction: "thumbsup",
+            item: { type: "message", channel: "C9", ts: "171.1" },
+        });
+        expect(sink.onReaction).not.toHaveBeenCalled();
+    });
+    it("DOES dispatch a normal user's reaction to sink.onReaction", async () => {
+        const { fireReaction, sink } = await startWithFakes();
+        await fireReaction("reaction_added", {
+            user: "UHUMAN",
+            reaction: "thumbsup",
+            item: { type: "message", channel: "C9", ts: "171.1" },
+        });
+        expect(sink.onReaction).toHaveBeenCalledTimes(1);
+    });
+    it("enriches the reaction user via resolveUser (name + email), not a bare {id}", async () => {
+        const { fireReaction, sink, usersInfo } = await startWithFakes();
+        await fireReaction("reaction_added", {
+            user: "UHUMAN",
+            reaction: "thumbsup",
+            item: { type: "message", channel: "C9", ts: "171.1" },
+        });
+        expect(usersInfo).toHaveBeenCalledWith({ user: "UHUMAN" });
+        const evt = sink.onReaction.mock.calls[0]?.[0];
+        expect(evt.user).toEqual({
+            id: "UHUMAN",
+            name: "Human User",
+            email: "human@example.com",
+        });
+    });
+    it("enriches the reaction user on reaction_removed too", async () => {
+        const { fireReaction, sink } = await startWithFakes();
+        await fireReaction("reaction_removed", {
+            user: "UHUMAN",
+            reaction: "thumbsup",
+            item: { type: "message", channel: "C9", ts: "171.1" },
+        });
+        const evt = sink.onReaction.mock.calls[0]?.[0];
+        expect(evt.user).toMatchObject({ name: "Human User" });
+    });
+});
+describe("adapter reaction egress", () => {
+    it("calls reactions.add with the resolved Slack shortcode", async () => {
+        const { SlackAdapter } = await import("../adapter.js");
+        const adapter = new SlackAdapter({
+            botToken: "xoxb",
+            appToken: "xapp",
+            signingSecret: "s",
+        });
+        const add = vi.fn().mockResolvedValue({ ok: true });
+        adapter.client = {
+            reactions: { add, remove: vi.fn().mockResolvedValue({ ok: true }) },
+        };
+        const res = await adapter.addReaction({ channel: "C1" }, { id: "1.2", channel: "C1" }, "thumbs_up");
+        expect(res).toEqual({ ok: true });
+        expect(add).toHaveBeenCalledWith({
+            channel: "C1",
+            timestamp: "1.2",
+            name: "+1",
+        });
+    });
+});

package/dist/__tests__/slack-listener.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=slack-listener.test.d.ts.map

package/dist/__tests__/slack-listener.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-listener.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/slack-listener.test.ts"],"names":[],"mappings":""}