@poolzin/pool-bot 2026.3.14 → 2026.3.16

package/extensions/hexstrike-ai/src/client.test.ts

@@ -0,0 +1,335 @@
+/**
+ * HexStrike Client Tests
+ * Tests for the HexStrike AI HTTP client
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { HexStrikeClient, type HealthStatus, type ScanResult } from './client.js';
+
+const mockFetch = vi.fn();
+vi.stubGlobal('fetch', mockFetch);
+
+describe('HexStrikeClient', () => {
+  let client: HexStrikeClient;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    client = new HexStrikeClient({
+      host: '127.0.0.1',
+      port: 8888,
+      token: 'test-token',
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Constructor', () => {
+    it('should create client with default config', () => {
+      const defaultClient = new HexStrikeClient();
+      expect(defaultClient).toBeDefined();
+    });
+
+    it('should create client with custom host', () => {
+      const customClient = new HexStrikeClient({ host: '192.168.1.100' });
+      expect(customClient).toBeDefined();
+    });
+
+    it('should create client with custom port', () => {
+      const customClient = new HexStrikeClient({ port: 9999 });
+      expect(customClient).toBeDefined();
+    });
+
+    it('should create client without token', () => {
+      const noTokenClient = new HexStrikeClient({ token: undefined });
+      expect(noTokenClient).toBeDefined();
+    });
+  });
+
+  describe('health()', () => {
+    it('should return health status on success', async () => {
+      const mockHealth: HealthStatus = {
+        status: 'healthy',
+        version: '6.0.0',
+        uptime: 3600,
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockHealth,
+      });
+
+      const result = await client.health();
+
+      expect(result).toEqual(mockHealth);
+      expect(mockFetch).toHaveBeenCalledWith('http://127.0.0.1:8888/health');
+    });
+
+    it('should throw error on health check failure', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 503,
+      });
+
+      await expect(client.health()).rejects.toThrow('Health check failed: 503');
+    });
+
+    it('should handle network errors', async () => {
+      mockFetch.mockRejectedValueOnce(new Error('ECONNREFUSED'));
+
+      await expect(client.health()).rejects.toThrow('ECONNREFUSED');
+    });
+  });
+
+  describe('getTools()', () => {
+    it('should return list of available tools', async () => {
+      const mockTools = ['nmap', 'nuclei', 'sqlmap', 'gobuster', 'wpscan'];
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ tools: mockTools }),
+      });
+
+      const result = await client.getTools();
+
+      expect(result).toEqual(mockTools);
+      expect(mockFetch).toHaveBeenCalledWith('http://127.0.0.1:8888/api/tools', {
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'Bearer test-token',
+        },
+      });
+    });
+
+    it('should return empty array when tools is undefined', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({}),
+      });
+
+      const result = await client.getTools();
+
+      expect(result).toEqual([]);
+    });
+
+    it('should throw error on failure', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 500,
+      });
+
+      await expect(client.getTools()).rejects.toThrow('Failed to get tools: 500');
+    });
+
+    it('should include authorization header when token is provided', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ tools: [] }),
+      });
+
+      await client.getTools();
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            'Authorization': 'Bearer test-token',
+          }),
+        })
+      );
+    });
+
+    it('should not include authorization header when token is not provided', async () => {
+      const noTokenClient = new HexStrikeClient({ token: undefined });
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ tools: [] }),
+      });
+
+      await noTokenClient.getTools();
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          headers: expect.not.objectContaining({
+            'Authorization': expect.any(String),
+          }),
+        })
+      );
+    });
+  });
+
+  describe('scan()', () => {
+    it('should start scan with target only', async () => {
+      const mockResponse = { id: 'scan-123' };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockResponse,
+      });
+
+      const result = await client.scan({ target: 'https://example.com' });
+
+      expect(result).toEqual({ scanId: 'scan-123' });
+      expect(mockFetch).toHaveBeenCalledWith('http://127.0.0.1:8888/api/scan', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'Bearer test-token',
+        },
+        body: JSON.stringify({ target: 'https://example.com' }),
+      });
+    });
+
+    it('should start scan with specific scanners', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ id: 'scan-456' }),
+      });
+
+      await client.scan({
+        target: 'https://example.com',
+        scanners: ['nmap', 'nuclei'],
+      });
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          body: JSON.stringify({
+            target: 'https://example.com',
+            scanners: ['nmap', 'nuclei'],
+          }),
+        })
+      );
+    });
+
+    it('should start scan with custom options', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ id: 'scan-789' }),
+      });
+
+      await client.scan({
+        target: '192.168.1.1',
+        options: { timeout: 300, threads: 10 },
+      });
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          body: JSON.stringify({
+            target: '192.168.1.1',
+            options: { timeout: 300, threads: 10 },
+          }),
+        })
+      );
+    });
+
+    it('should throw error on scan failure', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 400,
+      });
+
+      await expect(client.scan({ target: 'invalid' })).rejects.toThrow('Scan failed: 400');
+    });
+
+    it('should handle network errors', async () => {
+      mockFetch.mockRejectedValueOnce(new Error('ENOTFOUND'));
+
+      await expect(client.scan({ target: 'https://example.com' }))
+        .rejects.toThrow('ENOTFOUND');
+    });
+  });
+
+  describe('getScanResult()', () => {
+    it('should return scan result on success', async () => {
+      const mockResult: ScanResult = {
+        id: 'scan-123',
+        status: 'completed',
+        findings: [
+          {
+            severity: 'high',
+            title: 'SQL Injection',
+            description: 'SQL injection vulnerability found',
+            remediation: 'Use parameterized queries',
+          },
+          {
+            severity: 'medium',
+            title: 'XSS Vulnerability',
+            description: 'Cross-site scripting vulnerability',
+          },
+        ],
+        metadata: {
+          startedAt: '2026-03-12T10:00:00Z',
+          completedAt: '2026-03-12T10:30:00Z',
+          duration: 1800,
+        },
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockResult,
+      });
+
+      const result = await client.getScanResult('scan-123');
+
+      expect(result).toEqual(mockResult);
+      expect(mockFetch).toHaveBeenCalledWith('http://127.0.0.1:8888/api/scan/scan-123', {
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'Bearer test-token',
+        },
+      });
+    });
+
+    it('should handle scan with no findings', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          id: 'scan-456',
+          status: 'completed',
+          findings: [],
+          metadata: {
+            startedAt: '2026-03-12T10:00:00Z',
+            completedAt: '2026-03-12T10:05:00Z',
+          },
+        }),
+      });
+
+      const result = await client.getScanResult('scan-456');
+
+      expect(result.findings).toEqual([]);
+    });
+
+    it('should handle running scan', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          id: 'scan-789',
+          status: 'running',
+          findings: [],
+          metadata: {
+            startedAt: '2026-03-12T10:00:00Z',
+          },
+        }),
+      });
+
+      const result = await client.getScanResult('scan-789');
+
+      expect(result.status).toBe('running');
+      expect(result.metadata.completedAt).toBeUndefined();
+    });
+
+    it('should throw error on failure', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 404,
+      });
+
+      await expect(client.getScanResult('non-existent'))
+        .rejects.toThrow('Failed to get scan: 404');
+    });
+  });
+});

package/extensions/hexstrike-ai/src/server-manager.test.ts

@@ -0,0 +1,286 @@
+/**
+ * HexStrike Server Manager Tests
+ * Tests for the HexStrike Python server process manager
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { HexStrikeServerManager } from './server-manager.js';
+import { spawn } from 'node:child_process';
+import EventEmitter from 'node:events';
+
+vi.mock('node:child_process', () => ({
+  spawn: vi.fn(),
+}));
+
+describe('HexStrikeServerManager', () => {
+  let serverManager: HexStrikeServerManager;
+  let mockProcess: any;
+  let mockStdout: EventEmitter;
+  let mockStderr: EventEmitter;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    mockStdout = new EventEmitter();
+    mockStderr = new EventEmitter();
+    mockProcess = {
+      stdout: mockStdout,
+      stderr: mockStderr,
+      on: vi.fn(),
+      kill: vi.fn(),
+      killed: false,
+    };
+
+    vi.mocked(spawn).mockReturnValue(mockProcess);
+
+    serverManager = new HexStrikeServerManager({
+      port: 8888,
+      host: '127.0.0.1',
+      pythonPath: 'python3',
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Constructor', () => {
+    it('should create server manager with default config', () => {
+      const defaultManager = new HexStrikeServerManager();
+      expect(defaultManager).toBeDefined();
+    });
+
+    it('should create server manager with custom port', () => {
+      const customManager = new HexStrikeServerManager({ port: 9999 });
+      expect(customManager).toBeDefined();
+    });
+
+    it('should create server manager with custom host', () => {
+      const customManager = new HexStrikeServerManager({ host: '0.0.0.0' });
+      expect(customManager).toBeDefined();
+    });
+
+    it('should create server manager with custom python path', () => {
+      const customManager = new HexStrikeServerManager({ pythonPath: '/usr/bin/python3.11' });
+      expect(customManager).toBeDefined();
+    });
+
+    it('should use defaults for missing config values', () => {
+      const partialManager = new HexStrikeServerManager({});
+      expect(partialManager).toBeDefined();
+    });
+  });
+
+  describe('start()', () => {
+    it('should spawn Python process with correct arguments', async () => {
+      mockProcess.on = vi.fn();
+
+      setTimeout(() => {
+        mockStdout.emit('data', Buffer.from('Server started on port 8888'));
+      }, 10);
+
+      await serverManager.start();
+
+      expect(spawn).toHaveBeenCalledWith('python3', expect.any(Array), {
+        env: expect.objectContaining({
+          HEXSTRIKE_PORT: '8888',
+          HEXSTRIKE_HOST: '127.0.0.1',
+        }),
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    });
+
+    it('should set environment variables correctly', async () => {
+      mockProcess.on = vi.fn();
+      
+      setTimeout(() => {
+        mockStdout.emit('data', Buffer.from('Server started'));
+      }, 10);
+
+      await serverManager.start();
+
+      const spawnCall = vi.mocked(spawn).mock.calls[0];
+      const options = spawnCall[2];
+      
+      expect(options?.env).toEqual(
+        expect.objectContaining({
+          HEXSTRIKE_PORT: '8888',
+          HEXSTRIKE_HOST: '127.0.0.1',
+        })
+      );
+    });
+
+    it('should resolve promise when server starts', async () => {
+      mockProcess.on = vi.fn();
+      
+      setTimeout(() => {
+        mockStdout.emit('data', Buffer.from('Server started on port 8888'));
+      }, 10);
+
+      await expect(serverManager.start()).resolves.toBeUndefined();
+    });
+
+    it('should resolve on "Listening" message', async () => {
+      mockProcess.on = vi.fn();
+      
+      setTimeout(() => {
+        mockStdout.emit('data', Buffer.from('Listening on 127.0.0.1:8888'));
+      }, 10);
+
+      await expect(serverManager.start()).resolves.toBeUndefined();
+    });
+
+    it('should reject on timeout', async () => {
+      mockProcess.on = vi.fn();
+      
+      vi.useFakeTimers();
+
+      const startPromise = serverManager.start();
+
+      vi.advanceTimersByTime(30000);
+
+      await expect(startPromise).rejects.toThrow('HexStrike server failed to start within 30s');
+
+      vi.useRealTimers();
+    });
+
+    it('should reject on spawn error', async () => {
+      const error = new Error('python3 not found');
+      mockProcess.on = vi.fn((event: string, callback: any) => {
+        if (event === 'error') {
+          setTimeout(() => callback(error), 10);
+        }
+        return mockProcess;
+      });
+
+      await expect(serverManager.start()).rejects.toThrow('python3 not found');
+    });
+
+    it('should reject on non-zero exit code', async () => {
+      mockProcess.on = vi.fn((event: string, callback: any) => {
+        if (event === 'exit') {
+          setTimeout(() => callback(1, null), 10);
+        }
+        return mockProcess;
+      });
+
+      await expect(serverManager.start()).rejects.toThrow('HexStrike server exited with code 1');
+    });
+
+    it('should log stdout output', async () => {
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      
+      mockProcess.on = vi.fn();
+      
+      setTimeout(() => {
+        mockStdout.emit('data', Buffer.from('[INFO] Server starting'));
+      }, 10);
+
+      await serverManager.start();
+
+      expect(consoleLogSpy).toHaveBeenCalledWith('[HexStrike] [INFO] Server starting');
+
+      consoleLogSpy.mockRestore();
+    });
+
+    it('should log stderr output', async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      
+      mockProcess.on = vi.fn();
+      
+      setTimeout(() => {
+        mockStderr.emit('data', Buffer.from('[ERROR] Something went wrong'));
+      }, 10);
+
+      serverManager.start().catch(() => {});
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('[HexStrike] [ERROR] Something went wrong');
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe('stop()', () => {
+    it('should kill running process with SIGTERM', async () => {
+      serverManager = new HexStrikeServerManager();
+      (serverManager as any).process = mockProcess;
+
+      await serverManager.stop();
+
+      expect(mockProcess.kill).toHaveBeenCalledWith('SIGTERM');
+    });
+
+    it('should wait for process to exit', async () => {
+      serverManager = new HexStrikeServerManager();
+      (serverManager as any).process = mockProcess;
+
+      const setTimeoutSpy = vi.spyOn(global, 'setTimeout').mockImplementation((callback: any) => {
+        callback();
+        return 0 as any;
+      });
+
+      await serverManager.stop();
+
+      expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 5000);
+
+      setTimeoutSpy.mockRestore();
+    });
+
+    it('should use SIGKILL if process does not exit', async () => {
+      serverManager = new HexStrikeServerManager();
+      (serverManager as any).process = {
+        ...mockProcess,
+        killed: false,
+      };
+
+      await serverManager.stop();
+
+      expect(mockProcess.kill).toHaveBeenCalledWith('SIGKILL');
+    });
+
+    it('should set process to null after stop', async () => {
+      serverManager = new HexStrikeServerManager();
+      (serverManager as any).process = mockProcess;
+
+      await serverManager.stop();
+
+      expect((serverManager as any).process).toBeNull();
+    });
+
+    it('should do nothing if process is not running', async () => {
+      serverManager = new HexStrikeServerManager();
+      (serverManager as any).process = null;
+
+      await serverManager.stop();
+
+      expect(mockProcess.kill).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('isRunning', () => {
+    it('should return true when process is running', () => {
+      serverManager = new HexStrikeServerManager();
+      (serverManager as any).process = {
+        killed: false,
+      };
+
+      expect(serverManager.isRunning).toBe(true);
+    });
+
+    it('should return false when process is null', () => {
+      serverManager = new HexStrikeServerManager();
+      (serverManager as any).process = null;
+
+      expect(serverManager.isRunning).toBe(false);
+    });
+
+    it('should return false when process is killed', () => {
+      serverManager = new HexStrikeServerManager();
+      (serverManager as any).process = {
+        killed: true,
+      };
+
+      expect(serverManager.isRunning).toBe(false);
+    });
+  });
+});

package/extensions/page-agent/poolbot.plugin.json

@@ -0,0 +1,24 @@
+{
+  "id": "page-agent",
+  "name": "Page Agent",
+  "description": "GUI Browser Automation for PoolBot with AI-powered web interaction",
+  "version": "2026.3.14",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "headless": {
+        "type": "boolean",
+        "default": true,
+        "description": "Run browser in headless mode"
+      },
+      "viewport": {
+        "type": "object",
+        "properties": {
+          "width": { "type": "number", "default": 1280 },
+          "height": { "type": "number", "default": 720 }
+        }
+      }
+    }
+  }
+}

package/extensions/xyops/poolbot.plugin.json

@@ -0,0 +1,21 @@
+{
+  "id": "xyops",
+  "name": "XYOps",
+  "description": "Workflow automation and job scheduling for PoolBot",
+  "version": "2026.3.14",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "apiKey": {
+        "type": "string",
+        "description": "XYOps API key"
+      },
+      "endpoint": {
+        "type": "string",
+        "format": "uri",
+        "description": "XYOps API endpoint"
+      }
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolzin/pool-bot",
-  "version": "2026.3.14",
+  "version": "2026.3.16",
   "description": "🎱 Pool Bot - AI assistant with PLCODE integrations",
   "keywords": [],
   "license": "MIT",