whale-code 6.5.10 → 6.6.0

package/dist/node/__tests__/cli-channels.test.js

@@ -1,293 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-
-// ---------------------------------------------------------------------------
-// Mocks — intercept all side effects of cli.ts module-level code
-// ---------------------------------------------------------------------------
-
-vi.mock("../../cli/services/error-logger.js", () => ({
-  initErrorLogger: vi.fn(),
-  setErrorLoggerUser: vi.fn(),
-  captureError: vi.fn()
-}));
-vi.mock("../../cli/services/config-store.js", () => ({
-  loadConfig: vi.fn(() => ({}))
-}));
-const mockLoadConfig = vi.fn();
-const mockSaveConfig = vi.fn();
-const mockRequireConfig = vi.fn();
-const mockGetConfigPath = vi.fn(() => "/Users/test/.whaletools/config.json");
-vi.mock("../config.js", () => ({
-  loadConfig: (...args) => mockLoadConfig(...args),
-  saveConfig: (...args) => mockSaveConfig(...args),
-  requireConfig: (...args) => mockRequireConfig(...args),
-  getConfigPath: (...args) => mockGetConfigPath(...args)
-}));
-const {
-  mockRuntimeStart,
-  mockRuntimeStop
-} = vi.hoisted(() => ({
-  mockRuntimeStart: vi.fn().mockResolvedValue(undefined),
-  mockRuntimeStop: vi.fn()
-}));
-vi.mock("../runtime.js", () => ({
-  NodeRuntime: vi.fn().mockImplementation(function () {
-    return {
-      start: mockRuntimeStart,
-      stop: mockRuntimeStop
-    };
-  })
-}));
-const mockFetch = vi.fn();
-vi.stubGlobal("fetch", mockFetch);
-const consoleLogs = [];
-const consoleErrors = [];
-const origLog = console.log;
-const origError = console.error;
-const origWarn = console.warn;
-const mockExit = vi.spyOn(process, "exit").mockImplementation(() => {
-  throw new Error("process.exit called");
-});
-
-// ---------------------------------------------------------------------------
-// Tests — channels, version, help
-// ---------------------------------------------------------------------------
-describe("WhaleNode CLI — channels and help", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    consoleLogs.length = 0;
-    consoleErrors.length = 0;
-    console.log = (...args) => consoleLogs.push(args.join(" "));
-    console.error = (...args) => consoleErrors.push(args.join(" "));
-    console.warn = (...args) => {};
-  });
-  afterEach(() => {
-    console.log = origLog;
-    console.error = origError;
-    console.warn = origWarn;
-  });
-
-  // ====== channel add command behavior ======
-
-  describe("channel add flow", () => {
-    const validTypes = ["imessage", "telegram", "discord", "slack", "whatsapp", "sms", "email"];
-    it("validates channel type against known types", () => {
-      for (const type of validTypes) {
-        expect(validTypes.includes(type)).toBe(true);
-      }
-      expect(validTypes.includes("carrier_pigeon")).toBe(false);
-    });
-    it("registers channel with server and saves config", async () => {
-      const config = {
-        node_id: "node-1",
-        api_key: "key-1",
-        store_id: "store-1",
-        server_url: "https://server.example.com",
-        channels: []
-      };
-      mockRequireConfig.mockReturnValue(config);
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          success: true,
-          channel: {
-            id: "ch-new-id"
-          }
-        })
-      });
-      const res = await mockFetch(`${config.server_url}/channels`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${config.api_key}`
-        },
-        body: JSON.stringify({
-          store_id: config.store_id,
-          node_id: config.node_id,
-          type: "telegram",
-          name: "my-telegram",
-          config: {
-            bot_token: "123:ABC"
-          }
-        })
-      });
-      const data = await res.json();
-      config.channels.push({
-        id: data.channel.id,
-        type: "telegram",
-        name: "my-telegram",
-        config: {
-          bot_token: "123:ABC"
-        }
-      });
-      mockSaveConfig(config);
-      expect(data.success).toBe(true);
-      expect(config.channels).toHaveLength(1);
-      expect(config.channels[0].id).toBe("ch-new-id");
-      expect(mockSaveConfig).toHaveBeenCalledWith(config);
-    });
-    it("handles channel add failure from server", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          success: false,
-          error: "Duplicate channel"
-        })
-      });
-      const res = await mockFetch("https://test/channels", {
-        method: "POST",
-        body: "{}"
-      });
-      const data = await res.json();
-      expect(data.success).toBe(false);
-    });
-    it("builds correct config for imessage channel", () => {
-      const channelConfig = {
-        watch_groups: [109, 110],
-        mention_required: "@whale",
-        max_message_length: 4000
-      };
-      expect(channelConfig.watch_groups).toEqual([109, 110]);
-      expect(channelConfig.mention_required).toBe("@whale");
-    });
-    it("builds correct config for whatsapp channel", () => {
-      const channelConfig = {
-        phone_number_id: "12345",
-        access_token: "token",
-        verify_token: "verify",
-        allowed_numbers: ["+1555", "+1666"],
-        webhook_port: 3100
-      };
-      expect(channelConfig.phone_number_id).toBe("12345");
-      expect(channelConfig.allowed_numbers).toHaveLength(2);
-    });
-    it("builds correct config for sms channel", () => {
-      const channelConfig = {
-        account_sid: "AC123",
-        auth_token: "token",
-        from_number: "+15551234567"
-      };
-      expect(channelConfig.account_sid).toBe("AC123");
-    });
-    it("builds correct config for email channel", () => {
-      const channelConfig = {
-        api_key: "re_key",
-        from_address: "bot@example.com",
-        webhook_secret: "whsec_xxx",
-        webhook_port: 3102
-      };
-      expect(channelConfig.api_key).toBe("re_key");
-      expect(channelConfig.webhook_port).toBe(3102);
-    });
-    it("builds correct config for discord channel", () => {
-      const channelConfig = {
-        bot_token: "discord-token",
-        allowed_channels: ["ch1", "ch2"],
-        allowed_guilds: ["g1"],
-        mention_required: true
-      };
-      expect(channelConfig.allowed_channels).toEqual(["ch1", "ch2"]);
-    });
-    it("builds correct config for slack channel", () => {
-      const channelConfig = {
-        bot_token: "xoxb-token",
-        app_token: "xapp-token",
-        allowed_channels: ["C123"],
-        mention_required: true
-      };
-      expect(channelConfig.app_token).toBe("xapp-token");
-    });
-  });
-
-  // ====== channel list command behavior ======
-
-  describe("channel list flow", () => {
-    it("lists configured channels", () => {
-      const config = {
-        node_id: "n1",
-        api_key: "k",
-        store_id: "s",
-        server_url: "https://test",
-        channels: [{
-          id: "ch-1",
-          type: "telegram",
-          name: "TG Channel",
-          config: {}
-        }, {
-          id: "ch-2",
-          type: "discord",
-          name: "DC Channel",
-          config: {}
-        }]
-      };
-      mockRequireConfig.mockReturnValue(config);
-      const cfg = mockRequireConfig();
-      console.log("Configured channels:");
-      for (const ch of cfg.channels) {
-        console.log(`  ${ch.type.padEnd(10)} ${ch.name.padEnd(20)} ${ch.id}`);
-      }
-      expect(consoleLogs.some(l => l.includes("telegram"))).toBe(true);
-      expect(consoleLogs.some(l => l.includes("discord"))).toBe(true);
-    });
-    it("shows message when no channels configured", () => {
-      const config = {
-        node_id: "n",
-        api_key: "k",
-        store_id: "s",
-        server_url: "u",
-        channels: []
-      };
-      mockRequireConfig.mockReturnValue(config);
-      const cfg = mockRequireConfig();
-      if (!cfg.channels.length) {
-        console.log("No channels configured.");
-      }
-      expect(consoleLogs.some(l => l.includes("No channels configured"))).toBe(true);
-    });
-  });
-
-  // ====== version and help ======
-
-  describe("version and help", () => {
-    it("version outputs WhaleNode CLI version", () => {
-      console.log("WhaleNode CLI v1.1.0");
-      expect(consoleLogs).toContain("WhaleNode CLI v1.1.0");
-    });
-    it("help output includes all command groups", () => {
-      const helpText = `
-WhaleNode CLI v1.1.0 — Bridge local channels to WhaleTools AI agents
-
-Commands:
-  whale node register   Register this machine as a WhaleNode
-  whale node start      Start the node (heartbeat + channel adapters)
-  whale node status     Show node status
-
-  whale channel add     Add a channel adapter
-  whale channel list    List configured channels
-
-  whale status          Quick status check
-  whale version         Show version
-  whale help            Show this help
-`;
-      console.log(helpText);
-      expect(consoleLogs.some(l => l.includes("whale node register"))).toBe(true);
-      expect(consoleLogs.some(l => l.includes("whale channel add"))).toBe(true);
-      expect(consoleLogs.some(l => l.includes("whale status"))).toBe(true);
-    });
-    it("help lists all channel types", () => {
-      const types = ["imessage", "telegram", "discord", "slack", "whatsapp", "sms", "email"];
-      const helpChannels = `
-Channel Types:
-  imessage   --groups 109,110 --mention @whale
-  telegram   --token BOT_TOKEN
-  discord    --token BOT_TOKEN [--channels ID1,ID2]
-  slack      --token BOT_TOKEN --app-token APP_TOKEN
-  whatsapp   --phone-number-id ID --access-token TOKEN --verify-token SECRET
-  sms        --account-sid SID --auth-token TOKEN --from-number +1234567890
-  email      --api-key KEY --from-address sender@example.com
-`;
-      for (const type of types) {
-        expect(helpChannels).toContain(type);
-      }
-    });
-  });
-});

package/dist/node/__tests__/cli-config-edge.test.js

@@ -1,154 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-
-// ---------------------------------------------------------------------------
-// Mocks — intercept all side effects of cli.ts module-level code
-// ---------------------------------------------------------------------------
-
-vi.mock("../../cli/services/error-logger.js", () => ({
-  initErrorLogger: vi.fn(),
-  setErrorLoggerUser: vi.fn(),
-  captureError: vi.fn()
-}));
-vi.mock("../../cli/services/config-store.js", () => ({
-  loadConfig: vi.fn(() => ({}))
-}));
-const mockLoadConfig = vi.fn();
-const mockSaveConfig = vi.fn();
-const mockRequireConfig = vi.fn();
-const mockGetConfigPath = vi.fn(() => "/Users/test/.whaletools/config.json");
-vi.mock("../config.js", () => ({
-  loadConfig: (...args) => mockLoadConfig(...args),
-  saveConfig: (...args) => mockSaveConfig(...args),
-  requireConfig: (...args) => mockRequireConfig(...args),
-  getConfigPath: (...args) => mockGetConfigPath(...args)
-}));
-const {
-  mockRuntimeStart,
-  mockRuntimeStop
-} = vi.hoisted(() => ({
-  mockRuntimeStart: vi.fn().mockResolvedValue(undefined),
-  mockRuntimeStop: vi.fn()
-}));
-vi.mock("../runtime.js", () => ({
-  NodeRuntime: vi.fn().mockImplementation(function () {
-    return {
-      start: mockRuntimeStart,
-      stop: mockRuntimeStop
-    };
-  })
-}));
-const mockFetch = vi.fn();
-vi.stubGlobal("fetch", mockFetch);
-const mockExit = vi.spyOn(process, "exit").mockImplementation(() => {
-  throw new Error("process.exit called");
-});
-import { captureError } from "../../cli/services/error-logger.js";
-
-// ---------------------------------------------------------------------------
-// Tests — error handling and config edge cases
-// ---------------------------------------------------------------------------
-describe("WhaleNode CLI — errors & edge cases", () => {
-  const consoleLogs = [];
-  const consoleErrors = [];
-  const origLog = console.log;
-  const origError = console.error;
-  const origWarn = console.warn;
-  beforeEach(() => {
-    vi.clearAllMocks();
-    consoleLogs.length = 0;
-    consoleErrors.length = 0;
-    console.log = (...args) => consoleLogs.push(args.join(" "));
-    console.error = (...args) => consoleErrors.push(args.join(" "));
-    console.warn = (...args) => {};
-  });
-  afterEach(() => {
-    console.log = origLog;
-    console.error = origError;
-    console.warn = origWarn;
-  });
-  describe("error handling", () => {
-    it("captureError is called for fatal errors", () => {
-      const err = new Error("Fatal crash");
-      captureError({
-        error: err,
-        severity: "fatal",
-        tags: {
-          source: "whale-node",
-          handler: "main"
-        }
-      });
-      expect(captureError).toHaveBeenCalledWith(expect.objectContaining({
-        severity: "fatal",
-        tags: expect.objectContaining({
-          source: "whale-node"
-        })
-      }));
-    });
-    it("captureError handles uncaughtException", () => {
-      const err = new Error("Uncaught!");
-      captureError({
-        error: err,
-        severity: "fatal",
-        tags: {
-          source: "whale-node",
-          handler: "uncaughtException"
-        }
-      });
-      expect(captureError).toHaveBeenCalledWith(expect.objectContaining({
-        tags: expect.objectContaining({
-          handler: "uncaughtException"
-        })
-      }));
-    });
-    it("captureError handles unhandledRejection", () => {
-      const err = new Error("Unhandled!");
-      captureError({
-        error: err,
-        severity: "error",
-        tags: {
-          source: "whale-node",
-          handler: "unhandledRejection"
-        }
-      });
-      expect(captureError).toHaveBeenCalledWith(expect.objectContaining({
-        tags: expect.objectContaining({
-          handler: "unhandledRejection"
-        })
-      }));
-    });
-    it("converts non-Error rejections to Error instances", () => {
-      const reason = "string rejection";
-      const err = reason instanceof Error ? reason : new Error(String(reason));
-      expect(err).toBeInstanceOf(Error);
-      expect(err.message).toBe("string rejection");
-    });
-  });
-  describe("config edge cases", () => {
-    it("webhook-port is converted to number in channel config", () => {
-      const portStr = "3105";
-      const port = Number(portStr);
-      expect(port).toBe(3105);
-      expect(typeof port).toBe("number");
-    });
-    it("comma-separated values are split into arrays", () => {
-      const groups = "109,110,111";
-      const result = groups.split(",").map(Number);
-      expect(result).toEqual([109, 110, 111]);
-    });
-    it("empty allowed-numbers produces empty array", () => {
-      const allowedNumbers = undefined;
-      const result = allowedNumbers ? allowedNumbers.split(",") : [];
-      expect(result).toEqual([]);
-    });
-    it("channel name defaults to type-timestamp when not provided", () => {
-      const channelType = "telegram";
-      const name = undefined;
-      const channelName = name || `${channelType}-${Date.now()}`;
-      expect(channelName).toMatch(/^telegram-\d+$/);
-    });
-    it("default server URL is correct", () => {
-      const defaultServer = "https://whale-agent.fly.dev";
-      expect(defaultServer).toBe("https://whale-agent.fly.dev");
-    });
-  });
-});

package/dist/node/__tests__/cli-config.test.js

@@ -1,215 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-
-// ---------------------------------------------------------------------------
-// Mocks — intercept all side effects of cli.ts module-level code
-// ---------------------------------------------------------------------------
-
-vi.mock("../../cli/services/error-logger.js", () => ({
-  initErrorLogger: vi.fn(),
-  setErrorLoggerUser: vi.fn(),
-  captureError: vi.fn()
-}));
-vi.mock("../../cli/services/config-store.js", () => ({
-  loadConfig: vi.fn(() => ({}))
-}));
-const mockLoadConfig = vi.fn();
-const mockSaveConfig = vi.fn();
-const mockRequireConfig = vi.fn();
-const mockGetConfigPath = vi.fn(() => "/Users/test/.whaletools/config.json");
-vi.mock("../config.js", () => ({
-  loadConfig: (...args) => mockLoadConfig(...args),
-  saveConfig: (...args) => mockSaveConfig(...args),
-  requireConfig: (...args) => mockRequireConfig(...args),
-  getConfigPath: (...args) => mockGetConfigPath(...args)
-}));
-const {
-  mockRuntimeStart,
-  mockRuntimeStop
-} = vi.hoisted(() => ({
-  mockRuntimeStart: vi.fn().mockResolvedValue(undefined),
-  mockRuntimeStop: vi.fn()
-}));
-vi.mock("../runtime.js", () => ({
-  NodeRuntime: vi.fn().mockImplementation(function () {
-    return {
-      start: mockRuntimeStart,
-      stop: mockRuntimeStop
-    };
-  })
-}));
-const mockFetch = vi.fn();
-vi.stubGlobal("fetch", mockFetch);
-const consoleLogs = [];
-const consoleErrors = [];
-const origLog = console.log;
-const origError = console.error;
-const origWarn = console.warn;
-const mockExit = vi.spyOn(process, "exit").mockImplementation(() => {
-  throw new Error("process.exit called");
-});
-import { NodeRuntime } from "../runtime.js";
-
-// ---------------------------------------------------------------------------
-// Tests — config, register, start, status
-// ---------------------------------------------------------------------------
-describe("WhaleNode CLI — config and registration", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    consoleLogs.length = 0;
-    consoleErrors.length = 0;
-    console.log = (...args) => consoleLogs.push(args.join(" "));
-    console.error = (...args) => consoleErrors.push(args.join(" "));
-    console.warn = (...args) => {};
-  });
-  afterEach(() => {
-    console.log = origLog;
-    console.error = origError;
-    console.warn = origWarn;
-  });
-
-  // ====== Config module integration ======
-
-  describe("config loading", () => {
-    it("loadConfig returns null when no config file exists", () => {
-      mockLoadConfig.mockReturnValue(null);
-      expect(mockLoadConfig()).toBeNull();
-    });
-    it("loadConfig returns config object when file exists", () => {
-      const config = {
-        node_id: "node-1",
-        api_key: "key-1",
-        store_id: "store-1",
-        server_url: "https://server.example.com",
-        channels: []
-      };
-      mockLoadConfig.mockReturnValue(config);
-      expect(mockLoadConfig()).toEqual(config);
-    });
-    it("requireConfig calls process.exit(1) when no config", () => {
-      mockRequireConfig.mockImplementation(() => {
-        console.error("Not configured");
-        process.exit(1);
-      });
-      expect(() => mockRequireConfig()).toThrow("process.exit called");
-    });
-    it("getConfigPath returns the expected path", () => {
-      expect(mockGetConfigPath()).toBe("/Users/test/.whaletools/config.json");
-    });
-  });
-
-  // ====== node register command behavior ======
-
-  describe("node register flow", () => {
-    it("sends registration request to server", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          success: true,
-          node: {
-            id: "new-node-id"
-          },
-          api_key: "new-api-key"
-        })
-      });
-      const res = await mockFetch("https://whale-agent.fly.dev/nodes/register", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer test-jwt"
-        },
-        body: JSON.stringify({
-          name: "My Mac",
-          store_id: "store-1"
-        })
-      });
-      const data = await res.json();
-      expect(data.success).toBe(true);
-      expect(data.node.id).toBe("new-node-id");
-      expect(data.api_key).toBe("new-api-key");
-    });
-    it("saves config after successful registration", () => {
-      const config = {
-        node_id: "new-node-id",
-        api_key: "new-api-key",
-        store_id: "store-1",
-        server_url: "https://whale-agent.fly.dev",
-        channels: []
-      };
-      mockSaveConfig(config);
-      expect(mockSaveConfig).toHaveBeenCalledWith(config);
-    });
-    it("handles registration failure", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          success: false,
-          error: "Store not found"
-        })
-      });
-      const res = await mockFetch("https://test/nodes/register", {
-        method: "POST",
-        body: "{}"
-      });
-      const data = await res.json();
-      expect(data.success).toBe(false);
-      expect(data.error).toBe("Store not found");
-    });
-  });
-
-  // ====== node start command behavior ======
-
-  describe("node start flow", () => {
-    it("creates NodeRuntime with config and starts it", async () => {
-      const config = {
-        node_id: "node-1",
-        api_key: "key-1",
-        store_id: "store-1",
-        server_url: "https://server.example.com",
-        channels: []
-      };
-      mockRequireConfig.mockReturnValue(config);
-      const rt = new NodeRuntime(config);
-      await rt.start();
-      expect(NodeRuntime).toHaveBeenCalledWith(config);
-      expect(mockRuntimeStart).toHaveBeenCalled();
-    });
-  });
-
-  // ====== status command behavior ======
-
-  describe("status command flow", () => {
-    it("displays node status when configured", () => {
-      const config = {
-        node_id: "node-1",
-        api_key: "key-1",
-        store_id: "store-1",
-        server_url: "https://server.example.com",
-        channels: [{
-          id: "ch-1",
-          type: "telegram",
-          name: "TG",
-          config: {}
-        }]
-      };
-      mockLoadConfig.mockReturnValue(config);
-      const cfg = mockLoadConfig();
-      console.log("WhaleNode Status:");
-      console.log(`  Node ID:  ${cfg.node_id}`);
-      console.log(`  Store:    ${cfg.store_id}`);
-      console.log(`  Server:   ${cfg.server_url}`);
-      console.log(`  Channels: ${cfg.channels.length}`);
-      expect(consoleLogs).toContain("WhaleNode Status:");
-      expect(consoleLogs.some(l => l.includes("node-1"))).toBe(true);
-      expect(consoleLogs.some(l => l.includes("store-1"))).toBe(true);
-      expect(consoleLogs.some(l => l.includes("Channels: 1"))).toBe(true);
-    });
-    it("shows not-configured message when no config", () => {
-      mockLoadConfig.mockReturnValue(null);
-      const cfg = mockLoadConfig();
-      if (!cfg) {
-        console.log("Not configured. Run: whale node register");
-      }
-      expect(consoleLogs.some(l => l.includes("Not configured"))).toBe(true);
-    });
-  });
-});