whale-code 6.5.11 → 6.6.0

package/dist/node/adapters/__tests__/telegram-polling.test.js

@@ -1,256 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-
-// Mock global fetch
-const mockFetch = vi.fn();
-vi.stubGlobal("fetch", mockFetch);
-import { TelegramAdapter } from "../telegram.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function defaultConfig(overrides = {}) {
-  return {
-    bot_token: "123456:ABC-DEF",
-    allowed_chats: undefined,
-    ...overrides
-  };
-}
-function buildPollResponse(updates = []) {
-  return {
-    ok: true,
-    json: async () => ({
-      ok: true,
-      result: updates
-    })
-  };
-}
-function makeUpdate(updateId, chatId, text, from) {
-  return {
-    update_id: updateId,
-    message: {
-      message_id: updateId * 10,
-      chat: {
-        id: chatId,
-        type: "private"
-      },
-      from: from || {
-        id: 999,
-        first_name: "TestUser"
-      },
-      text
-    }
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe("TelegramAdapter — polling", () => {
-  let adapter;
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.clearAllMocks();
-    mockFetch.mockResolvedValue(buildPollResponse([]));
-    adapter = new TelegramAdapter("test-tg", defaultConfig());
-  });
-  afterEach(async () => {
-    if (adapter.isRunning()) await adapter.stop();
-    vi.useRealTimers();
-  });
-
-  // ====== Construction ======
-
-  describe("constructor", () => {
-    it("sets type to telegram", () => {
-      expect(adapter.type).toBe("telegram");
-    });
-    it("sets the name from constructor arg", () => {
-      expect(adapter.name).toBe("test-tg");
-    });
-    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() marks running and begins polling", async () => {
-      await adapter.start();
-      expect(adapter.isRunning()).toBe(true);
-      expect(mockFetch).toHaveBeenCalled();
-      const url = mockFetch.mock.calls[0][0];
-      expect(url).toContain("getUpdates");
-      expect(url).toContain("123456:ABC-DEF");
-    });
-    it("start() is idempotent", async () => {
-      await adapter.start();
-      const callCount = mockFetch.mock.calls.length;
-      await adapter.start();
-      expect(mockFetch.mock.calls.length).toBe(callCount);
-    });
-    it("stop() marks not running and clears poll timer", async () => {
-      await adapter.start();
-      await adapter.stop();
-      expect(adapter.isRunning()).toBe(false);
-    });
-    it("stop() when not started does not throw", async () => {
-      await expect(adapter.stop()).resolves.not.toThrow();
-    });
-  });
-
-  // ====== Polling / inbound messages ======
-
-  describe("polling for messages", () => {
-    it("processes incoming text messages and calls handler", async () => {
-      const handler = vi.fn().mockResolvedValue(undefined);
-      adapter.setMessageHandler(handler);
-      mockFetch.mockResolvedValueOnce(buildPollResponse([makeUpdate(1, 100, "Hello Telegram", {
-        id: 42,
-        first_name: "Alice",
-        last_name: "Smith"
-      })]));
-      await adapter.start();
-      await vi.advanceTimersByTimeAsync(0);
-      expect(handler).toHaveBeenCalledTimes(1);
-      const msg = handler.mock.calls[0][0];
-      expect(msg.sender_id).toBe("42");
-      expect(msg.sender_name).toBe("Alice Smith");
-      expect(msg.content).toBe("Hello Telegram");
-      expect(msg.metadata?.chat_id).toBe(100);
-      expect(msg.metadata?.chat_type).toBe("private");
-      expect(msg.metadata?.message_id).toBe(10);
-    });
-    it("increments messages_in on valid messages", async () => {
-      const handler = vi.fn().mockResolvedValue(undefined);
-      adapter.setMessageHandler(handler);
-      mockFetch.mockResolvedValueOnce(buildPollResponse([makeUpdate(1, 100, "Hi")]));
-      await adapter.start();
-      await vi.advanceTimersByTimeAsync(0);
-      expect(adapter.getStats().messages_in).toBe(1);
-    });
-    it("processes multiple updates in a single poll", async () => {
-      const handler = vi.fn().mockResolvedValue(undefined);
-      adapter.setMessageHandler(handler);
-      mockFetch.mockResolvedValueOnce(buildPollResponse([makeUpdate(1, 100, "First"), makeUpdate(2, 100, "Second"), makeUpdate(3, 100, "Third")]));
-      await adapter.start();
-      await vi.advanceTimersByTimeAsync(0);
-      expect(handler).toHaveBeenCalledTimes(3);
-      expect(adapter.getStats().messages_in).toBe(3);
-    });
-    it("advances offset after processing updates", async () => {
-      adapter.setMessageHandler(vi.fn().mockResolvedValue(undefined));
-      mockFetch.mockResolvedValueOnce(buildPollResponse([makeUpdate(42, 100, "Hi")]));
-      await adapter.start();
-      await vi.advanceTimersByTimeAsync(0);
-      mockFetch.mockResolvedValueOnce(buildPollResponse([]));
-      await vi.advanceTimersByTimeAsync(1000);
-      const lastCall = mockFetch.mock.calls.at(-1)?.[0];
-      expect(lastCall).toContain("offset=43");
-    });
-    it("skips messages without text", async () => {
-      const handler = vi.fn().mockResolvedValue(undefined);
-      adapter.setMessageHandler(handler);
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          ok: true,
-          result: [{
-            update_id: 1,
-            message: {
-              message_id: 10,
-              chat: {
-                id: 100
-              },
-              from: {
-                id: 1
-              }
-            }
-          }]
-        })
-      });
-      await adapter.start();
-      await vi.advanceTimersByTimeAsync(0);
-      expect(handler).not.toHaveBeenCalled();
-    });
-    it("continues polling on fetch error", async () => {
-      mockFetch.mockRejectedValueOnce(new Error("Network fail"));
-      await adapter.start();
-      await vi.advanceTimersByTimeAsync(0);
-      expect(adapter.getStats().errors).toBe(1);
-      mockFetch.mockResolvedValueOnce(buildPollResponse([]));
-      await vi.advanceTimersByTimeAsync(1000);
-      expect(mockFetch).toHaveBeenCalledTimes(2);
-    });
-    it("handles sender_name with only first_name", async () => {
-      const handler = vi.fn().mockResolvedValue(undefined);
-      adapter.setMessageHandler(handler);
-      mockFetch.mockResolvedValueOnce(buildPollResponse([makeUpdate(1, 100, "Hi", {
-        id: 1,
-        first_name: "Bob"
-      })]));
-      await adapter.start();
-      await vi.advanceTimersByTimeAsync(0);
-      expect(handler.mock.calls[0][0].sender_name).toBe("Bob");
-    });
-    it("falls back to 'unknown' when from is absent", async () => {
-      const handler = vi.fn().mockResolvedValue(undefined);
-      adapter.setMessageHandler(handler);
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          ok: true,
-          result: [{
-            update_id: 1,
-            message: {
-              message_id: 10,
-              chat: {
-                id: 100,
-                type: "group"
-              },
-              text: "Hi"
-            }
-          }]
-        })
-      });
-      await adapter.start();
-      await vi.advanceTimersByTimeAsync(0);
-      expect(handler.mock.calls[0][0].sender_id).toBe("unknown");
-    });
-  });
-
-  // ====== allowed_chats filter ======
-
-  describe("allowed_chats filter", () => {
-    it("filters messages from non-allowed chats", async () => {
-      const a = new TelegramAdapter("tg-filter", defaultConfig({
-        allowed_chats: [100]
-      }));
-      const handler = vi.fn().mockResolvedValue(undefined);
-      a.setMessageHandler(handler);
-      mockFetch.mockResolvedValueOnce(buildPollResponse([makeUpdate(1, 999, "Blocked")]));
-      await a.start();
-      await vi.advanceTimersByTimeAsync(0);
-      expect(handler).not.toHaveBeenCalled();
-      await a.stop();
-    });
-    it("allows messages from chats in allowed_chats", async () => {
-      const a = new TelegramAdapter("tg-allow", defaultConfig({
-        allowed_chats: [100]
-      }));
-      const handler = vi.fn().mockResolvedValue(undefined);
-      a.setMessageHandler(handler);
-      mockFetch.mockResolvedValueOnce(buildPollResponse([makeUpdate(1, 100, "Allowed")]));
-      await a.start();
-      await vi.advanceTimersByTimeAsync(0);
-      expect(handler).toHaveBeenCalledTimes(1);
-      await a.stop();
-    });
-  });
-});

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

@@ -1,166 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-
-// Mock global fetch
-const mockFetch = vi.fn();
-vi.stubGlobal("fetch", mockFetch);
-import { TelegramAdapter } from "../telegram.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function defaultConfig(overrides = {}) {
-  return {
-    bot_token: "123456:ABC-DEF",
-    allowed_chats: undefined,
-    ...overrides
-  };
-}
-function buildPollResponse(updates = []) {
-  return {
-    ok: true,
-    json: async () => ({
-      ok: true,
-      result: updates
-    })
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe("TelegramAdapter — sendMessage + stats", () => {
-  let adapter;
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.clearAllMocks();
-    mockFetch.mockResolvedValue(buildPollResponse([]));
-    adapter = new TelegramAdapter("test-tg", defaultConfig());
-  });
-  afterEach(async () => {
-    if (adapter.isRunning()) await adapter.stop();
-    vi.useRealTimers();
-  });
-
-  // ====== sendMessage ======
-
-  describe("sendMessage", () => {
-    it("sends message via Telegram API and returns true on success", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true
-      });
-      const result = await adapter.sendMessage({
-        id: "msg-1",
-        content: "Reply text",
-        sender_id: "42",
-        metadata: {
-          chat_id: 100
-        }
-      });
-      expect(result).toBe(true);
-      expect(adapter.getStats().messages_out).toBe(1);
-      const [url, opts] = mockFetch.mock.calls[0];
-      expect(url).toContain("123456:ABC-DEF/sendMessage");
-      const body = JSON.parse(opts.body);
-      expect(body.chat_id).toBe(100);
-      expect(body.text).toBe("Reply text");
-      expect(body.parse_mode).toBe("Markdown");
-    });
-    it("returns false when no chat_id available", async () => {
-      const result = await adapter.sendMessage({
-        id: "msg-2",
-        content: "No chat",
-        sender_id: "42"
-      });
-      expect(result).toBe(false);
-    });
-    it("returns false when API responds non-ok", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: false,
-        status: 400
-      });
-      const result = await adapter.sendMessage({
-        id: "msg-3",
-        content: "Fail",
-        sender_id: "42",
-        metadata: {
-          chat_id: 100
-        }
-      });
-      expect(result).toBe(false);
-      expect(adapter.getStats().errors).toBe(1);
-    });
-    it("returns false on network error", async () => {
-      mockFetch.mockRejectedValueOnce(new Error("Network fail"));
-      const result = await adapter.sendMessage({
-        id: "msg-4",
-        content: "Fail",
-        sender_id: "42",
-        metadata: {
-          chat_id: 100
-        }
-      });
-      expect(result).toBe(false);
-      expect(adapter.getStats().errors).toBe(1);
-    });
-    it("uses conversation_id as fallback for chat_id", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true
-      });
-      await adapter.sendMessage({
-        id: "msg-5",
-        content: "Fallback",
-        sender_id: "42",
-        conversation_id: "conv-999"
-      });
-      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-      expect(body.chat_id).toBe("conv-999");
-    });
-  });
-
-  // ====== 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",
-        metadata: {
-          chat_id: 1
-        }
-      });
-      expect(adapter.getStats().last_message_at).toBeDefined();
-    });
-    it("increments errors when handler rejects", async () => {
-      const handler = vi.fn().mockRejectedValue(new Error("boom"));
-      adapter.setMessageHandler(handler);
-      mockFetch.mockResolvedValueOnce(buildPollResponse([{
-        update_id: 1,
-        message: {
-          message_id: 10,
-          chat: {
-            id: 100,
-            type: "private"
-          },
-          from: {
-            id: 999,
-            first_name: "TestUser"
-          },
-          text: "Crash"
-        }
-      }]));
-      await adapter.start();
-      await vi.advanceTimersByTimeAsync(0);
-      expect(adapter.getStats().errors).toBe(1);
-    });
-  });
-});

package/dist/node/adapters/__tests__/webchat-inbound.test.js

@@ -1,188 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import http from "node:http";
-import { WebchatAdapter } from "../webchat.js";
-// ============================================================================
-// Helpers
-// ============================================================================
-
-function request(port, method, path, body, headers) {
-  return new Promise((resolve, reject) => {
-    const req = http.request({
-      hostname: "127.0.0.1",
-      port,
-      method,
-      path,
-      headers: {
-        "Content-Type": "application/json",
-        ...headers
-      }
-    }, res => {
-      let data = "";
-      res.on("data", chunk => data += chunk);
-      res.on("end", () => resolve({
-        status: res.statusCode || 500,
-        body: data,
-        headers: res.headers
-      }));
-    });
-    req.on("error", reject);
-    if (body) req.write(body);
-    req.end();
-  });
-}
-let testPort;
-let adapter;
-beforeEach(async () => {
-  testPort = 30000 + Math.floor(Math.random() * 30000);
-  adapter = new WebchatAdapter("test-webchat", {
-    port: testPort
-  });
-  await adapter.start();
-  for (let i = 0; i < 20; i++) {
-    try {
-      await request(testPort, "GET", "/health");
-      break;
-    } catch {
-      await new Promise(r => setTimeout(r, 50));
-    }
-  }
-});
-afterEach(async () => {
-  await adapter.stop();
-  await new Promise(r => setTimeout(r, 50));
-});
-
-// ============================================================================
-// Constructor / Properties
-// ============================================================================
-
-describe("WebchatAdapter — properties", () => {
-  it("has correct type and name", () => {
-    expect(adapter.type).toBe("webchat");
-    expect(adapter.name).toBe("test-webchat");
-  });
-  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 running after start", () => {
-    expect(adapter.isRunning()).toBe(true);
-  });
-});
-
-// ============================================================================
-// Health endpoint
-// ============================================================================
-
-describe("WebchatAdapter — GET /health", () => {
-  it("returns health check response", async () => {
-    const res = await request(testPort, "GET", "/health");
-    expect(res.status).toBe(200);
-    const data = JSON.parse(res.body);
-    expect(data.status).toBe("ok");
-    expect(data.adapter).toBe("test-webchat");
-    expect(data.stats).toBeDefined();
-  });
-});
-
-// ============================================================================
-// CORS preflight
-// ============================================================================
-
-describe("WebchatAdapter — OPTIONS preflight", () => {
-  it("returns 204 with CORS headers", async () => {
-    const res = await request(testPort, "OPTIONS", "/message");
-    expect(res.status).toBe(204);
-    expect(res.headers["access-control-allow-methods"]).toContain("POST");
-    expect(res.headers["access-control-allow-headers"]).toContain("Content-Type");
-  });
-});
-
-// ============================================================================
-// POST /message
-// ============================================================================
-
-describe("WebchatAdapter — POST /message", () => {
-  it("accepts a valid message and calls handler", async () => {
-    const handler = vi.fn(async _msg => {});
-    adapter.setMessageHandler(handler);
-    const res = await request(testPort, "POST", "/message", JSON.stringify({
-      content: "Hello from web!",
-      session_id: "sess-123"
-    }));
-    expect(res.status).toBe(200);
-    const data = JSON.parse(res.body);
-    expect(data.success).toBe(true);
-    expect(handler).toHaveBeenCalledWith(expect.objectContaining({
-      sender_id: "sess-123",
-      content: "Hello from web!"
-    }));
-    expect(adapter.getStats().messages_in).toBe(1);
-  });
-  it("includes sender_name from request", async () => {
-    const handler = vi.fn(async _msg => {});
-    adapter.setMessageHandler(handler);
-    await request(testPort, "POST", "/message", JSON.stringify({
-      content: "Hello",
-      session_id: "sess-1",
-      sender_name: "Alice"
-    }));
-    expect(handler).toHaveBeenCalledWith(expect.objectContaining({
-      sender_name: "Alice"
-    }));
-  });
-  it("defaults sender_name to 'Visitor'", async () => {
-    const handler = vi.fn(async _msg => {});
-    adapter.setMessageHandler(handler);
-    await request(testPort, "POST", "/message", JSON.stringify({
-      content: "Hello",
-      session_id: "sess-1"
-    }));
-    expect(handler).toHaveBeenCalledWith(expect.objectContaining({
-      sender_name: "Visitor"
-    }));
-  });
-  it("rejects missing content", async () => {
-    const res = await request(testPort, "POST", "/message", JSON.stringify({
-      session_id: "sess-1"
-    }));
-    expect(res.status).toBe(400);
-    const data = JSON.parse(res.body);
-    expect(data.error).toContain("content and session_id required");
-  });
-  it("rejects missing session_id", async () => {
-    const res = await request(testPort, "POST", "/message", JSON.stringify({
-      content: "Hello"
-    }));
-    expect(res.status).toBe(400);
-    const data = JSON.parse(res.body);
-    expect(data.error).toContain("content and session_id required");
-  });
-  it("truncates messages exceeding max_message_length", async () => {
-    const handler = vi.fn(async _msg => {});
-    adapter.setMessageHandler(handler);
-    const longContent = "x".repeat(10000);
-    await request(testPort, "POST", "/message", JSON.stringify({
-      content: longContent,
-      session_id: "sess-1"
-    }));
-    const receivedContent = handler.mock.calls[0][0].content;
-    expect(receivedContent.length).toBe(8000); // MAX_MESSAGE_LENGTH
-  });
-  it("includes page_url in metadata", async () => {
-    const handler = vi.fn(async _msg => {});
-    adapter.setMessageHandler(handler);
-    await request(testPort, "POST", "/message", JSON.stringify({
-      content: "Hello",
-      session_id: "sess-1",
-      page_url: "https://example.com/products"
-    }));
-    expect(handler).toHaveBeenCalledWith(expect.objectContaining({
-      metadata: expect.objectContaining({
-        page_url: "https://example.com/products"
-      })
-    }));
-  });
-});