whale-code 6.5.11 → 6.6.0

package/dist/server/__tests__/tool-router-registry.test.js

@@ -1,331 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// ---------------------------------------------------------------------------
-// Mocks — must be before imports
-// ---------------------------------------------------------------------------
-
-vi.mock("../../shared/agent-core.js", () => ({
-  sanitizeError: err => err instanceof Error ? err.message : String(err)
-}));
-vi.mock("../validation.js", () => ({
-  validateToolArgs: vi.fn((toolName, args) => ({
-    valid: true,
-    data: args
-  }))
-}));
-vi.mock("../lib/prompt-sanitizer.js", () => ({
-  sanitizeToolDescription: vi.fn(s => s || "")
-}));
-vi.mock("../lib/ssrf-guard.js", () => ({
-  validateUrl: vi.fn(async () => null)
-}));
-vi.mock("../lib/utils.js", () => ({
-  summarizeResult: vi.fn(() => ({
-    rows: 1
-  })),
-  withTimeout: vi.fn(async promise => promise)
-}));
-vi.mock("../handlers/inventory.js", () => ({
-  handleInventory: vi.fn(async () => ({
-    success: true,
-    data: {}
-  })),
-  handleInventoryQuery: vi.fn(async () => ({
-    success: true,
-    data: {}
-  })),
-  handleInventoryAudit: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/supply-chain.js", () => ({
-  handlePurchaseOrders: vi.fn(async () => ({
-    success: true,
-    data: {}
-  })),
-  handleTransfers: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/catalog.js", () => ({
-  handleProducts: vi.fn(async () => ({
-    success: true,
-    data: {}
-  })),
-  handleCollections: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/crm.js", () => ({
-  handleCustomers: vi.fn(async () => ({
-    success: true,
-    data: {}
-  })),
-  handleOrders: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/analytics.js", () => ({
-  handleAnalytics: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/operations.js", () => ({
-  handleLocations: vi.fn(async () => ({
-    success: true,
-    data: {}
-  })),
-  handleSuppliers: vi.fn(async () => ({
-    success: true,
-    data: {}
-  })),
-  handleAlerts: vi.fn(async () => ({
-    success: true,
-    data: {}
-  })),
-  handleAuditTrail: vi.fn(async () => ({
-    success: true,
-    data: {}
-  })),
-  handleStore: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/comms.js", () => ({
-  handleEmail: vi.fn(async () => ({
-    success: true,
-    data: {}
-  })),
-  handleDocuments: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/platform.js", () => ({
-  handleWebSearch: vi.fn(async () => ({
-    success: true,
-    data: {}
-  })),
-  handleTelemetry: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/browser.js", () => ({
-  handleBrowser: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/discovery.js", () => ({
-  handleDiscovery: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/voice.js", () => ({
-  handleVoice: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/workflows.js", () => ({
-  handleWorkflows: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/embeddings.js", () => ({
-  handleEmbeddings: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/llm-providers.js", () => ({
-  handleLLM: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/image-gen.js", () => ({
-  handleImageGen: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/video-gen.js", () => ({
-  handleVideoGen: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/api-keys.js", () => ({
-  handleAPIKeys: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/creations.js", () => ({
-  handleCreations: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/meta-ads.js", () => ({
-  handleMetaAds: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/kali.js", () => ({
-  handleKali: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/local-agent.js", () => ({
-  handleLocalAgent: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-vi.mock("../handlers/enrichment.js", () => ({
-  handleEnrichment: vi.fn(async () => ({
-    success: true,
-    data: {}
-  }))
-}));
-
-// ---------------------------------------------------------------------------
-// Import the module under test
-// ---------------------------------------------------------------------------
-
-import { flushSpans, getToolMetrics, TOOL_HANDLERS, getRegisteredToolNames, setExtendedToolsCache, getExtendedToolsCache, getExtendedToolsIndex, getFullToolSchemas } from "../tool-router.js";
-
-// ---------------------------------------------------------------------------
-// TESTS
-// ---------------------------------------------------------------------------
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-describe("TOOL_HANDLERS registry", () => {
-  it("is frozen and cannot be modified", () => {
-    expect(Object.isFrozen(TOOL_HANDLERS)).toBe(true);
-  });
-  it("contains all expected tool names", () => {
-    const names = getRegisteredToolNames();
-    expect(names).toContain("inventory");
-    expect(names).toContain("products");
-    expect(names).toContain("customers");
-    expect(names).toContain("orders");
-    expect(names).toContain("analytics");
-    expect(names).toContain("web_search");
-    expect(names).toContain("discover_tools");
-    expect(names).toContain("kali");
-    expect(names).toContain("local_agent");
-    expect(names).toContain("enrichment");
-  });
-  it("getRegisteredToolNames returns only string keys", () => {
-    const names = getRegisteredToolNames();
-    expect(names.length).toBeGreaterThan(10);
-    for (const n of names) {
-      expect(typeof n).toBe("string");
-    }
-  });
-  it("every entry has handler, timeout, and requiresStore", () => {
-    for (const [name, entry] of Object.entries(TOOL_HANDLERS)) {
-      expect(typeof entry.handler).toBe("function");
-      expect(typeof entry.timeout).toBe("number");
-      expect(typeof entry.requiresStore).toBe("boolean");
-    }
-  });
-  it("web_search does not require store", () => {
-    expect(TOOL_HANDLERS["web_search"].requiresStore).toBe(false);
-  });
-  it("inventory requires store", () => {
-    expect(TOOL_HANDLERS["inventory"].requiresStore).toBe(true);
-  });
-  it("kali has 600s timeout", () => {
-    expect(TOOL_HANDLERS["kali"].timeout).toBe(600_000);
-  });
-  it("discover_tools has 5s timeout", () => {
-    expect(TOOL_HANDLERS["discover_tools"].timeout).toBe(5000);
-  });
-});
-describe("getToolMetrics", () => {
-  it("returns an object (may be empty or populated from other tests)", () => {
-    const metrics = getToolMetrics();
-    expect(typeof metrics).toBe("object");
-  });
-});
-describe("flushSpans", () => {
-  it("does nothing when buffer is empty", async () => {
-    await flushSpans();
-  });
-});
-describe("extended tools cache", () => {
-  it("setExtendedToolsCache populates cache and index", () => {
-    const tools = [{
-      name: "kali",
-      description: "Security scanner. Advanced pentesting.",
-      input_schema: {
-        type: "object"
-      }
-    }, {
-      name: "browser",
-      description: "Web browser automation.",
-      input_schema: {
-        type: "object"
-      }
-    }];
-    setExtendedToolsCache(tools);
-    expect(getExtendedToolsCache()).toEqual(tools);
-    const index = getExtendedToolsIndex();
-    expect(index).toHaveLength(2);
-    expect(index[0].description).toBe("Security scanner");
-    expect(index[1].description).toBe("Web browser automation");
-  });
-  it("getFullToolSchemas filters by name", () => {
-    const tools = [{
-      name: "kali",
-      description: "Security",
-      input_schema: {
-        type: "object"
-      }
-    }, {
-      name: "browser",
-      description: "Browser",
-      input_schema: {
-        type: "object"
-      }
-    }, {
-      name: "voice",
-      description: "Voice",
-      input_schema: {
-        type: "object"
-      }
-    }];
-    setExtendedToolsCache(tools);
-    const result = getFullToolSchemas(["kali", "voice"]);
-    expect(result).toHaveLength(2);
-    expect(result.map(t => t.name)).toEqual(["kali", "voice"]);
-  });
-  it("getFullToolSchemas returns empty for empty names", () => {
-    expect(getFullToolSchemas([])).toEqual([]);
-  });
-  it("getFullToolSchemas skips unknown names", () => {
-    setExtendedToolsCache([{
-      name: "kali",
-      description: "x",
-      input_schema: {}
-    }]);
-    expect(getFullToolSchemas(["nonexistent"])).toEqual([]);
-  });
-});

package/dist/server/__tests__/validation-inventory.test.js

@@ -1,250 +0,0 @@
-/**
- * Tests for validateToolArgs — passthrough behavior and inventory mutations
- * (adjust, set, transfer, bulk_set, bulk_adjust, bulk_clear).
- */
-
-import { describe, it, expect } from "vitest";
-import { validateToolArgs } from "../validation.js";
-
-// ============================================================================
-// HELPERS
-// ============================================================================
-
-const VALID_UUID = "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11";
-const VALID_UUID_2 = "b1eebc99-9c0b-4ef8-bb6d-6bb9bd380a22";
-const VALID_UUID_3 = "c2eebc99-9c0b-4ef8-bb6d-6bb9bd380a33";
-function expectValid(result) {
-  expect(result.valid).toBe(true);
-}
-function expectInvalid(result) {
-  expect(result.valid).toBe(false);
-}
-
-// ============================================================================
-// PASSTHROUGH BEHAVIOR
-// ============================================================================
-
-describe("validateToolArgs passthrough", () => {
-  it("passes through when no action param is provided", () => {
-    const result = validateToolArgs("inventory", {
-      product_id: "foo"
-    });
-    expectValid(result);
-    expect(result.data).toEqual({
-      product_id: "foo"
-    });
-  });
-  it("passes through for unregistered tools", () => {
-    const result = validateToolArgs("analytics", {
-      action: "query",
-      range: "7d"
-    });
-    expectValid(result);
-    expect(result.data).toEqual({
-      action: "query",
-      range: "7d"
-    });
-  });
-  it("passes through for unregistered actions on registered tools", () => {
-    const result = validateToolArgs("inventory", {
-      action: "find",
-      query: "test"
-    });
-    expectValid(result);
-    expect(result.data).toEqual({
-      action: "find",
-      query: "test"
-    });
-  });
-});
-
-// ============================================================================
-// INVENTORY MUTATIONS
-// ============================================================================
-
-describe("inventory adjust", () => {
-  it("validates correct adjust input", () => {
-    const result = validateToolArgs("inventory", {
-      action: "adjust",
-      product_id: VALID_UUID,
-      location_id: VALID_UUID_2,
-      adjustment: -5
-    });
-    expectValid(result);
-    expect(result.data.adjustment).toBe(-5);
-  });
-  it("allows optional reason field", () => {
-    const result = validateToolArgs("inventory", {
-      action: "adjust",
-      product_id: VALID_UUID,
-      location_id: VALID_UUID_2,
-      adjustment: 10,
-      reason: "recount"
-    });
-    expectValid(result);
-    expect(result.data.reason).toBe("recount");
-  });
-  it("rejects non-UUID product_id", () => {
-    const result = validateToolArgs("inventory", {
-      action: "adjust",
-      product_id: "not-a-uuid",
-      location_id: VALID_UUID_2,
-      adjustment: 5
-    });
-    expectInvalid(result);
-    expect(result.error).toContain("product_id");
-  });
-  it("rejects missing adjustment", () => {
-    const result = validateToolArgs("inventory", {
-      action: "adjust",
-      product_id: VALID_UUID,
-      location_id: VALID_UUID_2
-    });
-    expectInvalid(result);
-    expect(result.error).toContain("adjustment");
-  });
-  it("rejects string adjustment", () => {
-    const result = validateToolArgs("inventory", {
-      action: "adjust",
-      product_id: VALID_UUID,
-      location_id: VALID_UUID_2,
-      adjustment: "five"
-    });
-    expectInvalid(result);
-  });
-});
-describe("inventory set", () => {
-  it("validates correct set input", () => {
-    const result = validateToolArgs("inventory", {
-      action: "set",
-      product_id: VALID_UUID,
-      location_id: VALID_UUID_2,
-      quantity: 100
-    });
-    expectValid(result);
-  });
-  it("allows zero quantity", () => {
-    const result = validateToolArgs("inventory", {
-      action: "set",
-      product_id: VALID_UUID,
-      location_id: VALID_UUID_2,
-      quantity: 0
-    });
-    expectValid(result);
-  });
-  it("rejects negative quantity", () => {
-    const result = validateToolArgs("inventory", {
-      action: "set",
-      product_id: VALID_UUID,
-      location_id: VALID_UUID_2,
-      quantity: -1
-    });
-    expectInvalid(result);
-  });
-});
-describe("inventory transfer", () => {
-  it("validates correct transfer input", () => {
-    const result = validateToolArgs("inventory", {
-      action: "transfer",
-      product_id: VALID_UUID,
-      from_location_id: VALID_UUID_2,
-      to_location_id: VALID_UUID_3,
-      quantity: 10
-    });
-    expectValid(result);
-  });
-  it("rejects zero quantity", () => {
-    const result = validateToolArgs("inventory", {
-      action: "transfer",
-      product_id: VALID_UUID,
-      from_location_id: VALID_UUID_2,
-      to_location_id: VALID_UUID_3,
-      quantity: 0
-    });
-    expectInvalid(result);
-  });
-  it("rejects negative quantity", () => {
-    const result = validateToolArgs("inventory", {
-      action: "transfer",
-      product_id: VALID_UUID,
-      from_location_id: VALID_UUID_2,
-      to_location_id: VALID_UUID_3,
-      quantity: -5
-    });
-    expectInvalid(result);
-  });
-});
-describe("inventory bulk_set", () => {
-  it("validates correct bulk_set input", () => {
-    const result = validateToolArgs("inventory", {
-      action: "bulk_set",
-      items: [{
-        product_id: VALID_UUID,
-        location_id: VALID_UUID_2,
-        quantity: 10
-      }, {
-        product_id: VALID_UUID_3,
-        location_id: VALID_UUID_2,
-        quantity: 0
-      }]
-    });
-    expectValid(result);
-  });
-  it("rejects empty items array", () => {
-    const result = validateToolArgs("inventory", {
-      action: "bulk_set",
-      items: []
-    });
-    expectInvalid(result);
-  });
-  it("rejects items with invalid UUIDs", () => {
-    const result = validateToolArgs("inventory", {
-      action: "bulk_set",
-      items: [{
-        product_id: "bad",
-        location_id: VALID_UUID_2,
-        quantity: 10
-      }]
-    });
-    expectInvalid(result);
-  });
-});
-describe("inventory bulk_adjust", () => {
-  it("validates correct bulk_adjust input", () => {
-    const result = validateToolArgs("inventory", {
-      action: "bulk_adjust",
-      items: [{
-        product_id: VALID_UUID,
-        location_id: VALID_UUID_2,
-        adjustment: 5
-      }, {
-        product_id: VALID_UUID_3,
-        location_id: VALID_UUID_2,
-        adjustment: -3
-      }]
-    });
-    expectValid(result);
-  });
-  it("rejects empty items array", () => {
-    const result = validateToolArgs("inventory", {
-      action: "bulk_adjust",
-      items: []
-    });
-    expectInvalid(result);
-  });
-});
-describe("inventory bulk_clear", () => {
-  it("validates correct bulk_clear input", () => {
-    const result = validateToolArgs("inventory", {
-      action: "bulk_clear",
-      location_id: VALID_UUID
-    });
-    expectValid(result);
-  });
-  it("rejects missing location_id", () => {
-    const result = validateToolArgs("inventory", {
-      action: "bulk_clear"
-    });
-    expectInvalid(result);
-  });
-});