whale-code 6.5.11 → 6.6.0

package/dist/node/adapters/__tests__/slack.part2.test.js

@@ -1,135 +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) {}
-  simulateMessage(data) {
-    if (this.onmessage) {
-      this.onmessage({
-        data: JSON.stringify(data)
-      });
-    }
-  }
-  simulateOpen() {
-    if (this.onopen) this.onopen();
-  }
-}
-vi.stubGlobal("WebSocket", MockWebSocket);
-import { SlackAdapter } from "../slack.js";
-// ============================================================================
-// Setup
-// ============================================================================
-
-const defaultConfig = {
-  bot_token: "xoxb-test-token-123",
-  app_token: "xapp-test-app-token-456"
-};
-let adapter;
-beforeEach(() => {
-  vi.clearAllMocks();
-  adapter = new SlackAdapter("test-slack", defaultConfig);
-});
-
-// ============================================================================
-// start / stop
-// ============================================================================
-
-describe("SlackAdapter — start/stop", () => {
-  beforeEach(() => {
-    // Mock auth.test
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        ok: true,
-        user_id: "U-BOT-123",
-        user: "testbot"
-      })
-    });
-
-    // Mock apps.connections.open
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        ok: true,
-        url: "wss://wss-primary.slack.com/link/xxx"
-      })
-    });
-  });
-  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);
-  });
-  it("fetches bot identity on start", async () => {
-    await adapter.start();
-    expect(mockFetch).toHaveBeenCalledWith("https://slack.com/api/auth.test", expect.objectContaining({
-      method: "POST",
-      headers: expect.objectContaining({
-        Authorization: "Bearer xoxb-test-token-123"
-      })
-    }));
-  });
-});
-
-// ============================================================================
-// Message handler
-// ============================================================================
-
-describe("SlackAdapter — message handler", () => {
-  it("setMessageHandler stores the handler", () => {
-    const handler = vi.fn(async _msg => {});
-    adapter.setMessageHandler(handler);
-    expect(handler).not.toHaveBeenCalled();
-  });
-});
-
-// ============================================================================
-// Configuration
-// ============================================================================
-
-describe("SlackAdapter — configuration", () => {
-  it("stores allowed_channels config", () => {
-    const config = {
-      bot_token: "xoxb-token",
-      app_token: "xapp-token",
-      allowed_channels: ["C1", "C2"]
-    };
-    const a = new SlackAdapter("filtered", config);
-    expect(a.name).toBe("filtered");
-  });
-  it("stores mention_required config", () => {
-    const config = {
-      bot_token: "xoxb-token",
-      app_token: "xapp-token",
-      mention_required: true
-    };
-    const a = new SlackAdapter("mention-only", config);
-    expect(a.type).toBe("slack");
-  });
-});

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

@@ -1,241 +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) {}
-  simulateMessage(data) {
-    if (this.onmessage) {
-      this.onmessage({
-        data: JSON.stringify(data)
-      });
-    }
-  }
-  simulateOpen() {
-    if (this.onopen) this.onopen();
-  }
-}
-vi.stubGlobal("WebSocket", MockWebSocket);
-import { SlackAdapter } from "../slack.js";
-// ============================================================================
-// Setup
-// ============================================================================
-
-const defaultConfig = {
-  bot_token: "xoxb-test-token-123",
-  app_token: "xapp-test-app-token-456"
-};
-let adapter;
-beforeEach(() => {
-  vi.clearAllMocks();
-  adapter = new SlackAdapter("test-slack", defaultConfig);
-});
-
-// ============================================================================
-// Constructor / Properties
-// ============================================================================
-
-describe("SlackAdapter — properties", () => {
-  it("has correct type and name", () => {
-    expect(adapter.type).toBe("slack");
-    expect(adapter.name).toBe("test-slack");
-  });
-  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("SlackAdapter — sendMessage", () => {
-  it("sends a message via chat.postMessage API", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        ok: true
-      })
-    });
-    const msg = {
-      id: "msg-1",
-      content: "Hello Slack!",
-      sender_id: "bot",
-      metadata: {
-        channel_id: "C123456"
-      }
-    };
-    const result = await adapter.sendMessage(msg);
-    expect(result).toBe(true);
-    expect(mockFetch).toHaveBeenCalledWith("https://slack.com/api/chat.postMessage", expect.objectContaining({
-      method: "POST",
-      headers: expect.objectContaining({
-        Authorization: "Bearer xoxb-test-token-123"
-      })
-    }));
-    const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-    expect(body.channel).toBe("C123456");
-    expect(body.text).toBe("Hello Slack!");
-  });
-  it("uses conversation_id as fallback channel", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        ok: true
-      })
-    });
-    const msg = {
-      id: "msg-1",
-      content: "Fallback",
-      sender_id: "bot",
-      conversation_id: "C-fallback"
-    };
-    const result = await adapter.sendMessage(msg);
-    expect(result).toBe(true);
-    const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-    expect(body.channel).toBe("C-fallback");
-  });
-  it("returns false when no channel_id", async () => {
-    const msg = {
-      id: "msg-1",
-      content: "No channel",
-      sender_id: "bot"
-    };
-    const result = await adapter.sendMessage(msg);
-    expect(result).toBe(false);
-  });
-  it("includes thread_ts for threaded replies", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        ok: true
-      })
-    });
-    const msg = {
-      id: "msg-1",
-      content: "Thread reply",
-      sender_id: "bot",
-      metadata: {
-        channel_id: "C123",
-        thread_ts: "1234567890.123456"
-      }
-    };
-    await adapter.sendMessage(msg);
-    const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-    expect(body.thread_ts).toBe("1234567890.123456");
-  });
-  it("splits long messages", async () => {
-    mockFetch.mockResolvedValue({
-      ok: true,
-      json: async () => ({
-        ok: true
-      })
-    });
-    const msg = {
-      id: "msg-1",
-      content: "x".repeat(10000),
-      sender_id: "bot",
-      metadata: {
-        channel_id: "C123"
-      }
-    };
-    await adapter.sendMessage(msg);
-    expect(mockFetch).toHaveBeenCalledTimes(3); // 4000 + 4000 + 2000
-  });
-  it("respects custom max_message_length", async () => {
-    const customAdapter = new SlackAdapter("custom", {
-      ...defaultConfig,
-      max_message_length: 500
-    });
-    mockFetch.mockResolvedValue({
-      ok: true,
-      json: async () => ({
-        ok: true
-      })
-    });
-    const msg = {
-      id: "msg-1",
-      content: "x".repeat(1200),
-      sender_id: "bot",
-      metadata: {
-        channel_id: "C123"
-      }
-    };
-    await customAdapter.sendMessage(msg);
-    expect(mockFetch).toHaveBeenCalledTimes(3); // 500 + 500 + 200
-  });
-  it("handles Slack API errors (ok: false)", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        ok: false,
-        error: "channel_not_found"
-      })
-    });
-    const msg = {
-      id: "msg-1",
-      content: "Fail",
-      sender_id: "bot",
-      metadata: {
-        channel_id: "C-bad"
-      }
-    };
-    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: "C123"
-      }
-    };
-    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,
-      json: async () => ({
-        ok: true
-      })
-    });
-    await adapter.sendMessage({
-      id: "msg-1",
-      content: "Hello",
-      sender_id: "bot",
-      metadata: {
-        channel_id: "C123"
-      }
-    });
-    expect(adapter.getStats().messages_out).toBe(1);
-    expect(adapter.getStats().last_message_at).toBeDefined();
-  });
-});

package/dist/node/adapters/__tests__/sms-extras.test.js

@@ -1,108 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-// ---------------------------------------------------------------------------
-// Mock node:http (duplicated from sms.test.ts)
-// ---------------------------------------------------------------------------
-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: 3101
-    }))
-  });
-  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 { SmsAdapter } from "../sms.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function defaultConfig(overrides = {}) {
-  return {
-    account_sid: "AC_test_sid",
-    auth_token: "test_auth_token",
-    from_number: "+15550001111",
-    webhook_port: 3101,
-    ...overrides
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests — server error handling & stats
-// ---------------------------------------------------------------------------
-describe("SmsAdapter — server errors & stats", () => {
-  let adapter;
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.clearAllMocks();
-    mockFetch.mockResolvedValue({
-      ok: true,
-      text: async () => "",
-      json: async () => ({})
-    });
-    adapter = new SmsAdapter("test-sms", defaultConfig());
-  });
-  afterEach(async () => {
-    if (adapter.isRunning()) await adapter.stop();
-    vi.useRealTimers();
-  });
-
-  // ====== 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", () => {
-    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: "+1"
-      });
-      expect(adapter.getStats().last_message_at).toBeDefined();
-    });
-  });
-});

package/dist/node/adapters/__tests__/sms-lifecycle.test.js

@@ -1,203 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-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: 3101
-    }))
-  });
-  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 { SmsAdapter } from "../sms.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function defaultConfig(overrides = {}) {
-  return {
-    account_sid: "AC_test_sid",
-    auth_token: "test_auth_token",
-    from_number: "+15550001111",
-    webhook_port: 3101,
-    ...overrides
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests — constructor, start/stop, GET health check
-// ---------------------------------------------------------------------------
-describe("SmsAdapter — lifecycle", () => {
-  let adapter;
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.clearAllMocks();
-    mockFetch.mockResolvedValue({
-      ok: true,
-      text: async () => "",
-      json: async () => ({})
-    });
-    adapter = new SmsAdapter("test-sms", defaultConfig());
-  });
-  afterEach(async () => {
-    if (adapter.isRunning()) await adapter.stop();
-    vi.useRealTimers();
-  });
-
-  // ====== Construction ======
-
-  describe("constructor", () => {
-    it("sets type to sms", () => {
-      expect(adapter.type).toBe("sms");
-    });
-    it("sets the name from constructor arg", () => {
-      expect(adapter.name).toBe("test-sms");
-    });
-    it("starts with zero stats", () => {
-      const s = adapter.getStats();
-      expect(s.messages_in).toBe(0);
-      expect(s.messages_out).toBe(0);
-      expect(s.errors).toBe(0);
-    });
-    it("is not running before start()", () => {
-      expect(adapter.isRunning()).toBe(false);
-    });
-  });
-
-  // ====== Lifecycle ======
-
-  describe("start / stop", () => {
-    it("start() creates an HTTP server and marks running", async () => {
-      await adapter.start();
-      expect(adapter.isRunning()).toBe(true);
-      expect(mockCreateServer).toHaveBeenCalled();
-      expect(mockServer.listen).toHaveBeenCalledWith(3101, expect.any(Function));
-    });
-    it("start() is idempotent", async () => {
-      await adapter.start();
-      await adapter.start();
-      expect(mockCreateServer).toHaveBeenCalledTimes(1);
-    });
-    it("stop() closes server and marks not running", async () => {
-      await adapter.start();
-      await adapter.stop();
-      expect(adapter.isRunning()).toBe(false);
-      expect(mockServer.close).toHaveBeenCalled();
-    });
-    it("stop() when not started does not throw", async () => {
-      await expect(adapter.stop()).resolves.not.toThrow();
-    });
-    it("uses default port 3101 when not specified", async () => {
-      const a = new SmsAdapter("s2", defaultConfig({
-        webhook_port: undefined
-      }));
-      await a.start();
-      expect(mockServer.listen).toHaveBeenCalledWith(3101, expect.any(Function));
-      await a.stop();
-    });
-    it("uses custom port when specified", async () => {
-      const a = new SmsAdapter("s3", defaultConfig({
-        webhook_port: 7777
-      }));
-      await a.start();
-      expect(mockServer.listen).toHaveBeenCalledWith(7777, expect.any(Function));
-      await a.stop();
-    });
-  });
-
-  // ====== GET requests (health check) ======
-
-  describe("GET request (health check)", () => {
-    it("responds 200 with running message", async () => {
-      await adapter.start();
-      const handler = mockCreateServer.mock.calls.at(-1)?.[0];
-      if (!handler) throw new Error("createServer handler not registered");
-      const req = new EventEmitter();
-      req.method = "GET";
-      req.url = "/";
-      req.headers = {};
-      class FakeResponse {
-        statusCode = 200;
-        headers = {};
-        body = "";
-        writeHead(code, headers) {
-          this.statusCode = code;
-          if (headers) this.headers = headers;
-        }
-        end(data) {
-          if (data) this.body = data;
-        }
-      }
-      const res = new FakeResponse();
-      handler(req, res);
-      req.emit("data", Buffer.from(""));
-      req.emit("end");
-      expect(res.statusCode).toBe(200);
-      expect(res.body).toContain("SMS adapter running");
-    });
-  });
-
-  // ====== 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", () => {
-    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: "+1"
-      });
-      expect(adapter.getStats().last_message_at).toBeDefined();
-    });
-  });
-});