whale-code 6.5.6 → 6.5.7

package/dist/cli/services/__tests__/server-tools-execute.test.js

@@ -0,0 +1,317 @@
+/**
+ * Tests for server-tools.ts — isServerTool, getAllServerToolDefinitions, getServerStatus, executeServerTool
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// -- Mocks --
+
+const mockFrom = vi.fn();
+const mockClient = {
+  from: mockFrom
+};
+vi.mock("@supabase/supabase-js", () => ({
+  createClient: vi.fn(() => mockClient)
+}));
+vi.mock("../config-store.js", () => ({
+  resolveConfig: vi.fn(() => ({
+    supabaseUrl: "https://test.supabase.co",
+    supabaseKey: "test-key",
+    storeId: "store-1",
+    serverUrl: "https://server.example.com/api",
+    store_id: "store-1",
+    store_name: "Test Store"
+  })),
+  loadConfig: vi.fn(() => ({
+    store_id: "store-1",
+    store_name: "Test Store"
+  }))
+}));
+vi.mock("../auth-service.js", () => ({
+  getValidToken: vi.fn(async () => "mock-jwt-token"),
+  createAuthenticatedClient: vi.fn(() => mockClient)
+}));
+vi.mock("../format-server-response.js", () => ({
+  formatServerResponse: vi.fn(data => JSON.stringify(data))
+}));
+
+// Mock global fetch
+const mockFetch = vi.fn();
+vi.stubGlobal("fetch", mockFetch);
+import { setServerToolContext, resetServerToolClient, isServerTool, getAllServerToolDefinitions, getServerStatus, executeServerTool, loadServerToolDefinitions } from "../server-tools.js";
+describe("server-tools — query, status, execute", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetServerToolClient();
+  });
+
+  // ═══════════════════════════════════════════════════════════════════
+  // isServerTool
+  // ═══════════════════════════════════════════════════════════════════
+
+  describe("isServerTool", () => {
+    it("returns false before loading", () => {
+      expect(isServerTool("voice")).toBe(false);
+    });
+    it("returns true after loading tools", async () => {
+      mockFrom.mockReturnValueOnce({
+        select: vi.fn().mockReturnValue({
+          eq: vi.fn().mockReturnValue({
+            neq: vi.fn().mockResolvedValue({
+              data: [{
+                name: "voice",
+                description: "d",
+                definition: {
+                  input_schema: {
+                    type: "object",
+                    properties: {}
+                  }
+                }
+              }],
+              error: null
+            })
+          })
+        })
+      });
+      await loadServerToolDefinitions();
+      expect(isServerTool("voice")).toBe(true);
+      expect(isServerTool("nonexistent")).toBe(false);
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════
+  // getAllServerToolDefinitions
+  // ═══════════════════════════════════════════════════════════════════
+
+  describe("getAllServerToolDefinitions", () => {
+    it("returns empty array initially", () => {
+      expect(getAllServerToolDefinitions()).toEqual([]);
+    });
+    it("returns loaded tools after loadServerToolDefinitions", async () => {
+      mockFrom.mockReturnValueOnce({
+        select: vi.fn().mockReturnValue({
+          eq: vi.fn().mockReturnValue({
+            neq: vi.fn().mockResolvedValue({
+              data: [{
+                name: "t1",
+                description: "d1",
+                definition: {
+                  input_schema: {
+                    type: "object",
+                    properties: {}
+                  }
+                }
+              }, {
+                name: "t2",
+                description: "d2",
+                definition: {
+                  input_schema: {
+                    type: "object",
+                    properties: {}
+                  }
+                }
+              }],
+              error: null
+            })
+          })
+        })
+      });
+      await loadServerToolDefinitions();
+      const defs = getAllServerToolDefinitions();
+      expect(defs).toHaveLength(2);
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════
+  // getServerStatus
+  // ═══════════════════════════════════════════════════════════════════
+
+  describe("getServerStatus", () => {
+    it("returns connected status when tools load", async () => {
+      mockFrom.mockReturnValueOnce({
+        select: vi.fn().mockReturnValue({
+          eq: vi.fn().mockReturnValue({
+            neq: vi.fn().mockResolvedValue({
+              data: [{
+                name: "t1",
+                description: "d",
+                definition: {
+                  input_schema: {
+                    type: "object",
+                    properties: {}
+                  }
+                }
+              }],
+              error: null
+            })
+          })
+        })
+      });
+      const status = await getServerStatus();
+      expect(status.connected).toBe(true);
+      expect(status.toolCount).toBe(1);
+      expect(status.storeId).toBe("store-1");
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════
+  // executeServerTool
+  // ═══════════════════════════════════════════════════════════════════
+
+  describe("executeServerTool", () => {
+    it("returns error when no server URL configured", async () => {
+      const configMod = await import("../config-store.js");
+      vi.mocked(configMod.resolveConfig).mockReturnValueOnce({});
+      const result = await executeServerTool("voice", {
+        text: "hello"
+      });
+      expect(result.success).toBe(false);
+      expect(result.output).toContain("No server URL configured");
+    });
+    it("returns error when no auth token available", async () => {
+      const configMod = await import("../config-store.js");
+      vi.mocked(configMod.resolveConfig).mockReturnValueOnce({
+        serverUrl: "https://x.com"
+      });
+      const authMod = await import("../auth-service.js");
+      vi.mocked(authMod.getValidToken).mockResolvedValueOnce(null);
+      const result = await executeServerTool("voice", {
+        text: "hello"
+      });
+      expect(result.success).toBe(false);
+      expect(result.output).toContain("No auth token");
+    });
+    it("executes a standard tool and returns success", async () => {
+      mockFetch.mockResolvedValueOnce({
+        json: vi.fn().mockResolvedValue({
+          success: true,
+          data: {
+            result: "ok"
+          }
+        })
+      });
+      const result = await executeServerTool("my_tool", {
+        arg: "val"
+      });
+      expect(result.success).toBe(true);
+      expect(mockFetch).toHaveBeenCalledWith("https://server.example.com/api", expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "Content-Type": "application/json",
+          Authorization: "Bearer test-key"
+        })
+      }));
+    });
+    it("returns string data directly", async () => {
+      mockFetch.mockResolvedValueOnce({
+        json: vi.fn().mockResolvedValue({
+          success: true,
+          data: "plain text result"
+        })
+      });
+      const result = await executeServerTool("my_tool", {});
+      expect(result.success).toBe(true);
+      expect(result.output).toBe("plain text result");
+    });
+    it("returns error message from failed response", async () => {
+      mockFetch.mockResolvedValueOnce({
+        json: vi.fn().mockResolvedValue({
+          success: false,
+          error: "Tool not found"
+        })
+      });
+      const result = await executeServerTool("bad_tool", {});
+      expect(result.success).toBe(false);
+      expect(result.output).toBe("Tool not found");
+    });
+    it("extracts nested error when top-level error is missing", async () => {
+      mockFetch.mockResolvedValueOnce({
+        json: vi.fn().mockResolvedValue({
+          success: false,
+          data: {
+            error: "nested error msg"
+          }
+        })
+      });
+      const result = await executeServerTool("bad_tool", {});
+      expect(result.success).toBe(false);
+      expect(result.output).toBe("nested error msg");
+    });
+    it("returns fallback message for success=false without error", async () => {
+      mockFetch.mockResolvedValueOnce({
+        json: vi.fn().mockResolvedValue({
+          success: false
+        })
+      });
+      const result = await executeServerTool("bad_tool", {});
+      expect(result.success).toBe(false);
+      expect(result.output).toContain("returned success=false");
+    });
+    it("catches network errors", async () => {
+      mockFetch.mockRejectedValueOnce(new Error("Network failure"));
+      const result = await executeServerTool("my_tool", {});
+      expect(result.success).toBe(false);
+      expect(result.output).toContain("Network failure");
+    });
+    it("truncates output exceeding safety max", async () => {
+      const hugeData = "x".repeat(600_000);
+      mockFetch.mockResolvedValueOnce({
+        json: vi.fn().mockResolvedValue({
+          success: true,
+          data: hugeData
+        })
+      });
+      const result = await executeServerTool("my_tool", {});
+      expect(result.success).toBe(true);
+      expect(result.output.length).toBeLessThan(600_000);
+      expect(result.output).toContain("safety truncated");
+    });
+    it("sends execution context headers in body", async () => {
+      setServerToolContext({
+        traceId: "t-123",
+        userId: "u-1"
+      });
+      mockFetch.mockResolvedValueOnce({
+        json: vi.fn().mockResolvedValue({
+          success: true,
+          data: "ok"
+        })
+      });
+      await executeServerTool("test_tool", {
+        a: 1
+      });
+      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+      expect(body.trace_id).toBe("t-123");
+      expect(body.userId).toBe("u-1");
+      expect(body.mode).toBe("tool");
+      expect(body.tool_name).toBe("test_tool");
+    });
+    it("handles voice tool with file_paths pre-processing that fail to read", async () => {
+      mockFetch.mockResolvedValueOnce({
+        json: vi.fn().mockResolvedValue({
+          success: true,
+          data: "voiced"
+        })
+      });
+
+      // Calling with no file_paths — just args — should proceed normally
+      const result = await executeServerTool("voice", {
+        action: "speak",
+        text: "hello there"
+      });
+      expect(result.success).toBe(true);
+    });
+    it("includes store_id in request body when configured", async () => {
+      mockFetch.mockResolvedValueOnce({
+        json: vi.fn().mockResolvedValue({
+          success: true,
+          data: "ok"
+        })
+      });
+      await executeServerTool("test_tool", {
+        x: 1
+      });
+      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+      expect(body.store_id).toBe("store-1");
+    });
+  });
+});

package/dist/cli/services/__tests__/server-tools.test.js

@@ -0,0 +1,272 @@
+/**
+ * Tests for server-tools.ts — context, reset, connection, loading
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// -- Mocks --
+
+const mockFrom = vi.fn();
+const mockClient = {
+  from: mockFrom
+};
+vi.mock("@supabase/supabase-js", () => ({
+  createClient: vi.fn(() => mockClient)
+}));
+vi.mock("../config-store.js", () => ({
+  resolveConfig: vi.fn(() => ({
+    supabaseUrl: "https://test.supabase.co",
+    supabaseKey: "test-key",
+    storeId: "store-1",
+    serverUrl: "https://server.example.com/api",
+    store_id: "store-1",
+    store_name: "Test Store"
+  })),
+  loadConfig: vi.fn(() => ({
+    store_id: "store-1",
+    store_name: "Test Store"
+  }))
+}));
+vi.mock("../auth-service.js", () => ({
+  getValidToken: vi.fn(async () => "mock-jwt-token"),
+  createAuthenticatedClient: vi.fn(() => mockClient)
+}));
+vi.mock("../format-server-response.js", () => ({
+  formatServerResponse: vi.fn(data => JSON.stringify(data))
+}));
+
+// Mock global fetch
+const mockFetch = vi.fn();
+vi.stubGlobal("fetch", mockFetch);
+import { setServerToolContext, resetServerToolClient, checkConnection, loadServerToolDefinitions, isServerTool } from "../server-tools.js";
+describe("server-tools — context, reset, connection, loading", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetServerToolClient();
+  });
+
+  // ═══════════════════════════════════════════════════════════════════
+  // setServerToolContext
+  // ═══════════════════════════════════════════════════════════════════
+
+  describe("setServerToolContext", () => {
+    it("sets context without error", () => {
+      expect(() => {
+        setServerToolContext({
+          traceId: "trace-1",
+          conversationId: "conv-1",
+          userId: "user-1",
+          source: "test"
+        });
+      }).not.toThrow();
+    });
+    it("accepts an empty context", () => {
+      expect(() => setServerToolContext({})).not.toThrow();
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════
+  // resetServerToolClient
+  // ═══════════════════════════════════════════════════════════════════
+
+  describe("resetServerToolClient", () => {
+    it("resets state without error", () => {
+      expect(() => resetServerToolClient()).not.toThrow();
+    });
+    it("clears loaded tools so isServerTool returns false", () => {
+      resetServerToolClient();
+      expect(isServerTool("some_tool")).toBe(false);
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════
+  // checkConnection
+  // ═══════════════════════════════════════════════════════════════════
+
+  describe("checkConnection", () => {
+    it("returns true when Supabase query succeeds", async () => {
+      mockFrom.mockReturnValueOnce({
+        select: vi.fn().mockReturnValue({
+          limit: vi.fn().mockResolvedValue({
+            error: null
+          })
+        })
+      });
+      const ok = await checkConnection();
+      expect(ok).toBe(true);
+    });
+    it("returns false when Supabase query fails", async () => {
+      mockFrom.mockReturnValueOnce({
+        select: vi.fn().mockReturnValue({
+          limit: vi.fn().mockResolvedValue({
+            error: {
+              message: "fail"
+            }
+          })
+        })
+      });
+      const ok = await checkConnection();
+      expect(ok).toBe(false);
+    });
+    it("returns cached true on subsequent calls after success", async () => {
+      mockFrom.mockReturnValueOnce({
+        select: vi.fn().mockReturnValue({
+          limit: vi.fn().mockResolvedValue({
+            error: null
+          })
+        })
+      });
+      await checkConnection();
+      // second call should return true without another DB call
+      const ok2 = await checkConnection();
+      expect(ok2).toBe(true);
+      expect(mockFrom).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════
+  // loadServerToolDefinitions
+  // ═══════════════════════════════════════════════════════════════════
+
+  describe("loadServerToolDefinitions", () => {
+    it("loads tools from ai_tool_registry", async () => {
+      mockFrom.mockReturnValueOnce({
+        select: vi.fn().mockReturnValue({
+          eq: vi.fn().mockReturnValue({
+            neq: vi.fn().mockResolvedValue({
+              data: [{
+                name: "voice",
+                description: "Voice tool",
+                definition: {
+                  description: "Voice tool desc",
+                  input_schema: {
+                    type: "object",
+                    properties: {
+                      text: {
+                        type: "string"
+                      }
+                    }
+                  }
+                }
+              }, {
+                name: "image_gen",
+                description: "Image generation",
+                definition: {
+                  input_schema: {
+                    type: "object",
+                    properties: {}
+                  }
+                }
+              }],
+              error: null
+            })
+          })
+        })
+      });
+      const tools = await loadServerToolDefinitions();
+      expect(tools).toHaveLength(2);
+      expect(tools[0].name).toBe("voice");
+      expect(tools[1].name).toBe("image_gen");
+    });
+    it("returns cached tools on second call within TTL", async () => {
+      mockFrom.mockReturnValueOnce({
+        select: vi.fn().mockReturnValue({
+          eq: vi.fn().mockReturnValue({
+            neq: vi.fn().mockResolvedValue({
+              data: [{
+                name: "t1",
+                description: "d",
+                definition: {
+                  input_schema: {
+                    type: "object",
+                    properties: {}
+                  }
+                }
+              }],
+              error: null
+            })
+          })
+        })
+      });
+      await loadServerToolDefinitions();
+      const tools2 = await loadServerToolDefinitions();
+      expect(tools2).toHaveLength(1);
+      expect(mockFrom).toHaveBeenCalledTimes(1);
+    });
+    it("force-reloads when force=true", async () => {
+      const mockChain = () => ({
+        select: vi.fn().mockReturnValue({
+          eq: vi.fn().mockReturnValue({
+            neq: vi.fn().mockResolvedValue({
+              data: [{
+                name: "forced",
+                description: "d",
+                definition: {
+                  input_schema: {
+                    type: "object",
+                    properties: {}
+                  }
+                }
+              }],
+              error: null
+            })
+          })
+        })
+      });
+      mockFrom.mockReturnValueOnce(mockChain()).mockReturnValueOnce(mockChain());
+      await loadServerToolDefinitions();
+      const tools2 = await loadServerToolDefinitions(true);
+      expect(tools2[0].name).toBe("forced");
+      expect(mockFrom).toHaveBeenCalledTimes(2);
+    });
+    it("returns empty array when no client available", async () => {
+      // Reset and mock config with no credentials
+      resetServerToolClient();
+      const configMod = await import("../config-store.js");
+      vi.mocked(configMod.resolveConfig).mockReturnValueOnce({});
+      const authMod = await import("../auth-service.js");
+      vi.mocked(authMod.getValidToken).mockResolvedValueOnce(null);
+      const tools = await loadServerToolDefinitions(true);
+      expect(tools).toEqual([]);
+    });
+    it("returns stale cache on DB error", async () => {
+      // Load initial data
+      mockFrom.mockReturnValueOnce({
+        select: vi.fn().mockReturnValue({
+          eq: vi.fn().mockReturnValue({
+            neq: vi.fn().mockResolvedValue({
+              data: [{
+                name: "cached",
+                description: "d",
+                definition: {
+                  input_schema: {
+                    type: "object",
+                    properties: {}
+                  }
+                }
+              }],
+              error: null
+            })
+          })
+        })
+      });
+      await loadServerToolDefinitions();
+
+      // Force reload triggers error
+      mockFrom.mockReturnValueOnce({
+        select: vi.fn().mockReturnValue({
+          eq: vi.fn().mockReturnValue({
+            neq: vi.fn().mockResolvedValue({
+              data: null,
+              error: {
+                message: "DB error"
+              }
+            })
+          })
+        })
+      });
+      const tools = await loadServerToolDefinitions(true);
+      expect(tools).toHaveLength(1);
+      expect(tools[0].name).toBe("cached");
+    });
+  });
+});