@copilotkit/channels-slack 0.1.0

package/dist/__tests__/download-files.test.d.ts.map

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

package/dist/__tests__/download-files.test.js

@@ -0,0 +1,142 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { buildFileContentParts } from "../download-files.js";
+function fakeFetch(bodyByUrl) {
+    return vi.fn(async (url) => {
+        const e = bodyByUrl[url];
+        if (!e)
+            return { ok: false, status: 404 };
+        return {
+            ok: e.ok ?? true,
+            status: e.status ?? 200,
+            arrayBuffer: async () => (e.bytes ?? Buffer.from("")).buffer.slice((e.bytes ?? Buffer.from("")).byteOffset, (e.bytes ?? Buffer.from("")).byteOffset +
+                (e.bytes ?? Buffer.from("")).byteLength),
+        };
+    });
+}
+afterEach(() => vi.unstubAllGlobals());
+const img = {
+    name: "shot.png",
+    mimetype: "image/png",
+    url_private: "https://files.slack.com/shot.png",
+};
+const csv = {
+    name: "data.csv",
+    mimetype: "text/csv",
+    url_private: "https://files.slack.com/data.csv",
+};
+describe("buildFileContentParts", () => {
+    it("turns an image into a base64 image part", async () => {
+        const bytes = Buffer.from([1, 2, 3, 4]);
+        vi.stubGlobal("fetch", fakeFetch({ [img.url_private]: { bytes } }));
+        const { parts, notes } = await buildFileContentParts([img], "xoxb-tok");
+        expect(notes).toEqual([]);
+        expect(parts).toHaveLength(1);
+        expect(parts[0]).toMatchObject({
+            type: "image",
+            source: {
+                type: "data",
+                mimeType: "image/png",
+                value: bytes.toString("base64"),
+            },
+        });
+    });
+    it("decodes a text/csv file into a text part", async () => {
+        const bytes = Buffer.from("a,b\n1,2\n", "utf8");
+        vi.stubGlobal("fetch", fakeFetch({ [csv.url_private]: { bytes } }));
+        const { parts } = await buildFileContentParts([csv], "tok");
+        expect(parts[0]?.type).toBe("text");
+        expect(parts[0].text).toContain("data.csv");
+        expect(parts[0].text).toContain("a,b");
+    });
+    it("truncates large text files", async () => {
+        const bytes = Buffer.from("x".repeat(5000), "utf8");
+        vi.stubGlobal("fetch", fakeFetch({ [csv.url_private]: { bytes } }));
+        const { parts } = await buildFileContentParts([csv], "tok", {
+            maxTextBytes: 100,
+        });
+        const text = parts[0].text;
+        expect(text).toContain("truncated");
+        expect(text.length).toBeLessThan(400);
+    });
+    it("turns a PDF into a document part", async () => {
+        const bytes = Buffer.from("%PDF-1.7 ...", "utf8");
+        const pdf = {
+            name: "report.pdf",
+            mimetype: "application/pdf",
+            url_private: "https://files.slack.com/report.pdf",
+        };
+        vi.stubGlobal("fetch", fakeFetch({ [pdf.url_private]: { bytes } }));
+        const { parts, notes } = await buildFileContentParts([pdf], "tok");
+        expect(notes).toEqual([]);
+        expect(parts[0]).toMatchObject({
+            type: "document",
+            source: {
+                type: "data",
+                mimeType: "application/pdf",
+                value: bytes.toString("base64"),
+            },
+        });
+    });
+    it.each([
+        { name: "memo.mp3", mimetype: "audio/mpeg", expected: "audio" },
+        { name: "clip.mp4", mimetype: "video/mp4", expected: "video" },
+    ])("passes $mimetype through as a $expected part", async ({ name, mimetype, expected }) => {
+        const bytes = Buffer.from([9, 8, 7, 6]);
+        const file = {
+            name,
+            mimetype,
+            url_private: `https://files.slack.com/${name}`,
+        };
+        vi.stubGlobal("fetch", fakeFetch({ [file.url_private]: { bytes } }));
+        const { parts, notes } = await buildFileContentParts([file], "tok");
+        expect(notes).toEqual([]);
+        expect(parts[0]).toMatchObject({
+            type: expected,
+            source: {
+                type: "data",
+                mimeType: mimetype,
+                value: bytes.toString("base64"),
+            },
+        });
+    });
+    it("skips genuinely unsupported types with a note", async () => {
+        const zip = {
+            name: "a.zip",
+            mimetype: "application/zip",
+            url_private: "u",
+        };
+        vi.stubGlobal("fetch", fakeFetch({}));
+        const { parts, notes } = await buildFileContentParts([zip], "tok");
+        expect(parts).toEqual([]);
+        expect(notes[0]).toContain("unsupported");
+    });
+    it("skips files over the size cap (by reported size) without downloading", async () => {
+        const big = { ...img, size: 99_999_999 };
+        const fetchSpy = fakeFetch({});
+        vi.stubGlobal("fetch", fetchSpy);
+        const { parts, notes } = await buildFileContentParts([big], "tok", {
+            maxBytesPerFile: 10,
+        });
+        expect(parts).toEqual([]);
+        expect(notes[0]).toContain("exceeds");
+        expect(fetchSpy).not.toHaveBeenCalled();
+    });
+    it("skips on a failed download with a note", async () => {
+        vi.stubGlobal("fetch", fakeFetch({ [img.url_private]: { ok: false, status: 403 } }));
+        const { parts, notes } = await buildFileContentParts([img], "tok");
+        expect(parts).toEqual([]);
+        expect(notes[0]).toContain("403");
+    });
+    it("caps the number of files processed", async () => {
+        const files = Array.from({ length: 8 }, (_, i) => ({
+            ...csv,
+            url_private: `u${i}`,
+        }));
+        vi.stubGlobal("fetch", fakeFetch(Object.fromEntries(files.map((f) => [f.url_private, { bytes: Buffer.from("x") }]))));
+        const { parts, notes } = await buildFileContentParts(files, "tok", {
+            maxFiles: 3,
+        });
+        expect(parts).toHaveLength(3);
+        expect(notes.some((n) => n.includes("first 3 of 8"))).toBe(true);
+    });
+});

package/dist/__tests__/ephemeral.test.d.ts

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

package/dist/__tests__/ephemeral.test.d.ts.map

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

package/dist/__tests__/ephemeral.test.js

@@ -0,0 +1,85 @@
+import { describe, it, expect, vi } from "vitest";
+import { SlackAdapter } from "../adapter.js";
+describe("SlackAdapter.postEphemeral", () => {
+    it("posts a native ephemeral message (usedFallback=false)", async () => {
+        const adapter = new SlackAdapter({
+            botToken: "xoxb",
+            appToken: "xapp",
+            signingSecret: "s",
+        });
+        const postEphemeral = vi
+            .fn()
+            .mockResolvedValue({ ok: true, message_ts: "5.5" });
+        // @ts-expect-error inject stub
+        adapter.client = { chat: { postEphemeral } };
+        const ir = [{ type: "text", props: { value: "hi" } }];
+        const res = await adapter.postEphemeral({ channel: "C1", threadTs: "1.0" }, { id: "U1" }, ir, { fallbackToDM: false });
+        expect(res).toMatchObject({ ok: true, usedFallback: false });
+        expect(postEphemeral).toHaveBeenCalledWith(expect.objectContaining({ channel: "C1", user: "U1", thread_ts: "1.0" }));
+    });
+    it("accepts a string user id", async () => {
+        const adapter = new SlackAdapter({
+            botToken: "xoxb",
+            appToken: "xapp",
+            signingSecret: "s",
+        });
+        const postEphemeral = vi
+            .fn()
+            .mockResolvedValue({ ok: true, message_ts: "6.0" });
+        // @ts-expect-error inject stub
+        adapter.client = { chat: { postEphemeral } };
+        const res = await adapter.postEphemeral({ channel: "C2" }, "U2", [], {
+            fallbackToDM: false,
+        });
+        expect(res).toMatchObject({ ok: true, usedFallback: false });
+        expect(postEphemeral).toHaveBeenCalledWith(expect.objectContaining({ channel: "C2", user: "U2" }));
+        // No thread_ts when target has none.
+        const args = postEphemeral.mock.calls[0][0];
+        expect(args["thread_ts"]).toBeUndefined();
+    });
+    it("omits thread_ts when target has none", async () => {
+        const adapter = new SlackAdapter({
+            botToken: "xoxb",
+            appToken: "xapp",
+            signingSecret: "s",
+        });
+        const postEphemeral = vi
+            .fn()
+            .mockResolvedValue({ ok: true, message_ts: "7.0" });
+        // @ts-expect-error inject stub
+        adapter.client = { chat: { postEphemeral } };
+        await adapter.postEphemeral({ channel: "C3" }, { id: "U3" }, [], {
+            fallbackToDM: false,
+        });
+        const args = postEphemeral.mock.calls[0][0];
+        expect(args["thread_ts"]).toBeUndefined();
+    });
+    it("ignores fallbackToDM and always posts natively (usedFallback always false)", async () => {
+        const adapter = new SlackAdapter({
+            botToken: "xoxb",
+            appToken: "xapp",
+            signingSecret: "s",
+        });
+        const postEphemeral = vi
+            .fn()
+            .mockResolvedValue({ ok: true, message_ts: "8.0" });
+        // @ts-expect-error inject stub
+        adapter.client = { chat: { postEphemeral } };
+        const res = await adapter.postEphemeral({ channel: "C4" }, { id: "U4" }, [], { fallbackToDM: true });
+        expect(res).toMatchObject({ ok: true, usedFallback: false });
+    });
+    it("returns { ok: false, error } when the Slack API throws", async () => {
+        const adapter = new SlackAdapter({
+            botToken: "xoxb",
+            appToken: "xapp",
+            signingSecret: "s",
+        });
+        const postEphemeral = vi
+            .fn()
+            .mockRejectedValue(new Error("channel_not_found"));
+        // @ts-expect-error inject stub
+        adapter.client = { chat: { postEphemeral } };
+        const res = await adapter.postEphemeral({ channel: "C5" }, { id: "U5" }, [], { fallbackToDM: false });
+        expect(res).toEqual({ ok: false, error: "channel_not_found" });
+    });
+});

package/dist/__tests__/event-renderer.test.d.ts

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

package/dist/__tests__/event-renderer.test.d.ts.map

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