whale-code 6.5.10 → 6.6.0

package/dist/node/adapters/__tests__/discord.test.js

@@ -1,284 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// ============================================================================
-// Mock fetch globally
-// ============================================================================
-const mockFetch = vi.fn();
-vi.stubGlobal("fetch", mockFetch);
-
-// Mock WebSocket
-class MockWebSocket {
-  static OPEN = 1;
-  onopen = null;
-  onmessage = null;
-  onclose = null;
-  onerror = null;
-  readyState = 1;
-  sentMessages = [];
-  send(data) {
-    this.sentMessages.push(data);
-  }
-  close(_code, _reason) {
-    // noop
-  }
-
-  // Test helper: simulate receiving a message
-  simulateMessage(data) {
-    if (this.onmessage) {
-      this.onmessage({
-        data: JSON.stringify(data)
-      });
-    }
-  }
-
-  // Test helper: simulate connection open
-  simulateOpen() {
-    if (this.onopen) this.onopen();
-  }
-}
-vi.stubGlobal("WebSocket", MockWebSocket);
-import { DiscordAdapter } from "../discord.js";
-// ============================================================================
-// Setup
-// ============================================================================
-const defaultConfig = {
-  bot_token: "test-bot-token-123"
-};
-let adapter;
-beforeEach(() => {
-  vi.clearAllMocks();
-  adapter = new DiscordAdapter("test-discord", defaultConfig);
-});
-
-// ============================================================================
-// Constructor / Properties
-// ============================================================================
-describe("DiscordAdapter — properties", () => {
-  it("has correct type and name", () => {
-    expect(adapter.type).toBe("discord");
-    expect(adapter.name).toBe("test-discord");
-  });
-  it("starts with zero stats", () => {
-    const stats = adapter.getStats();
-    expect(stats.messages_in).toBe(0);
-    expect(stats.messages_out).toBe(0);
-    expect(stats.errors).toBe(0);
-  });
-  it("is not running initially", () => {
-    expect(adapter.isRunning()).toBe(false);
-  });
-});
-
-// ============================================================================
-// sendMessage
-// ============================================================================
-describe("DiscordAdapter — sendMessage", () => {
-  it("sends a message to a channel", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true
-    });
-    const msg = {
-      id: "msg-1",
-      content: "Hello Discord!",
-      sender_id: "bot",
-      metadata: {
-        channel_id: "123456789"
-      }
-    };
-    const result = await adapter.sendMessage(msg);
-    expect(result).toBe(true);
-    expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining("/channels/123456789/messages"), expect.objectContaining({
-      method: "POST",
-      headers: expect.objectContaining({
-        Authorization: "Bot test-bot-token-123"
-      })
-    }));
-  });
-  it("uses conversation_id as fallback channel", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true
-    });
-    const msg = {
-      id: "msg-1",
-      content: "Fallback",
-      sender_id: "bot",
-      conversation_id: "fallback-channel"
-    };
-    const result = await adapter.sendMessage(msg);
-    expect(result).toBe(true);
-    expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining("/channels/fallback-channel/messages"), expect.any(Object));
-  });
-  it("returns false when no channel_id available", async () => {
-    const msg = {
-      id: "msg-1",
-      content: "No channel",
-      sender_id: "bot"
-    };
-    const result = await adapter.sendMessage(msg);
-    expect(result).toBe(false);
-  });
-  it("splits messages exceeding Discord limit (2000 chars)", async () => {
-    mockFetch.mockResolvedValue({
-      ok: true
-    });
-    const msg = {
-      id: "msg-1",
-      content: "x".repeat(5000),
-      sender_id: "bot",
-      metadata: {
-        channel_id: "123"
-      }
-    };
-    const result = await adapter.sendMessage(msg);
-    expect(result).toBe(true);
-    expect(mockFetch).toHaveBeenCalledTimes(3); // 2000 + 2000 + 1000
-  });
-  it("respects custom max_message_length", async () => {
-    const customAdapter = new DiscordAdapter("custom", {
-      ...defaultConfig,
-      max_message_length: 100
-    });
-    mockFetch.mockResolvedValue({
-      ok: true
-    });
-    const msg = {
-      id: "msg-1",
-      content: "x".repeat(250),
-      sender_id: "bot",
-      metadata: {
-        channel_id: "123"
-      }
-    };
-    await customAdapter.sendMessage(msg);
-    expect(mockFetch).toHaveBeenCalledTimes(3); // 100 + 100 + 50
-  });
-  it("includes message_reference for replies", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true
-    });
-    const msg = {
-      id: "msg-1",
-      content: "Reply",
-      sender_id: "bot",
-      metadata: {
-        channel_id: "123",
-        message_id: "original-msg-456"
-      }
-    };
-    await adapter.sendMessage(msg);
-    const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-    expect(body.message_reference).toEqual({
-      message_id: "original-msg-456"
-    });
-  });
-  it("handles API errors", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 403,
-      text: async () => "Missing permissions"
-    });
-    const msg = {
-      id: "msg-1",
-      content: "Fail",
-      sender_id: "bot",
-      metadata: {
-        channel_id: "123"
-      }
-    };
-    const result = await adapter.sendMessage(msg);
-    expect(result).toBe(false);
-    expect(adapter.getStats().errors).toBe(1);
-  });
-  it("handles fetch exceptions", async () => {
-    mockFetch.mockRejectedValueOnce(new Error("Network down"));
-    const msg = {
-      id: "msg-1",
-      content: "Fail",
-      sender_id: "bot",
-      metadata: {
-        channel_id: "123"
-      }
-    };
-    const result = await adapter.sendMessage(msg);
-    expect(result).toBe(false);
-    expect(adapter.getStats().errors).toBe(1);
-  });
-  it("increments messages_out counter on success", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true
-    });
-    await adapter.sendMessage({
-      id: "msg-1",
-      content: "Hello",
-      sender_id: "bot",
-      metadata: {
-        channel_id: "123"
-      }
-    });
-    expect(adapter.getStats().messages_out).toBe(1);
-    expect(adapter.getStats().last_message_at).toBeDefined();
-  });
-});
-
-// ============================================================================
-// start / stop
-// ============================================================================
-describe("DiscordAdapter — start/stop", () => {
-  it("sets running to true on start", async () => {
-    await adapter.start();
-    expect(adapter.isRunning()).toBe(true);
-  });
-  it("does not start twice", async () => {
-    await adapter.start();
-    await adapter.start(); // Should be a no-op
-    expect(adapter.isRunning()).toBe(true);
-  });
-  it("sets running to false on stop", async () => {
-    await adapter.start();
-    await adapter.stop();
-    expect(adapter.isRunning()).toBe(false);
-  });
-});
-
-// ============================================================================
-// Message handler
-// ============================================================================
-describe("DiscordAdapter — message handler", () => {
-  it("setMessageHandler stores the handler", () => {
-    const handler = vi.fn(async _msg => {});
-    adapter.setMessageHandler(handler);
-    // We can't directly test the private field, but we can verify it was set
-    // by testing message handling indirectly through the adapter
-    expect(handler).not.toHaveBeenCalled();
-  });
-});
-
-// ============================================================================
-// Configuration validation
-// ============================================================================
-describe("DiscordAdapter — configuration", () => {
-  it("stores allowed_channels config", () => {
-    const config = {
-      bot_token: "token",
-      allowed_channels: ["ch-1", "ch-2"]
-    };
-    const a = new DiscordAdapter("filtered", config);
-    expect(a.name).toBe("filtered");
-  });
-  it("stores allowed_guilds config", () => {
-    const config = {
-      bot_token: "token",
-      allowed_guilds: ["guild-1"]
-    };
-    const a = new DiscordAdapter("guild-filtered", config);
-    expect(a.type).toBe("discord");
-  });
-  it("stores mention_required config", () => {
-    const config = {
-      bot_token: "token",
-      mention_required: true
-    };
-    const a = new DiscordAdapter("mention-only", config);
-    expect(a.type).toBe("discord");
-  });
-});

package/dist/node/adapters/__tests__/email-send.test.js

@@ -1,295 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { createHmac } from "node:crypto";
-import { EventEmitter } from "node:events";
-
-// ---------------------------------------------------------------------------
-// Mock node:http
-// ---------------------------------------------------------------------------
-const {
-  mockCreateServer,
-  mockServer
-} = vi.hoisted(() => {
-  const {
-    EventEmitter
-  } = require("node:events");
-  const mockServer = Object.assign(new EventEmitter(), {
-    listen: vi.fn((_port, cb) => {
-      cb?.();
-    }),
-    close: vi.fn(cb => {
-      cb?.();
-    }),
-    address: vi.fn(() => ({
-      port: 3102
-    }))
-  });
-  const mockCreateServer = vi.fn(() => mockServer);
-  return {
-    mockCreateServer,
-    mockServer
-  };
-});
-vi.mock("node:http", () => ({
-  createServer: mockCreateServer
-}));
-
-// Mock global fetch
-const mockFetch = vi.fn();
-vi.stubGlobal("fetch", mockFetch);
-import { EmailAdapter } from "../email.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function defaultConfig(overrides = {}) {
-  return {
-    api_key: "re_test_key",
-    from_address: "bot@example.com",
-    webhook_port: 3102,
-    ...overrides
-  };
-}
-function buildEmailPayload(from, text, subject = "Test Subject") {
-  return JSON.stringify({
-    type: "email.received",
-    data: {
-      id: "email-id-123",
-      from,
-      to: "bot@example.com",
-      subject,
-      text,
-      created_at: "2025-01-01T00:00:00Z",
-      attachments: []
-    }
-  });
-}
-class FakeResponse {
-  statusCode = 200;
-  headers = {};
-  body = "";
-  writeHead(code, headers) {
-    this.statusCode = code;
-    if (headers) this.headers = headers;
-  }
-  end(data) {
-    if (data) this.body = data;
-  }
-}
-function simulateRequest(method, url, body, headers) {
-  const handler = mockCreateServer.mock.calls.at(-1)?.[0];
-  if (!handler) throw new Error("createServer handler not registered");
-  const req = new EventEmitter();
-  req.method = method;
-  req.url = url;
-  req.headers = headers || {};
-  const res = new FakeResponse();
-  handler(req, res);
-  if (body !== undefined) {
-    req.emit("data", Buffer.from(body));
-    req.emit("end");
-  }
-  return {
-    res
-  };
-}
-function makeSignature(body, secret, messageId, timestamp) {
-  const secretBytes = Buffer.from(secret.replace("whsec_", ""), "base64");
-  const signedContent = `${messageId}.${timestamp}.${body}`;
-  const sig = createHmac("sha256", secretBytes).update(signedContent).digest("base64");
-  return `v1,${sig}`;
-}
-
-// ---------------------------------------------------------------------------
-// Tests — webhook signature, sendMessage, server errors, stats
-// ---------------------------------------------------------------------------
-describe("EmailAdapter — send, signature, errors", () => {
-  let adapter;
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.clearAllMocks();
-    mockFetch.mockResolvedValue({
-      ok: true,
-      text: async () => "",
-      json: async () => ({})
-    });
-    adapter = new EmailAdapter("test-email", defaultConfig());
-  });
-  afterEach(async () => {
-    if (adapter.isRunning()) await adapter.stop();
-    vi.useRealTimers();
-  });
-
-  // ====== Webhook signature verification ======
-
-  describe("webhook signature verification", () => {
-    it("rejects POST without signature headers when secret configured", async () => {
-      const a = new EmailAdapter("sig-test", defaultConfig({
-        webhook_secret: "whsec_dGVzdA=="
-      }));
-      await a.start();
-      const {
-        res
-      } = simulateRequest("POST", "/", buildEmailPayload("a@b.com", "hi"));
-      expect(res.statusCode).toBe(401);
-      expect(res.body).toBe("Missing signature headers");
-      await a.stop();
-    });
-    it("rejects POST with invalid signature", async () => {
-      const a = new EmailAdapter("sig-test2", defaultConfig({
-        webhook_secret: "whsec_dGVzdA=="
-      }));
-      await a.start();
-      const body = buildEmailPayload("a@b.com", "hi");
-      const {
-        res
-      } = simulateRequest("POST", "/", body, {
-        "svix-id": "msg-123",
-        "svix-timestamp": "1234567890",
-        "svix-signature": "v1,invalidsignature"
-      });
-      expect(res.statusCode).toBe(401);
-      expect(res.body).toBe("Invalid signature");
-      await a.stop();
-    });
-    it("accepts POST with valid signature", async () => {
-      const secret = "whsec_dGVzdA==";
-      const a = new EmailAdapter("sig-test3", defaultConfig({
-        webhook_secret: secret
-      }));
-      await a.start();
-      const body = buildEmailPayload("a@b.com", "hi");
-      const sig = makeSignature(body, secret, "msg-123", "1234567890");
-      const {
-        res
-      } = simulateRequest("POST", "/", body, {
-        "svix-id": "msg-123",
-        "svix-timestamp": "1234567890",
-        "svix-signature": sig
-      });
-      expect(res.statusCode).toBe(200);
-      await a.stop();
-    });
-  });
-
-  // ====== sendMessage ======
-
-  describe("sendMessage", () => {
-    it("sends email via Resend API and returns true on success", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true
-      });
-      const result = await adapter.sendMessage({
-        id: "msg-1",
-        content: "Reply text",
-        sender_id: "user@test.com",
-        metadata: {
-          from_address: "user@test.com",
-          subject: "Re: Test"
-        }
-      });
-      expect(result).toBe(true);
-      expect(adapter.getStats().messages_out).toBe(1);
-      const [url, opts] = mockFetch.mock.calls[0];
-      expect(url).toContain("/emails");
-      expect(opts.headers.Authorization).toBe("Bearer re_test_key");
-      const body = JSON.parse(opts.body);
-      expect(body.to).toEqual(["user@test.com"]);
-      expect(body.from).toBe("bot@example.com");
-      expect(body.subject).toBe("Re: Test");
-    });
-    it("uses default subject when metadata.subject is absent", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true
-      });
-      await adapter.sendMessage({
-        id: "m2",
-        content: "Hi",
-        sender_id: "a@b.com"
-      });
-      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-      expect(body.subject).toBe("Re: Your message");
-    });
-    it("returns false when API responds non-ok", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: false,
-        status: 400,
-        text: async () => "bad"
-      });
-      const result = await adapter.sendMessage({
-        id: "m3",
-        content: "Hi",
-        sender_id: "a@b.com"
-      });
-      expect(result).toBe(false);
-      expect(adapter.getStats().errors).toBe(1);
-    });
-    it("returns false on network error", async () => {
-      mockFetch.mockRejectedValueOnce(new Error("Network down"));
-      const result = await adapter.sendMessage({
-        id: "m4",
-        content: "Hi",
-        sender_id: "a@b.com"
-      });
-      expect(result).toBe(false);
-      expect(adapter.getStats().errors).toBe(1);
-    });
-    it("returns false when no recipient available", async () => {
-      const result = await adapter.sendMessage({
-        id: "m5",
-        content: "Hi",
-        sender_id: ""
-      });
-      expect(result).toBe(false);
-    });
-    it("uses sender_id as fallback for recipient", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true
-      });
-      await adapter.sendMessage({
-        id: "m6",
-        content: "Hi",
-        sender_id: "fallback@x.com"
-      });
-      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-      expect(body.to).toEqual(["fallback@x.com"]);
-    });
-  });
-
-  // ====== Server error handling ======
-
-  describe("server error handling", () => {
-    it("increments errors on server error event", async () => {
-      await adapter.start();
-      mockServer.emit("error", new Error("EADDRINUSE"));
-      expect(adapter.getStats().errors).toBe(1);
-    });
-    it("schedules restart after server error while running", async () => {
-      await adapter.start();
-      mockServer.emit("error", new Error("EADDRINUSE"));
-      vi.advanceTimersByTime(2000);
-      expect(mockCreateServer).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  // ====== Stats ======
-
-  describe("stats tracking", () => {
-    it("getStats returns a copy", () => {
-      const s1 = adapter.getStats();
-      const s2 = adapter.getStats();
-      expect(s1).not.toBe(s2);
-      expect(s1).toEqual(s2);
-    });
-    it("tracks last_message_at on successful send", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true
-      });
-      await adapter.sendMessage({
-        id: "m",
-        content: "hi",
-        sender_id: "a@b.com"
-      });
-      expect(adapter.getStats().last_message_at).toBeDefined();
-    });
-  });
-});