whale-code 6.5.10 → 6.6.0

package/dist/node/__tests__/runtime-relay.test.js

@@ -1,341 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-
-// ---------------------------------------------------------------------------
-// Mocks — prevent real network, adapters, and error-logger side effects
-// ---------------------------------------------------------------------------
-
-vi.mock("../../cli/services/error-logger.js", () => ({
-  captureError: vi.fn(),
-  addBreadcrumb: vi.fn(),
-  initErrorLogger: vi.fn(),
-  setErrorLoggerUser: vi.fn()
-}));
-const {
-  mockAdapterStart,
-  mockAdapterStop,
-  mockAdapterSendMessage,
-  mockAdapterGetStats,
-  mockAdapterIsRunning,
-  mockAdapterSetMessageHandler
-} = vi.hoisted(() => {
-  return {
-    mockAdapterStart: vi.fn().mockResolvedValue(undefined),
-    mockAdapterStop: vi.fn().mockResolvedValue(undefined),
-    mockAdapterSendMessage: vi.fn().mockResolvedValue(true),
-    mockAdapterGetStats: vi.fn(() => ({
-      messages_in: 0,
-      messages_out: 0,
-      errors: 0
-    })),
-    mockAdapterIsRunning: vi.fn(() => true),
-    mockAdapterSetMessageHandler: vi.fn()
-  };
-});
-function makeMockAdapterClass(adapterType) {
-  return vi.fn().mockImplementation(function (name, _config) {
-    return {
-      type: adapterType,
-      name,
-      start: mockAdapterStart,
-      stop: mockAdapterStop,
-      sendMessage: mockAdapterSendMessage,
-      getStats: mockAdapterGetStats,
-      isRunning: mockAdapterIsRunning,
-      setMessageHandler: mockAdapterSetMessageHandler
-    };
-  });
-}
-vi.mock("../adapters/imessage.js", () => ({
-  IMessageAdapter: makeMockAdapterClass("imessage")
-}));
-vi.mock("../adapters/telegram.js", () => ({
-  TelegramAdapter: makeMockAdapterClass("telegram")
-}));
-vi.mock("../adapters/discord.js", () => ({
-  DiscordAdapter: makeMockAdapterClass("discord")
-}));
-vi.mock("../adapters/slack.js", () => ({
-  SlackAdapter: makeMockAdapterClass("slack")
-}));
-vi.mock("../adapters/webchat.js", () => ({
-  WebchatAdapter: makeMockAdapterClass("webchat")
-}));
-vi.mock("../adapters/whatsapp.js", () => ({
-  WhatsAppAdapter: makeMockAdapterClass("whatsapp")
-}));
-vi.mock("../adapters/sms.js", () => ({
-  SmsAdapter: makeMockAdapterClass("sms")
-}));
-vi.mock("../adapters/email.js", () => ({
-  EmailAdapter: makeMockAdapterClass("email")
-}));
-const mockFetch = vi.fn();
-vi.stubGlobal("fetch", mockFetch);
-const mockExit = vi.spyOn(process, "exit").mockImplementation(() => {});
-const mockOn = vi.spyOn(process, "on").mockImplementation(() => {});
-import { NodeRuntime } from "../runtime.js";
-import { captureError } from "../../cli/services/error-logger.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function defaultNodeConfig(overrides = {}) {
-  return {
-    node_id: "test-node-001",
-    api_key: "test-api-key",
-    store_id: "test-store",
-    server_url: "https://test-server.example.com",
-    channels: [],
-    cluster_ws_port: 0,
-    ...overrides
-  };
-}
-function makeHeartbeatResponse(ok = true, status = 200) {
-  return {
-    ok,
-    status,
-    json: async () => ({
-      success: ok
-    }),
-    text: async () => ""
-  };
-}
-function makeRelayResponse(agentResponse) {
-  return {
-    ok: true,
-    status: 200,
-    json: async () => ({
-      success: true,
-      conversation_id: "conv-123",
-      agent_response: agentResponse || null
-    }),
-    text: async () => ""
-  };
-}
-function makePollResponse(messages = []) {
-  return {
-    ok: true,
-    status: 200,
-    json: async () => ({
-      success: true,
-      messages
-    }),
-    text: async () => ""
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe("NodeRuntime — relay, connectivity, polling", () => {
-  let runtime;
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.clearAllMocks();
-    mockFetch.mockResolvedValue(makeHeartbeatResponse(true));
-    runtime = new NodeRuntime(defaultNodeConfig());
-  });
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  // ====== relayAndDeliver ======
-
-  describe("relayAndDeliver", () => {
-    it("relays inbound message to server", async () => {
-      const config = defaultNodeConfig({
-        channels: [{
-          id: "ch-1",
-          type: "telegram",
-          name: "TG",
-          config: {}
-        }]
-      });
-      runtime = new NodeRuntime(config);
-      mockFetch.mockResolvedValueOnce(makeHeartbeatResponse(true));
-      await runtime.start();
-      mockFetch.mockResolvedValueOnce(makeRelayResponse());
-      await runtime.relayAndDeliver("ch-1", {
-        sender_id: "user-1",
-        content: "Hello"
-      });
-      const relayCalls = mockFetch.mock.calls.filter(([url]) => String(url).includes("/channels/ch-1/messages") && !String(url).includes("undelivered"));
-      expect(relayCalls.length).toBeGreaterThanOrEqual(1);
-      const body = JSON.parse(relayCalls[0][1].body);
-      expect(body.direction).toBe("inbound");
-      expect(body.content).toBe("Hello");
-    });
-    it("increments messages_relayed on success", async () => {
-      runtime = new NodeRuntime(defaultNodeConfig({
-        channels: [{
-          id: "ch-1",
-          type: "telegram",
-          name: "TG",
-          config: {}
-        }]
-      }));
-      mockFetch.mockResolvedValueOnce(makeHeartbeatResponse(true));
-      await runtime.start();
-      mockFetch.mockResolvedValueOnce(makeRelayResponse());
-      await runtime.relayAndDeliver("ch-1", {
-        sender_id: "u",
-        content: "hi"
-      });
-      expect(runtime.getStats().messages_relayed).toBe(1);
-    });
-    it("delivers agent_response back via adapter.sendMessage", async () => {
-      runtime = new NodeRuntime(defaultNodeConfig({
-        channels: [{
-          id: "ch-1",
-          type: "telegram",
-          name: "TG",
-          config: {}
-        }]
-      }));
-      mockFetch.mockResolvedValueOnce(makeHeartbeatResponse(true));
-      await runtime.start();
-      const agentResponse = {
-        id: "resp-1",
-        content: "Agent reply",
-        conversation_id: "conv-1"
-      };
-      mockFetch.mockResolvedValueOnce(makeRelayResponse(agentResponse));
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        json: async () => ({}),
-        text: async () => ""
-      });
-      await runtime.relayAndDeliver("ch-1", {
-        sender_id: "u",
-        content: "hi"
-      });
-      expect(mockAdapterSendMessage).toHaveBeenCalledWith(expect.objectContaining({
-        id: "resp-1",
-        content: "Agent reply",
-        sender_id: "agent"
-      }));
-    });
-    it("marks delivered after adapter sends successfully", async () => {
-      runtime = new NodeRuntime(defaultNodeConfig({
-        channels: [{
-          id: "ch-1",
-          type: "telegram",
-          name: "TG",
-          config: {}
-        }]
-      }));
-      mockFetch.mockResolvedValueOnce(makeHeartbeatResponse(true));
-      await runtime.start();
-      mockFetch.mockResolvedValueOnce(makeRelayResponse({
-        id: "r1",
-        content: "ok"
-      }));
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        json: async () => ({}),
-        text: async () => ""
-      });
-      await runtime.relayAndDeliver("ch-1", {
-        sender_id: "u",
-        content: "hi"
-      });
-      const deliverCalls = mockFetch.mock.calls.filter(([url]) => String(url).includes("/delivered"));
-      expect(deliverCalls.length).toBe(1);
-    });
-    it("increments messages_failed on relay error", async () => {
-      runtime = new NodeRuntime(defaultNodeConfig({
-        channels: [{
-          id: "ch-1",
-          type: "telegram",
-          name: "TG",
-          config: {}
-        }]
-      }));
-      mockFetch.mockResolvedValueOnce(makeHeartbeatResponse(true));
-      await runtime.start();
-      mockFetch.mockRejectedValue(new Error("Server down"));
-      const p1 = runtime.relayAndDeliver("ch-1", {
-        sender_id: "u",
-        content: "hi"
-      });
-      await vi.advanceTimersByTimeAsync(10_000);
-      await p1;
-      expect(runtime.getStats().messages_failed).toBe(1);
-    });
-    it("captures error via error logger on relay failure", async () => {
-      runtime = new NodeRuntime(defaultNodeConfig({
-        channels: [{
-          id: "ch-1",
-          type: "telegram",
-          name: "TG",
-          config: {}
-        }]
-      }));
-      mockFetch.mockResolvedValueOnce(makeHeartbeatResponse(true));
-      await runtime.start();
-      mockFetch.mockRejectedValue(new Error("Server down"));
-      const p2 = runtime.relayAndDeliver("ch-1", {
-        sender_id: "u",
-        content: "hi"
-      });
-      await vi.advanceTimersByTimeAsync(10_000);
-      await p2;
-      expect(captureError).toHaveBeenCalledWith(expect.objectContaining({
-        severity: "error",
-        tags: expect.objectContaining({
-          source: "whale-node",
-          operation: "relay"
-        })
-      }));
-    });
-  });
-
-  // ====== Server connectivity tracking ======
-
-  describe("server connectivity tracking", () => {
-    it("status is connected after successful heartbeat", async () => {
-      await runtime.start();
-      expect(runtime.getStats().status).toBe("connected");
-      expect(runtime.getStats().consecutive_server_failures).toBe(0);
-    });
-    it("status is degraded when initial heartbeat fails", async () => {
-      mockFetch.mockRejectedValue(new Error("fail"));
-      const p = runtime.start();
-      await vi.advanceTimersByTimeAsync(10_000);
-      await p;
-      expect(runtime.getStats().status).toBe("degraded");
-      expect(runtime.getStats().consecutive_server_failures).toBeGreaterThan(0);
-    });
-    it("consecutive failures increase with each failed heartbeat", async () => {
-      mockFetch.mockRejectedValue(new Error("fail"));
-      const p = runtime.start();
-      await vi.advanceTimersByTimeAsync(10_000);
-      await p;
-      const initial = runtime.getStats().consecutive_server_failures;
-      expect(initial).toBeGreaterThan(0);
-    });
-  });
-
-  // ====== Poll outbound ======
-
-  describe("pollOutbound", () => {
-    it("starts polling timer for each channel", async () => {
-      const config = defaultNodeConfig({
-        channels: [{
-          id: "ch-1",
-          type: "telegram",
-          name: "TG",
-          config: {}
-        }]
-      });
-      runtime = new NodeRuntime(config);
-      await runtime.start();
-      mockFetch.mockResolvedValue(makePollResponse([]));
-      vi.advanceTimersByTime(2100);
-      const pollCalls = mockFetch.mock.calls.filter(([url]) => String(url).includes("/channels/ch-1/messages?undelivered"));
-      expect(pollCalls.length).toBeGreaterThanOrEqual(1);
-    });
-  });
-});

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

@@ -1,286 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { BaseAdapter } from "../base.js";
-
-// ============================================================================
-// Test subclass — BaseAdapter is abstract, so we need a concrete implementation
-// ============================================================================
-class TestAdapter extends BaseAdapter {
-  type = "test";
-  startCalled = false;
-  stopCalled = false;
-  lastSentMessage = null;
-  sendShouldFail = false;
-  constructor(name = "test-adapter") {
-    super();
-    this.name = name;
-  }
-  async start() {
-    this.startCalled = true;
-    this.running = true;
-  }
-  async stop() {
-    this.stopCalled = true;
-    this.running = false;
-  }
-  async sendMessage(msg) {
-    if (this.sendShouldFail) {
-      this.stats.errors++;
-      return false;
-    }
-    this.lastSentMessage = msg;
-    this.stats.messages_out++;
-    this.stats.last_message_at = new Date().toISOString();
-    return true;
-  }
-
-  // Expose protected members for testing
-  async triggerInbound(msg) {
-    if (this.onInboundMessage) {
-      this.stats.messages_in++;
-      this.stats.last_message_at = new Date().toISOString();
-      await this.onInboundMessage(msg);
-    }
-  }
-  getRunningState() {
-    return this.running;
-  }
-  getStatsInternal() {
-    return this.stats;
-  }
-}
-
-// ============================================================================
-// Setup
-// ============================================================================
-let adapter;
-beforeEach(() => {
-  adapter = new TestAdapter();
-});
-
-// ============================================================================
-// Constructor / Properties
-// ============================================================================
-
-describe("BaseAdapter - properties", () => {
-  it("has type from subclass", () => {
-    expect(adapter.type).toBe("test");
-  });
-  it("has name from subclass", () => {
-    expect(adapter.name).toBe("test-adapter");
-  });
-  it("accepts custom name", () => {
-    const custom = new TestAdapter("custom-name");
-    expect(custom.name).toBe("custom-name");
-  });
-  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);
-    expect(stats.last_message_at).toBeUndefined();
-  });
-  it("is not running initially", () => {
-    expect(adapter.isRunning()).toBe(false);
-  });
-});
-
-// ============================================================================
-// Stats tracking
-// ============================================================================
-
-describe("BaseAdapter - stats tracking", () => {
-  it("getStats returns a copy (not a reference)", () => {
-    const stats1 = adapter.getStats();
-    const stats2 = adapter.getStats();
-    expect(stats1).toEqual(stats2);
-    expect(stats1).not.toBe(stats2); // different object references
-  });
-  it("tracks messages_out after sendMessage", async () => {
-    const msg = {
-      id: "msg-1",
-      content: "Hello",
-      sender_id: "bot"
-    };
-    await adapter.sendMessage(msg);
-    expect(adapter.getStats().messages_out).toBe(1);
-  });
-  it("increments messages_out for multiple sends", async () => {
-    for (let i = 0; i < 5; i++) {
-      await adapter.sendMessage({
-        id: `msg-${i}`,
-        content: "Hi",
-        sender_id: "bot"
-      });
-    }
-    expect(adapter.getStats().messages_out).toBe(5);
-  });
-  it("tracks errors on failed sends", async () => {
-    adapter.sendShouldFail = true;
-    await adapter.sendMessage({
-      id: "msg-fail",
-      content: "Fail",
-      sender_id: "bot"
-    });
-    expect(adapter.getStats().errors).toBe(1);
-  });
-  it("tracks messages_in when inbound handler fires", async () => {
-    adapter.setMessageHandler(async () => {});
-    await adapter.triggerInbound({
-      sender_id: "user-1",
-      content: "Hello from user"
-    });
-    expect(adapter.getStats().messages_in).toBe(1);
-  });
-  it("updates last_message_at on outbound message", async () => {
-    await adapter.sendMessage({
-      id: "msg-1",
-      content: "Hello",
-      sender_id: "bot"
-    });
-    expect(adapter.getStats().last_message_at).toBeDefined();
-  });
-  it("updates last_message_at on inbound message", async () => {
-    adapter.setMessageHandler(async () => {});
-    await adapter.triggerInbound({
-      sender_id: "u1",
-      content: "Hi"
-    });
-    expect(adapter.getStats().last_message_at).toBeDefined();
-  });
-});
-
-// ============================================================================
-// start / stop
-// ============================================================================
-
-describe("BaseAdapter - start/stop", () => {
-  it("sets running=true after start", async () => {
-    await adapter.start();
-    expect(adapter.isRunning()).toBe(true);
-  });
-  it("sets running=false after stop", async () => {
-    await adapter.start();
-    await adapter.stop();
-    expect(adapter.isRunning()).toBe(false);
-  });
-  it("can be started and stopped multiple times", async () => {
-    await adapter.start();
-    expect(adapter.isRunning()).toBe(true);
-    await adapter.stop();
-    expect(adapter.isRunning()).toBe(false);
-    await adapter.start();
-    expect(adapter.isRunning()).toBe(true);
-  });
-});
-
-// ============================================================================
-// sendMessage
-// ============================================================================
-
-describe("BaseAdapter - sendMessage", () => {
-  it("returns true on successful send", async () => {
-    const result = await adapter.sendMessage({
-      id: "msg-1",
-      content: "Test message",
-      sender_id: "bot"
-    });
-    expect(result).toBe(true);
-  });
-  it("stores the last sent message", async () => {
-    const msg = {
-      id: "msg-42",
-      content: "Specific content",
-      sender_id: "agent",
-      sender_name: "Agent Smith",
-      conversation_id: "conv-1",
-      metadata: {
-        priority: "high"
-      }
-    };
-    await adapter.sendMessage(msg);
-    expect(adapter.lastSentMessage).toEqual(msg);
-  });
-  it("returns false on send failure", async () => {
-    adapter.sendShouldFail = true;
-    const result = await adapter.sendMessage({
-      id: "msg-bad",
-      content: "This will fail",
-      sender_id: "bot"
-    });
-    expect(result).toBe(false);
-  });
-});
-
-// ============================================================================
-// Message handler
-// ============================================================================
-
-describe("BaseAdapter - message handler", () => {
-  it("setMessageHandler stores the handler", () => {
-    const handler = vi.fn(async _msg => {});
-    adapter.setMessageHandler(handler);
-    // Handler should not be called yet
-    expect(handler).not.toHaveBeenCalled();
-  });
-  it("handler is invoked on inbound message", async () => {
-    const handler = vi.fn(async _msg => {});
-    adapter.setMessageHandler(handler);
-    const inbound = {
-      sender_id: "user-1",
-      sender_name: "Alice",
-      content: "Hello bot",
-      content_type: "text",
-      conversation_id: "conv-1",
-      metadata: {
-        source: "test"
-      }
-    };
-    await adapter.triggerInbound(inbound);
-    expect(handler).toHaveBeenCalledOnce();
-    expect(handler).toHaveBeenCalledWith(inbound);
-  });
-  it("can replace handler with a new one", async () => {
-    const handler1 = vi.fn(async () => {});
-    const handler2 = vi.fn(async () => {});
-    adapter.setMessageHandler(handler1);
-    adapter.setMessageHandler(handler2);
-    await adapter.triggerInbound({
-      sender_id: "u1",
-      content: "msg"
-    });
-    expect(handler1).not.toHaveBeenCalled();
-    expect(handler2).toHaveBeenCalledOnce();
-  });
-  it("does nothing when no handler is set", async () => {
-    // Should not throw
-    await adapter.triggerInbound({
-      sender_id: "u1",
-      content: "msg"
-    });
-    expect(adapter.getStats().messages_in).toBe(0);
-  });
-});
-
-// ============================================================================
-// Abstract contract verification
-// ============================================================================
-
-describe("BaseAdapter - abstract contract", () => {
-  it("requires subclass to implement type", () => {
-    expect(typeof adapter.type).toBe("string");
-    expect(adapter.type.length).toBeGreaterThan(0);
-  });
-  it("requires subclass to implement name", () => {
-    expect(typeof adapter.name).toBe("string");
-    expect(adapter.name.length).toBeGreaterThan(0);
-  });
-  it("requires subclass to implement start()", () => {
-    expect(typeof adapter.start).toBe("function");
-  });
-  it("requires subclass to implement stop()", () => {
-    expect(typeof adapter.stop).toBe("function");
-  });
-  it("requires subclass to implement sendMessage()", () => {
-    expect(typeof adapter.sendMessage).toBe("function");
-  });
-});