whale-code 6.5.10 → 6.6.0

package/dist/server/handlers/local-agent.tools-status.test.js

@@ -1,204 +0,0 @@
-// local-agent.test.ts — Tests for handleLocalAgent: tools, discover, status, info, agents
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { HAS_TEST_DB, getTestClient, cleanup, TEST_STORE } from "./__test-utils__/test-db.js";
-
-// ---------------------------------------------------------------------------
-// Mock the local-agent-gateway module — vi.hoisted for hoist-safe references
-// ---------------------------------------------------------------------------
-
-const {
-  mockHasLocalAgent,
-  mockGetAgentInfo,
-  mockExecuteOnLocalAgent,
-  mockExecuteToolOnLocalAgent,
-  mockDiscoverLocalTools,
-  mockGetGatewayStats
-} = vi.hoisted(() => ({
-  mockHasLocalAgent: vi.fn(),
-  mockGetAgentInfo: vi.fn(),
-  mockExecuteOnLocalAgent: vi.fn(),
-  mockExecuteToolOnLocalAgent: vi.fn(),
-  mockDiscoverLocalTools: vi.fn(),
-  mockGetGatewayStats: vi.fn()
-}));
-vi.mock("../local-agent-gateway.js", () => ({
-  hasLocalAgent: mockHasLocalAgent,
-  getAgentInfo: mockGetAgentInfo,
-  executeOnLocalAgent: mockExecuteOnLocalAgent,
-  executeToolOnLocalAgent: mockExecuteToolOnLocalAgent,
-  discoverLocalTools: mockDiscoverLocalTools,
-  getGatewayStats: mockGetGatewayStats
-}));
-import { handleLocalAgent } from "./local-agent.js";
-const sb = getTestClient();
-describe.skipIf(!HAS_TEST_DB)("handleLocalAgent — tools, status, agents", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockHasLocalAgent.mockReturnValue(true);
-    mockGetAgentInfo.mockReturnValue([{
-      agent_id: "agent-001",
-      hostname: "devbox",
-      platform: "darwin",
-      capabilities: ["exec", "burp", "zap"]
-    }]);
-    mockExecuteOnLocalAgent.mockResolvedValue({
-      success: true,
-      stdout: "command output",
-      stderr: "",
-      exit_code: 0
-    });
-    mockExecuteToolOnLocalAgent.mockResolvedValue({
-      success: true,
-      result: "tool output"
-    });
-    mockDiscoverLocalTools.mockResolvedValue({
-      success: true,
-      tools: ["burp", "zap", "tshark"]
-    });
-    mockGetGatewayStats.mockReturnValue({
-      total_agents: 3,
-      stores: 2,
-      uptime_ms: 123456
-    });
-  });
-  afterEach(async () => {
-    await cleanup();
-  });
-  describe("action: tools", () => {
-    it("lists available tools when no tool argument provided", async () => {
-      const result = await handleLocalAgent(sb, {
-        action: "tools"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-      const data = result.data;
-      expect(data.tools).toBeDefined();
-      expect(data.tools.length).toBe(3);
-      expect(data.agents).toBe(1);
-      expect(data.message).toContain("local tools available");
-    });
-    it("returns no-agent message when listing tools with no agent connected", async () => {
-      mockHasLocalAgent.mockReturnValue(false);
-      const result = await handleLocalAgent(sb, {
-        action: "tools"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("No local agent connected");
-    });
-    it("executes a specific tool on the local agent", async () => {
-      const result = await handleLocalAgent(sb, {
-        action: "tools",
-        tool: "burp",
-        tool_args: {
-          target: "https://example.com",
-          scan_type: "passive"
-        }
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-      expect(mockExecuteToolOnLocalAgent).toHaveBeenCalledWith(TEST_STORE, "burp", {
-        target: "https://example.com",
-        scan_type: "passive"
-      }, expect.objectContaining({
-        timeout: 60000
-      }));
-    });
-    it("returns no-agent message when executing tool with no agent connected", async () => {
-      mockHasLocalAgent.mockReturnValue(false);
-      const result = await handleLocalAgent(sb, {
-        action: "tools",
-        tool: "zap"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("No local agent connected");
-    });
-    it("deduplicates tools across multiple agents", async () => {
-      mockGetAgentInfo.mockReturnValue([{
-        agent_id: "a1",
-        hostname: "box1",
-        platform: "linux",
-        capabilities: ["exec", "burp"]
-      }, {
-        agent_id: "a2",
-        hostname: "box2",
-        platform: "linux",
-        capabilities: ["exec", "zap"]
-      }]);
-      const result = await handleLocalAgent(sb, {
-        action: "tools"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-      const data = result.data;
-      const tools = data.tools;
-      // "exec" should appear only once (Set dedup)
-      expect(tools.filter(t => t === "exec").length).toBe(1);
-      expect(tools.length).toBe(3); // exec, burp, zap
-      expect(data.agents).toBe(2);
-    });
-  });
-  describe("action: discover", () => {
-    it("triggers tool discovery on the local agent", async () => {
-      const result = await handleLocalAgent(sb, {
-        action: "discover"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-      expect(mockDiscoverLocalTools).toHaveBeenCalledWith(TEST_STORE);
-    });
-    it("returns no-agent message when no agent is connected for discover", async () => {
-      mockHasLocalAgent.mockReturnValue(false);
-      const result = await handleLocalAgent(sb, {
-        action: "discover"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("No local agent connected");
-    });
-  });
-  describe("action: status", () => {
-    it("returns connected status when agent is connected", async () => {
-      const result = await handleLocalAgent(sb, {
-        action: "status"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-      const data = result.data;
-      expect(data.connected).toBe(true);
-      expect(data.agents).toBeDefined();
-      expect(data.message).toContain("agent(s) connected");
-    });
-    it("returns disconnected status when no agent is connected", async () => {
-      mockHasLocalAgent.mockReturnValue(false);
-      mockGetAgentInfo.mockReturnValue([]);
-      const result = await handleLocalAgent(sb, {
-        action: "status"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-      const data = result.data;
-      expect(data.connected).toBe(false);
-      expect(data.message).toContain("No local agent connected");
-      expect(data.message).toContain("whale agent start");
-    });
-  });
-  describe("action: info", () => {
-    it("returns the same data as status (aliases)", async () => {
-      const statusResult = await handleLocalAgent(sb, {
-        action: "status"
-      }, TEST_STORE);
-      const infoResult = await handleLocalAgent(sb, {
-        action: "info"
-      }, TEST_STORE);
-      expect(statusResult.success).toBe(true);
-      expect(infoResult.success).toBe(true);
-      expect(statusResult.data.connected).toBe(infoResult.data.connected);
-    });
-  });
-  describe("action: agents", () => {
-    it("returns gateway-wide agent stats", async () => {
-      const result = await handleLocalAgent(sb, {
-        action: "agents"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-      expect(mockGetGatewayStats).toHaveBeenCalled();
-      const data = result.data;
-      expect(data.total_agents).toBe(3);
-      expect(data.stores).toBe(2);
-    });
-  });
-});

package/dist/server/handlers/local-agent.validation-exec.test.js

@@ -1,182 +0,0 @@
-// local-agent.test.ts — Tests for handleLocalAgent: validation + exec actions
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { HAS_TEST_DB, getTestClient, cleanup, TEST_STORE } from "./__test-utils__/test-db.js";
-
-// ---------------------------------------------------------------------------
-// Mock the local-agent-gateway module — vi.hoisted for hoist-safe references
-// ---------------------------------------------------------------------------
-
-const {
-  mockHasLocalAgent,
-  mockGetAgentInfo,
-  mockExecuteOnLocalAgent,
-  mockExecuteToolOnLocalAgent,
-  mockDiscoverLocalTools,
-  mockGetGatewayStats
-} = vi.hoisted(() => ({
-  mockHasLocalAgent: vi.fn(),
-  mockGetAgentInfo: vi.fn(),
-  mockExecuteOnLocalAgent: vi.fn(),
-  mockExecuteToolOnLocalAgent: vi.fn(),
-  mockDiscoverLocalTools: vi.fn(),
-  mockGetGatewayStats: vi.fn()
-}));
-vi.mock("../local-agent-gateway.js", () => ({
-  hasLocalAgent: mockHasLocalAgent,
-  getAgentInfo: mockGetAgentInfo,
-  executeOnLocalAgent: mockExecuteOnLocalAgent,
-  executeToolOnLocalAgent: mockExecuteToolOnLocalAgent,
-  discoverLocalTools: mockDiscoverLocalTools,
-  getGatewayStats: mockGetGatewayStats
-}));
-import { handleLocalAgent } from "./local-agent.js";
-const sb = getTestClient();
-describe.skipIf(!HAS_TEST_DB)("handleLocalAgent — validation + exec", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockHasLocalAgent.mockReturnValue(true);
-    mockGetAgentInfo.mockReturnValue([{
-      agent_id: "agent-001",
-      hostname: "devbox",
-      platform: "darwin",
-      capabilities: ["exec", "burp", "zap"]
-    }]);
-    mockExecuteOnLocalAgent.mockResolvedValue({
-      success: true,
-      stdout: "command output",
-      stderr: "",
-      exit_code: 0
-    });
-    mockExecuteToolOnLocalAgent.mockResolvedValue({
-      success: true,
-      result: "tool output"
-    });
-    mockDiscoverLocalTools.mockResolvedValue({
-      success: true,
-      tools: ["burp", "zap", "tshark"]
-    });
-    mockGetGatewayStats.mockReturnValue({
-      total_agents: 3,
-      stores: 2,
-      uptime_ms: 123456
-    });
-  });
-  afterEach(async () => {
-    await cleanup();
-  });
-  describe("parameter validation", () => {
-    it("returns error when action is missing", async () => {
-      const result = await handleLocalAgent(sb, {}, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("action is required");
-    });
-    it("returns error for unknown action", async () => {
-      const result = await handleLocalAgent(sb, {
-        action: "deploy"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("Unknown action: deploy");
-      expect(result.error).toContain("Valid:");
-    });
-    it("returns error when store_id is missing", async () => {
-      const result = await handleLocalAgent(sb, {
-        action: "exec",
-        command: "ls"
-      });
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("store_id is required");
-    });
-  });
-  describe("action: exec", () => {
-    it("executes a command on the local agent", async () => {
-      const result = await handleLocalAgent(sb, {
-        action: "exec",
-        command: "ls -la"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-      expect(mockExecuteOnLocalAgent).toHaveBeenCalledWith(TEST_STORE, "ls -la", expect.objectContaining({
-        timeout: 30000
-      }));
-      const data = result.data;
-      expect(data.stdout).toBe("command output");
-    });
-    it("returns error when command is missing for exec", async () => {
-      const result = await handleLocalAgent(sb, {
-        action: "exec"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("command is required for exec");
-    });
-    it("returns no-agent message when local agent is not connected", async () => {
-      mockHasLocalAgent.mockReturnValue(false);
-      const result = await handleLocalAgent(sb, {
-        action: "exec",
-        command: "whoami"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("No local agent connected");
-      expect(result.error).toContain("whale-code");
-    });
-    it("forwards session_id and timeout to executeOnLocalAgent", async () => {
-      await handleLocalAgent(sb, {
-        action: "exec",
-        command: "nmap target",
-        session_id: "sess-42",
-        timeout: 120000,
-        agent_id: "agent-001"
-      }, TEST_STORE);
-      expect(mockExecuteOnLocalAgent).toHaveBeenCalledWith(TEST_STORE, "nmap target", {
-        session_id: "sess-42",
-        timeout: 120000,
-        agent_id: "agent-001"
-      });
-    });
-    it("caps timeout at 600000ms", async () => {
-      await handleLocalAgent(sb, {
-        action: "exec",
-        command: "test",
-        timeout: 999999
-      }, TEST_STORE);
-      expect(mockExecuteOnLocalAgent).toHaveBeenCalledWith(TEST_STORE, "test", expect.objectContaining({
-        timeout: 600000
-      }));
-    });
-    it("handles execution failure from agent", async () => {
-      mockExecuteOnLocalAgent.mockResolvedValue({
-        success: false,
-        stdout: "",
-        stderr: "command not found",
-        exit_code: 127
-      });
-      const result = await handleLocalAgent(sb, {
-        action: "exec",
-        command: "nonexistent-cmd"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      const data = result.data;
-      expect(data.exit_code).toBe(127);
-    });
-  });
-  describe("action: exec_bg", () => {
-    it("runs a background command on the local agent", async () => {
-      mockExecuteOnLocalAgent.mockResolvedValue({
-        success: true,
-        job_id: "bg-job-1"
-      });
-      const result = await handleLocalAgent(sb, {
-        action: "exec_bg",
-        command: "long-scan --target all"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-      expect(mockExecuteOnLocalAgent).toHaveBeenCalled();
-    });
-    it("returns error when command is missing for exec_bg", async () => {
-      const result = await handleLocalAgent(sb, {
-        action: "exec_bg"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("command is required for exec");
-    });
-  });
-});

package/dist/server/handlers/meta-ads-audience-rules.test.js

@@ -1,243 +0,0 @@
-// meta-ads-audience-rules.test.ts — Tests for rules, targeting, reach estimate, error handling
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { HAS_TEST_DB, getTestClient, seedTracked, cleanup, TEST_STORE, RUN_PREFIX } from "./__test-utils__/test-db.js";
-import { randomUUID } from "node:crypto";
-// ---------------------------------------------------------------------------
-// Mock global fetch for Meta Graph API calls
-// ---------------------------------------------------------------------------
-
-const originalFetch = globalThis.fetch;
-const mockFetch = vi.fn((...args) => originalFetch(...args));
-import { handleMetaAds } from "./meta-ads.js";
-const AD_ACCOUNT_ID = "act_123456789";
-const ACCESS_TOKEN = "EAAtest_access_token_123";
-const PAGE_ID = "page_987654321";
-const sb = getTestClient();
-
-// ---------------------------------------------------------------------------
-// Test data helpers
-// ---------------------------------------------------------------------------
-
-function makeIntegrationRow(overrides = {}) {
-  return {
-    id: randomUUID(),
-    store_id: TEST_STORE,
-    app_id: `test_app_${RUN_PREFIX}`,
-    access_token_encrypted: ACCESS_TOKEN,
-    ad_account_id: AD_ACCOUNT_ID,
-    page_id: PAGE_ID,
-    pixel_id: "pixel_111",
-    instagram_business_id: "ig_222",
-    token_expires_at: "2027-01-01T00:00:00Z",
-    status: "active",
-    ...overrides
-  };
-}
-async function setupMetaIntegration(overrides = {}) {
-  await seedTracked("meta_integrations", [makeIntegrationRow(overrides)]);
-}
-function mockMetaFetchSuccess(responseData = {
-  id: "12345"
-}) {
-  mockFetch.mockImplementation((...args) => {
-    const url = typeof args[0] === "string" ? args[0] : args[0]?.url;
-    if (url && url.includes("graph.facebook.com")) {
-      return Promise.resolve({
-        ok: true,
-        status: 200,
-        json: () => Promise.resolve(responseData),
-        text: () => Promise.resolve(JSON.stringify(responseData))
-      });
-    }
-    return originalFetch(...args);
-  });
-}
-function mockMetaFetchError(status = 400, errorBody) {
-  const body = errorBody || {
-    error: {
-      message: "Invalid parameter",
-      code: 100,
-      error_user_msg: "Something went wrong"
-    }
-  };
-  mockFetch.mockImplementation((...args) => {
-    const url = typeof args[0] === "string" ? args[0] : args[0]?.url;
-    if (url && url.includes("graph.facebook.com")) {
-      return Promise.resolve({
-        ok: false,
-        status,
-        json: () => Promise.resolve(body),
-        text: () => Promise.resolve(JSON.stringify(body))
-      });
-    }
-    return originalFetch(...args);
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Tests — Rules, Targeting, Reach estimate, Error handling
-// ---------------------------------------------------------------------------
-
-describe.skipIf(!HAS_TEST_DB)("handleMetaAds — rules/targeting/errors", () => {
-  beforeEach(async () => {
-    vi.restoreAllMocks();
-    vi.clearAllMocks();
-    mockFetch.mockImplementation((...args) => originalFetch(...args));
-    globalThis.fetch = mockFetch;
-    await sb.from("meta_ads").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("meta_ad_sets").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("meta_campaigns").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("meta_integrations").delete().eq("store_id", TEST_STORE).then(() => {});
-  });
-  afterEach(async () => {
-    globalThis.fetch = originalFetch;
-    vi.restoreAllMocks();
-    await cleanup();
-    await sb.from("meta_ads").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("meta_ad_sets").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("meta_campaigns").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("meta_integrations").delete().eq("store_id", TEST_STORE).then(() => {});
-  });
-  describe("action: create_rule", () => {
-    it("creates an ad automation rule", async () => {
-      await setupMetaIntegration();
-      mockMetaFetchSuccess({
-        id: "rule_12345"
-      });
-      const result = await handleMetaAds(sb, {
-        action: "create_rule",
-        name: `${RUN_PREFIX} Auto-pause low CTR`,
-        evaluation_spec: {
-          filters: [{
-            field: "impressions",
-            value: 1000,
-            operator: "GREATER_THAN"
-          }, {
-            field: "ctr",
-            value: 0.5,
-            operator: "LESS_THAN"
-          }]
-        },
-        execution_spec: {
-          execution_type: "PAUSE"
-        }
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-    });
-    it("returns error when name is missing", async () => {
-      const result = await handleMetaAds(sb, {
-        action: "create_rule",
-        evaluation_spec: {},
-        execution_spec: {}
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("name required");
-    });
-    it("returns error when evaluation_spec is missing", async () => {
-      await setupMetaIntegration();
-      const result = await handleMetaAds(sb, {
-        action: "create_rule",
-        name: `${RUN_PREFIX} Rule`,
-        execution_spec: {}
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("evaluation_spec required");
-    });
-    it("returns error when execution_spec is missing", async () => {
-      await setupMetaIntegration();
-      const result = await handleMetaAds(sb, {
-        action: "create_rule",
-        name: `${RUN_PREFIX} Rule`,
-        evaluation_spec: {}
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("execution_spec required");
-    });
-  });
-  describe("action: search_targeting", () => {
-    it("searches for interests", async () => {
-      await setupMetaIntegration();
-      mockMetaFetchSuccess({
-        data: [{
-          id: "6003139266461",
-          name: "Fitness and wellness"
-        }]
-      });
-      const result = await handleMetaAds(sb, {
-        action: "search_targeting",
-        query: "fitness"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-    });
-    it("returns error when query is missing", async () => {
-      const result = await handleMetaAds(sb, {
-        action: "search_targeting"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("query required");
-    });
-    it("returns error on Meta API failure", async () => {
-      await setupMetaIntegration();
-      mockMetaFetchError(400);
-      const result = await handleMetaAds(sb, {
-        action: "search_targeting",
-        query: "invalid"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-    });
-  });
-  describe("action: reach_estimate", () => {
-    it("returns reach estimate for targeting spec", async () => {
-      await setupMetaIntegration();
-      mockMetaFetchSuccess({
-        data: [{
-          daily_outcomes_curve: [{
-            spend: 10,
-            reach: 5000
-          }],
-          estimate_dau: 15000,
-          estimate_ready: true
-        }]
-      });
-      const result = await handleMetaAds(sb, {
-        action: "reach_estimate",
-        targeting: {
-          geo_locations: {
-            countries: ["US"]
-          },
-          age_min: 25,
-          age_max: 55
-        }
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-    });
-    it("returns error when targeting is missing", async () => {
-      await setupMetaIntegration();
-      const result = await handleMetaAds(sb, {
-        action: "reach_estimate"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("targeting required");
-    });
-  });
-  describe("Meta API error handling", () => {
-    it("handles missing Meta integration gracefully", async () => {
-      const result = await handleMetaAds(sb, {
-        action: "list_audiences"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("Meta not connected");
-    });
-    it("handles expired token", async () => {
-      await seedTracked("meta_integrations", [makeIntegrationRow({
-        token_expires_at: "2020-01-01T00:00:00Z"
-      })]);
-      const result = await handleMetaAds(sb, {
-        action: "list_audiences"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("expired");
-    });
-  });
-});