whale-code 6.5.10 → 6.6.0

package/dist/local-agent/__tests__/connection-toolexec.test.js

@@ -1,253 +0,0 @@
-/**
- * Tests for LocalAgentConnection — tool_exec handling.
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-
-// ============================================================================
-// Mocks — vi.hoisted ensures MockWebSocket is available when vi.mock hoists
-// ============================================================================
-
-const {
-  MockWebSocket,
-  getLastWsInstance,
-  resetWsInstance
-} = vi.hoisted(() => {
-  let _lastWsInstance = null;
-  class MockWebSocket {
-    static OPEN = 1;
-    static CLOSED = 3;
-    static CONNECTING = 0;
-    readyState = 0; // CONNECTING
-    handlers = {};
-    sentMessages = [];
-    terminated = false;
-    closedWith = null;
-    constructor(url, options) {
-      this.url = url;
-      this.options = options;
-      _lastWsInstance = this;
-    }
-    on(event, handler) {
-      if (!this.handlers[event]) this.handlers[event] = [];
-      this.handlers[event].push(handler);
-    }
-    send(data) {
-      this.sentMessages.push(JSON.parse(data));
-    }
-    close(code, reason) {
-      this.closedWith = {
-        code,
-        reason
-      };
-      this.readyState = 3; // CLOSED
-      this.emit("close", code, reason);
-    }
-    terminate() {
-      this.terminated = true;
-      this.readyState = 3; // CLOSED
-    }
-    emit(event, ...args) {
-      (this.handlers[event] || []).forEach(h => h(...args));
-    }
-    simulateOpen() {
-      this.readyState = 1; // OPEN
-      this.emit("open");
-    }
-    simulateMessage(data) {
-      this.emit("message", Buffer.from(JSON.stringify(data)));
-    }
-    simulateError(err) {
-      this.emit("error", err);
-    }
-    simulateClose(code, reason) {
-      this.readyState = 3; // CLOSED
-      this.emit("close", code, Buffer.from(reason || ""));
-    }
-  }
-  return {
-    MockWebSocket,
-    getLastWsInstance: () => _lastWsInstance,
-    resetWsInstance: () => {
-      _lastWsInstance = null;
-    }
-  };
-});
-vi.mock("ws", () => ({
-  default: MockWebSocket
-}));
-vi.mock("node:os", () => ({
-  default: {
-    hostname: () => "test-machine"
-  }
-}));
-vi.mock("../discovery.js", () => ({
-  discoverTools: vi.fn(() => [{
-    name: "nmap",
-    path: "/usr/bin/nmap",
-    category: "network_scanning",
-    version: "7.94"
-  }, {
-    name: "curl",
-    path: "/usr/bin/curl",
-    category: "utility",
-    version: "8.1"
-  }])
-}));
-vi.mock("../executor.js", () => ({
-  exec: vi.fn(async () => ({
-    success: true,
-    stdout: "ok",
-    stderr: "",
-    exit_code: 0,
-    killed: false,
-    cwd: "/tmp",
-    duration_ms: 10
-  })),
-  getSystemInfo: vi.fn(() => ({
-    platform: "darwin",
-    arch: "arm64",
-    hostname: "testhost",
-    user: "tester",
-    home: "/Users/tester",
-    cpus: 8,
-    memory_gb: 16,
-    uptime_hours: 100,
-    node_version: "v20.0.0"
-  }))
-}));
-import { LocalAgentConnection } from "../connection.js";
-import { exec } from "../executor.js";
-
-// ============================================================================
-// Setup
-// ============================================================================
-
-const defaultConfig = {
-  apiKey: "test-api-key-123"
-};
-let agent;
-beforeEach(() => {
-  vi.clearAllMocks();
-  vi.useFakeTimers();
-  resetWsInstance();
-  agent = new LocalAgentConnection(defaultConfig);
-});
-afterEach(() => {
-  vi.useRealTimers();
-  agent.disconnect();
-});
-function lastWs() {
-  return getLastWsInstance();
-}
-
-// ============================================================================
-// tool_exec handling
-// ============================================================================
-
-describe("LocalAgentConnection - tool_exec", () => {
-  async function connectAgent() {
-    const connectPromise = agent.connect();
-    const ws = lastWs();
-    ws.simulateOpen();
-    ws.simulateMessage({
-      type: "authenticated",
-      agent_id: "a1"
-    });
-    await connectPromise;
-    ws.sentMessages.length = 0;
-    return ws;
-  }
-  it("handles tshark tool exec", async () => {
-    const ws = await connectAgent();
-    ws.simulateMessage({
-      type: "tool_exec",
-      request_id: "req-t1",
-      tool: "tshark",
-      args: {
-        interface: "en0",
-        filter: "tcp port 80",
-        count: 50
-      }
-    });
-    await vi.advanceTimersByTimeAsync(0);
-    expect(exec).toHaveBeenCalledWith(expect.stringContaining("tshark -i en0"), expect.objectContaining({
-      timeout: 60000
-    }));
-  });
-  it("handles burpsuite status action", async () => {
-    const ws = await connectAgent();
-    ws.simulateMessage({
-      type: "tool_exec",
-      request_id: "req-b1",
-      tool: "burpsuite",
-      args: {
-        action: "status",
-        port: 8080
-      }
-    });
-    await vi.advanceTimersByTimeAsync(0);
-    expect(exec).toHaveBeenCalledWith(expect.stringContaining("curl -s http://localhost:8080"), expect.any(Object));
-  });
-  it("handles unknown burpsuite action", async () => {
-    const ws = await connectAgent();
-    ws.simulateMessage({
-      type: "tool_exec",
-      request_id: "req-b2",
-      tool: "burpsuite",
-      args: {
-        action: "unknown_action"
-      }
-    });
-    await vi.advanceTimersByTimeAsync(0);
-    const result = ws.sentMessages.find(m => m.request_id === "req-b2");
-    expect(result).toBeDefined();
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("Unknown burpsuite action");
-  });
-  it("handles zap tool with various actions", async () => {
-    const ws = await connectAgent();
-    ws.simulateMessage({
-      type: "tool_exec",
-      request_id: "req-z1",
-      tool: "zap",
-      args: {
-        action: "spider",
-        target_url: "http://test.com",
-        api_key: "zapapikey"
-      }
-    });
-    await vi.advanceTimersByTimeAsync(0);
-    expect(exec).toHaveBeenCalledWith(expect.stringContaining("spider/action/scan"), expect.any(Object));
-  });
-  it("handles generic tool fallback", async () => {
-    const ws = await connectAgent();
-    ws.simulateMessage({
-      type: "tool_exec",
-      request_id: "req-g1",
-      tool: "custom-tool",
-      args: {
-        args: "--scan --target 192.168.1.1"
-      }
-    });
-    await vi.advanceTimersByTimeAsync(0);
-    expect(exec).toHaveBeenCalledWith("custom-tool --scan --target 192.168.1.1 2>&1", expect.objectContaining({
-      timeout: 30000
-    }));
-  });
-  it("handles tool_exec errors", async () => {
-    vi.mocked(exec).mockRejectedValueOnce(new Error("Tool crashed"));
-    const ws = await connectAgent();
-    ws.simulateMessage({
-      type: "tool_exec",
-      request_id: "req-e1",
-      tool: "nmap",
-      args: {}
-    });
-    await vi.advanceTimersByTimeAsync(0);
-    const result = ws.sentMessages.find(m => m.request_id === "req-e1");
-    expect(result).toBeDefined();
-    expect(result.success).toBe(false);
-    expect(result.error).toBe("Tool crashed");
-  });
-});

package/dist/local-agent/__tests__/discovery.test.js

@@ -1,328 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-
-// ============================================================================
-// Mock child_process
-// ============================================================================
-
-const mockExecSync = vi.fn();
-vi.mock("node:child_process", () => ({
-  execSync: (...args) => mockExecSync(...args)
-}));
-import { discoverTools, discoverToolNames } from "../discovery.js";
-
-// ============================================================================
-// Setup
-// ============================================================================
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-/**
- * Configure mockExecSync to simulate `which` and version calls.
- * @param toolMap - map of binary name to { path, versionOutput? }
- * @param portsListening - set of ports that have listeners
- */
-function setupMockTools(toolMap, portsListening = new Set()) {
-  mockExecSync.mockImplementation(cmd => {
-    // Handle "which <binary>" calls
-    const whichMatch = cmd.match(/^which (\S+)/);
-    if (whichMatch) {
-      const binary = whichMatch[1];
-      if (toolMap[binary]) return toolMap[binary].path;
-      throw new Error("not found");
-    }
-
-    // Handle version calls - match against binary name in command
-    for (const [binary, info] of Object.entries(toolMap)) {
-      if (cmd.startsWith(binary) && info.versionOutput) {
-        return info.versionOutput;
-      }
-    }
-
-    // Handle lsof port check
-    const lsofMatch = cmd.match(/lsof -i :(\d+)/);
-    if (lsofMatch) {
-      const port = parseInt(lsofMatch[1]);
-      if (portsListening.has(port)) return "node  1234 user";
-      throw new Error("no output");
-    }
-    throw new Error(`Unhandled mock command: ${cmd}`);
-  });
-}
-
-// ============================================================================
-// discoverTools()
-// ============================================================================
-
-describe("discoverTools", () => {
-  it("returns empty array when no tools found", () => {
-    mockExecSync.mockImplementation(() => {
-      throw new Error("not found");
-    });
-    const tools = discoverTools();
-    expect(tools).toEqual([]);
-  });
-  it("discovers a single tool by binary name", () => {
-    setupMockTools({
-      nmap: {
-        path: "/usr/bin/nmap",
-        versionOutput: "Nmap version 7.94"
-      }
-    });
-    const tools = discoverTools();
-    const nmap = tools.find(t => t.name === "nmap");
-    expect(nmap).toBeDefined();
-    expect(nmap.path).toBe("/usr/bin/nmap");
-    expect(nmap.category).toBe("network_scanning");
-  });
-  it("extracts version number from tool output", () => {
-    setupMockTools({
-      nmap: {
-        path: "/usr/bin/nmap",
-        versionOutput: "Nmap version 7.94SVN"
-      }
-    });
-    const tools = discoverTools();
-    const nmap = tools.find(t => t.name === "nmap");
-    expect(nmap.version).toBe("7.94");
-  });
-  it("extracts complex version numbers", () => {
-    setupMockTools({
-      curl: {
-        path: "/usr/bin/curl",
-        versionOutput: "curl 8.1.2 (aarch64-apple-darwin)"
-      }
-    });
-    const tools = discoverTools();
-    const curl = tools.find(t => t.name === "curl");
-    expect(curl.version).toBe("8.1.2");
-  });
-  it("discovers tools without version flag", () => {
-    // netdiscover has no versionFlag in TOOL_SPECS
-    setupMockTools({
-      netdiscover: {
-        path: "/usr/local/bin/netdiscover"
-      }
-    });
-    const tools = discoverTools();
-    const nd = tools.find(t => t.name === "netdiscover");
-    expect(nd).toBeDefined();
-    expect(nd.path).toBe("/usr/local/bin/netdiscover");
-    expect(nd.version).toBeUndefined();
-  });
-  it("handles version check failure gracefully", () => {
-    // which succeeds but version command throws
-    mockExecSync.mockImplementation(cmd => {
-      if (cmd.startsWith("which nmap")) return "/usr/bin/nmap";
-      if (cmd.startsWith("nmap")) throw new Error("segfault");
-      throw new Error("not found");
-    });
-    const tools = discoverTools();
-    const nmap = tools.find(t => t.name === "nmap");
-    expect(nmap).toBeDefined();
-    expect(nmap.version).toBeUndefined();
-  });
-  it("discovers multiple tools", () => {
-    setupMockTools({
-      nmap: {
-        path: "/usr/bin/nmap",
-        versionOutput: "Nmap 7.94"
-      },
-      curl: {
-        path: "/usr/bin/curl",
-        versionOutput: "curl 8.1"
-      },
-      python3: {
-        path: "/usr/bin/python3",
-        versionOutput: "Python 3.12.0"
-      }
-    });
-    const tools = discoverTools();
-    expect(tools.length).toBeGreaterThanOrEqual(3);
-    expect(tools.find(t => t.name === "nmap")).toBeDefined();
-    expect(tools.find(t => t.name === "curl")).toBeDefined();
-    expect(tools.find(t => t.name === "python3")).toBeDefined();
-  });
-  it("uses first matching binary when tool has multiple binary names", () => {
-    // metasploit has binaries: ["msfconsole", "msfvenom"]
-    setupMockTools({
-      msfconsole: {
-        path: "/usr/bin/msfconsole",
-        versionOutput: "Framework: 6.3.0"
-      }
-    });
-    const tools = discoverTools();
-    const msf = tools.find(t => t.name === "metasploit");
-    expect(msf).toBeDefined();
-    expect(msf.path).toBe("/usr/bin/msfconsole");
-  });
-  it("falls back to second binary if first is not found", () => {
-    // For metasploit: msfconsole not found, msfvenom found
-    mockExecSync.mockImplementation(cmd => {
-      if (cmd === "which msfconsole 2>/dev/null") throw new Error("not found");
-      if (cmd === "which msfvenom 2>/dev/null") return "/usr/bin/msfvenom";
-      if (cmd.startsWith("msfvenom")) return "Metasploit 6.3.0";
-      throw new Error("not found");
-    });
-    const tools = discoverTools();
-    const msf = tools.find(t => t.name === "metasploit");
-    expect(msf).toBeDefined();
-    expect(msf.path).toBe("/usr/bin/msfvenom");
-  });
-  it("assigns correct category to each tool", () => {
-    setupMockTools({
-      nmap: {
-        path: "/usr/bin/nmap",
-        versionOutput: "7.94"
-      },
-      sqlmap: {
-        path: "/usr/bin/sqlmap",
-        versionOutput: "1.7"
-      },
-      john: {
-        path: "/usr/bin/john"
-      }
-    });
-    const tools = discoverTools();
-    expect(tools.find(t => t.name === "nmap").category).toBe("network_scanning");
-    expect(tools.find(t => t.name === "sqlmap").category).toBe("web_security");
-    expect(tools.find(t => t.name === "john").category).toBe("password_cracking");
-  });
-  it("checks service status for burpsuite via port check", () => {
-    setupMockTools({
-      burpsuite: {
-        path: "/opt/BurpSuite/burpsuite"
-      }
-    }, new Set([8080]));
-    const tools = discoverTools();
-    const burp = tools.find(t => t.name === "burpsuite");
-    expect(burp).toBeDefined();
-    expect(burp.running).toBe(true);
-  });
-  it("reports service as not running when port is closed", () => {
-    setupMockTools({
-      burpsuite: {
-        path: "/opt/BurpSuite/burpsuite"
-      }
-    }, new Set() // no ports listening
-    );
-    const tools = discoverTools();
-    const burp = tools.find(t => t.name === "burpsuite");
-    expect(burp).toBeDefined();
-    expect(burp.running).toBe(false);
-  });
-  it("checks ZAP running status on port 8090", () => {
-    setupMockTools({
-      zaproxy: {
-        path: "/usr/bin/zaproxy"
-      }
-    }, new Set([8090]));
-    const tools = discoverTools();
-    const zap = tools.find(t => t.name === "zap");
-    expect(zap).toBeDefined();
-    expect(zap.running).toBe(true);
-  });
-  it("handles serviceCheck throwing an error", () => {
-    // If serviceCheck itself throws, running should be false
-    mockExecSync.mockImplementation(cmd => {
-      if (cmd.startsWith("which burpsuite")) return "/usr/bin/burpsuite";
-      if (cmd.startsWith("which")) throw new Error("not found");
-      // lsof throws something weird
-      if (cmd.includes("lsof")) throw {
-        killed: true,
-        message: "timeout"
-      };
-      throw new Error("not found");
-    });
-    const tools = discoverTools();
-    const burp = tools.find(t => t.name === "burpsuite");
-    if (burp) {
-      expect(burp.running).toBe(false);
-    }
-  });
-  it("returns tool path trimmed", () => {
-    mockExecSync.mockImplementation(cmd => {
-      if (cmd.startsWith("which curl")) return "  /usr/bin/curl  \n";
-      throw new Error("not found");
-    });
-    const tools = discoverTools();
-    const curl = tools.find(t => t.name === "curl");
-    expect(curl).toBeDefined();
-    expect(curl.path).toBe("/usr/bin/curl");
-  });
-  it("returns null from which when result is empty string", () => {
-    mockExecSync.mockImplementation(cmd => {
-      if (cmd.startsWith("which nmap")) return "";
-      throw new Error("not found");
-    });
-    const tools = discoverTools();
-    const nmap = tools.find(t => t.name === "nmap");
-    expect(nmap).toBeUndefined();
-  });
-  it("respects 5s timeout on version checks", () => {
-    setupMockTools({
-      nmap: {
-        path: "/usr/bin/nmap",
-        versionOutput: "7.94"
-      }
-    });
-    discoverTools();
-    // Find the version call (not the which call)
-    const versionCall = mockExecSync.mock.calls.find(call => call[0].includes("--version") && call[0].startsWith("nmap"));
-    expect(versionCall).toBeDefined();
-    expect(versionCall[1]).toEqual(expect.objectContaining({
-      timeout: 5000
-    }));
-  });
-  it("respects 3s timeout on which calls", () => {
-    setupMockTools({
-      nmap: {
-        path: "/usr/bin/nmap"
-      }
-    });
-    discoverTools();
-    const whichCall = mockExecSync.mock.calls.find(call => call[0].startsWith("which"));
-    expect(whichCall).toBeDefined();
-    expect(whichCall[1]).toEqual(expect.objectContaining({
-      timeout: 3000
-    }));
-  });
-});
-
-// ============================================================================
-// discoverToolNames()
-// ============================================================================
-
-describe("discoverToolNames", () => {
-  it("returns just tool names as strings", () => {
-    setupMockTools({
-      nmap: {
-        path: "/usr/bin/nmap",
-        versionOutput: "7.94"
-      },
-      curl: {
-        path: "/usr/bin/curl",
-        versionOutput: "8.1"
-      }
-    });
-    const names = discoverToolNames();
-    expect(names).toContain("nmap");
-    expect(names).toContain("curl");
-    expect(names.every(n => typeof n === "string")).toBe(true);
-  });
-  it("returns empty array when no tools installed", () => {
-    mockExecSync.mockImplementation(() => {
-      throw new Error("not found");
-    });
-    const names = discoverToolNames();
-    expect(names).toEqual([]);
-  });
-});