@poolzin/pool-bot 2026.3.14 → 2026.3.16

package/extensions/hackingtool/dist/client.js

@@ -0,0 +1,82 @@
+import { EventEmitter } from "events";
+export class HackingToolClient extends EventEmitter {
+    baseUrl;
+    token;
+    constructor(config = {}) {
+        super();
+        const host = config.host ?? "127.0.0.1";
+        const port = config.port ?? 8889;
+        this.baseUrl = `http://${host}:${port}`;
+        this.token = config.token;
+    }
+    async health() {
+        const response = await fetch(`${this.baseUrl}/health`);
+        if (!response.ok) {
+            throw new Error(`Health check failed: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async getTools() {
+        const response = await fetch(`${this.baseUrl}/tools`);
+        if (!response.ok) {
+            throw new Error(`Failed to get tools: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async runTool(category, toolName, target, options) {
+        const response = await fetch(`${this.baseUrl}/run_tool`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(this.token ? { Authorization: `Bearer ${this.token}` } : {}),
+            },
+            body: JSON.stringify({
+                method: "run_tool",
+                params: {
+                    category,
+                    tool_name: toolName,
+                    target,
+                    options,
+                },
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Tool execution failed: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return {
+            scanId: data.result.scan_id,
+            status: data.result.status,
+            category,
+            tool: toolName,
+            target,
+            result: data.result.result,
+            error: data.result.error,
+        };
+    }
+    async getScanStatus(scanId) {
+        const response = await fetch(`${this.baseUrl}/scan/${scanId}`);
+        if (!response.ok) {
+            throw new Error(`Failed to get scan status: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return {
+            scanId,
+            status: data.status,
+            category: data.category,
+            tool: data.tool,
+            target: data.target,
+            startedAt: data.started_at,
+            completedAt: data.completed_at,
+            result: data.result,
+            error: data.error,
+        };
+    }
+    async listScans() {
+        const response = await fetch(`${this.baseUrl}/scans`);
+        if (!response.ok) {
+            throw new Error(`Failed to list scans: ${response.statusText}`);
+        }
+        return response.json();
+    }
+}

package/extensions/hackingtool/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { HackingToolServerManager } from "./server-manager.js";
+import { HackingToolClient } from "./client.js";
+interface HackingToolConfig {
+    port?: number;
+    host?: string;
+    autoStart?: boolean;
+    token?: string;
+    pythonPath?: string;
+}
+export default function createPlugin(ctx: any): Promise<any>;
+export { HackingToolServerManager, HackingToolClient };
+export type { HackingToolConfig };

package/extensions/hackingtool/dist/index.js

@@ -0,0 +1,163 @@
+import { HackingToolServerManager } from "./server-manager.js";
+import { HackingToolClient } from "./client.js";
+export default async function createPlugin(ctx) {
+    const config = ctx.config;
+    const serverManager = new HackingToolServerManager({
+        port: config.port,
+        host: config.host,
+        pythonPath: config.pythonPath,
+    });
+    const client = new HackingToolClient({
+        host: config.host,
+        port: config.port,
+        token: config.token,
+    });
+    if (config.autoStart !== false) {
+        ctx.logger.info("Starting HackingTool MCP server...");
+        try {
+            await serverManager.start();
+            ctx.logger.info("HackingTool MCP server started successfully");
+        }
+        catch (err) {
+            ctx.logger.error("Failed to start HackingTool MCP server:", err);
+            throw err;
+        }
+    }
+    ctx.cli
+        .command("pentest.status")
+        .description("Check HackingTool server status")
+        .action(async () => {
+        try {
+            const health = await client.health();
+            console.log("✅ HackingTool is running");
+            console.log("   Status:", health.status);
+            console.log("   Version:", health.version ?? "unknown");
+            console.log("   Uptime:", health.uptime ? `${Math.floor(health.uptime / 60)}m` : "N/A");
+            console.log("   Tools Available:", health.toolsAvailable);
+            console.log("   Active Scans:", health.activeScans);
+        }
+        catch (err) {
+            console.error("❌ HackingTool is not running");
+            console.error("   Error:", err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+    ctx.cli
+        .command("pentest.tools")
+        .description("List available penetration testing tools")
+        .action(async () => {
+        try {
+            const tools = await client.getTools();
+            console.log("🔧 Available Penetration Testing Tools:\n");
+            for (const [category, toolList] of Object.entries(tools)) {
+                if (Array.isArray(toolList)) {
+                    console.log(`📁 ${category.toUpperCase().replace("_", " ")}`);
+                    for (const tool of toolList.slice(0, 10)) {
+                        console.log(`   • ${tool}`);
+                    }
+                    if (toolList.length > 10) {
+                        console.log(`   ... and ${toolList.length - 10} more`);
+                    }
+                    console.log();
+                }
+                else {
+                    console.log(`📁 ${category.toUpperCase().replace("_", " ")}`);
+                    const subCategories = toolList;
+                    for (const [subcat, subtools] of Object.entries(subCategories)) {
+                        console.log(`   ${subcat.replace("_", " ")}: ${subtools.slice(0, 5).join(", ")}`);
+                        if (subtools.length > 5) {
+                            console.log(`      ... and ${subtools.length - 5} more`);
+                        }
+                    }
+                    console.log();
+                }
+            }
+        }
+        catch (err) {
+            console.error("❌ Failed to get tools:", err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+    ctx.cli
+        .command("pentest.scan")
+        .description("Run penetration testing tool")
+        .argument("<category>", "Tool category (e.g., information_gathering, sql_injection, web_attack)")
+        .argument("<tool>", "Tool name (e.g., nmap, sqlmap, dirb)")
+        .argument("[target]", "Target URL or IP (optional)")
+        .option("-o, --output <file>", "Save results to file")
+        .action(async (category, tool, target, options) => {
+        try {
+            console.log(`🚀 Running ${tool} from ${category}...`);
+            if (target) {
+                console.log(`   Target: ${target}`);
+            }
+            const result = await client.runTool(category, tool, target);
+            console.log(`✅ Tool execution ${result.status}`);
+            console.log(`   Scan ID: ${result.scanId}`);
+            if (result.result) {
+                if (result.result.simulated) {
+                    console.log(`   ℹ️  ${result.result.message}`);
+                }
+                else if (result.result.stdout) {
+                    console.log("\n📊 Output:");
+                    console.log(result.result.stdout);
+                }
+                else if (result.result.error) {
+                    console.log(`   ❌ Error: ${result.result.error}`);
+                }
+            }
+            if (options?.output && result.result) {
+                const fs = await import("fs");
+                fs.writeFileSync(options.output, JSON.stringify(result.result, null, 2));
+                console.log(`\n💾 Results saved to: ${options.output}`);
+            }
+        }
+        catch (err) {
+            console.error("❌ Scan failed:", err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+    ctx.cli
+        .command("pentest.scans")
+        .description("List active scans")
+        .action(async () => {
+        try {
+            const scans = await client.listScans();
+            if (scans.length === 0) {
+                console.log("ℹ️  No active scans");
+                return;
+            }
+            console.log("🔍 Active Scans:\n");
+            for (const scan of scans) {
+                const statusIcon = scan.status === "running" ? "🔄" : scan.status === "completed" ? "✅" : "❌";
+                console.log(`${statusIcon} ${scan.scanId} - ${scan.tool} (${scan.status})`);
+                if (scan.target) {
+                    console.log(`   Target: ${scan.target}`);
+                }
+                console.log(`   Started: ${new Date((scan.startedAt || 0) * 1000).toLocaleString()}`);
+                console.log();
+            }
+        }
+        catch (err) {
+            console.error("❌ Failed to list scans:", err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+    ctx.cli
+        .command("pentest.stop")
+        .description("Stop HackingTool server")
+        .action(async () => {
+        ctx.logger.info("Stopping HackingTool server...");
+        await serverManager.stop();
+        console.log("✅ HackingTool server stopped");
+    });
+    return {
+        name: "hackingtool",
+        version: "1.2.0",
+        async onShutdown() {
+            ctx.logger.info("Stopping HackingTool server...");
+            await serverManager.stop();
+        },
+    };
+}
+export { HackingToolServerManager, HackingToolClient };

package/extensions/hackingtool/dist/server-manager.d.ts

@@ -0,0 +1,25 @@
+import { EventEmitter } from "events";
+interface ServerManagerConfig {
+    port?: number;
+    host?: string;
+    pythonPath?: string;
+}
+export declare class HackingToolServerManager extends EventEmitter {
+    private port;
+    private host;
+    private pythonPath;
+    private process;
+    private isRunning;
+    private healthCheckInterval?;
+    constructor(config?: ServerManagerConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getStatus(): {
+        running: boolean;
+        port: number;
+        host: string;
+    };
+    private startHealthChecks;
+    private stopHealthChecks;
+}
+export {};

package/extensions/hackingtool/dist/server-manager.js

@@ -0,0 +1,107 @@
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class HackingToolServerManager extends EventEmitter {
+    port;
+    host;
+    pythonPath;
+    process = null;
+    isRunning = false;
+    healthCheckInterval;
+    constructor(config = {}) {
+        super();
+        this.port = config.port ?? 8889;
+        this.host = config.host ?? "127.0.0.1";
+        this.pythonPath = config.pythonPath ?? "python3";
+    }
+    async start() {
+        if (this.isRunning) {
+            throw new Error("Server is already running");
+        }
+        const serverScript = resolve(__dirname, "./server/hackingtool_mcp.py");
+        return new Promise((resolve, reject) => {
+            try {
+                this.process = spawn(this.pythonPath, [
+                    serverScript,
+                    "--port",
+                    this.port.toString(),
+                    "--host",
+                    this.host,
+                ]);
+                this.process.stdout?.on("data", (data) => {
+                    const output = data.toString();
+                    this.emit("output", output);
+                    if (output.includes("running on")) {
+                        this.isRunning = true;
+                        this.startHealthChecks();
+                        resolve();
+                    }
+                });
+                this.process.stderr?.on("data", (data) => {
+                    const error = data.toString();
+                    this.emit("error", error);
+                    if (!this.isRunning) {
+                        reject(new Error(`Server failed to start: ${error}`));
+                    }
+                });
+                this.process.on("error", (err) => {
+                    this.isRunning = false;
+                    reject(new Error(`Spawn error: ${err.message}`));
+                });
+                this.process.on("exit", (code) => {
+                    this.isRunning = false;
+                    this.stopHealthChecks();
+                    this.emit("exit", code);
+                });
+                setTimeout(() => {
+                    if (!this.isRunning) {
+                        reject(new Error("Server startup timeout"));
+                    }
+                }, 10000);
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    async stop() {
+        if (!this.process || !this.isRunning) {
+            return;
+        }
+        return new Promise((resolve) => {
+            this.stopHealthChecks();
+            this.process?.kill("SIGTERM");
+            this.isRunning = false;
+            this.process = null;
+            resolve();
+        });
+    }
+    getStatus() {
+        return {
+            running: this.isRunning,
+            port: this.port,
+            host: this.host,
+        };
+    }
+    startHealthChecks() {
+        this.healthCheckInterval = setInterval(async () => {
+            try {
+                const response = await fetch(`http://${this.host}:${this.port}/health`);
+                if (!response.ok) {
+                    this.emit("health_check_failed", "Health check returned non-OK status");
+                }
+            }
+            catch (err) {
+                this.emit("health_check_failed", err instanceof Error ? err.message : String(err));
+            }
+        }, 30000);
+    }
+    stopHealthChecks() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = undefined;
+        }
+    }
+}

package/extensions/hackingtool/node_modules/.bin/tsc

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/bin/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/typescript@5.9.3/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/bin/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/typescript@5.9.3/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typescript/bin/tsc" "$@"
+else
+  exec node  "$basedir/../typescript/bin/tsc" "$@"
+fi

package/extensions/hackingtool/node_modules/.bin/tsserver

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/bin/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/typescript@5.9.3/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/bin/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/typescript@5.9.3/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typescript/bin/tsserver" "$@"
+else
+  exec node  "$basedir/../typescript/bin/tsserver" "$@"
+fi

package/extensions/hackingtool/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@poolbot/hackingtool",
+  "version": "2026.3.12",
+  "description": "HackingTool Security Platform - 100+ Penetration Testing Tools for PoolBot",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start:server": "python3 src/server/hackingtool_mcp.py",
+    "install:deps": "pip3 install -r src/server/requirements.txt"
+  },
+  "dependencies": {
+    "poolbot": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0"
+  },
+  "poolbot": {
+    "plugin": true,
+    "server": true,
+    "python": true
+  },
+  "keywords": [
+    "security",
+    "pentest",
+    "penetration-testing",
+    "scanning",
+    "vulnerability-assessment",
+    "ethical-hacking"
+  ],
+  "author": "PoolBot Team",
+  "license": "MIT"
+}

package/extensions/hackingtool/poolbot.plugin.json

@@ -0,0 +1,55 @@
+{
+  "id": "hackingtool",
+  "name": "HackingTool",
+  "version": "1.2.0",
+  "description": "Comprehensive penetration testing platform with 100+ security tools for ethical hacking and vulnerability assessment",
+  "author": "PoolBot Team",
+  "main": "dist/index.js",
+  "capabilities": [
+    "security",
+    "pentest",
+    "vulnerability-assessment",
+    "scanning",
+    "reconnaissance",
+    "exploitation"
+  ],
+  "commands": [
+    "pentest.status",
+    "pentest.tools",
+    "pentest.scan",
+    "pentest.scans",
+    "pentest.stop"
+  ],
+  "hooks": ["onInit", "onShutdown"],
+  "config": {
+    "port": 8889,
+    "host": "127.0.0.1",
+    "autoStart": true,
+    "pythonPath": "python3",
+    "toolCategories": [
+      "anonymity",
+      "information_gathering",
+      "wordlist",
+      "wireless",
+      "sql_injection",
+      "phishing",
+      "web_attack",
+      "post_exploitation",
+      "forensic",
+      "payload",
+      "exploit",
+      "reverse_engineering",
+      "ddos",
+      "rat",
+      "xss",
+      "steganography"
+    ],
+    "maxConcurrentScans": 5,
+    "scanTimeout": 600
+  },
+  "permissions": [
+    "gateway.rpc",
+    "telemetry.events",
+    "config.read"
+  ]
+}

package/extensions/hackingtool/src/client.ts

@@ -0,0 +1,120 @@
+import { EventEmitter } from "events";
+
+interface HackingToolClientConfig {
+  host?: string;
+  port?: number;
+  token?: string;
+}
+
+interface ScanResult {
+  scanId: string;
+  status: "running" | "completed" | "failed";
+  category?: string;
+  tool?: string;
+  target?: string;
+  result?: any;
+  error?: string;
+  startedAt?: number;
+  completedAt?: number;
+}
+
+export class HackingToolClient extends EventEmitter {
+  private baseUrl: string;
+  private token?: string;
+
+  constructor(config: HackingToolClientConfig = {}) {
+    super();
+    const host = config.host ?? "127.0.0.1";
+    const port = config.port ?? 8889;
+    this.baseUrl = `http://${host}:${port}`;
+    this.token = config.token;
+  }
+
+  async health(): Promise<{
+    status: string;
+    version: string;
+    uptime: number;
+    activeScans: number;
+    toolsAvailable: number;
+  }> {
+    const response = await fetch(`${this.baseUrl}/health`);
+    if (!response.ok) {
+      throw new Error(`Health check failed: ${response.statusText}`);
+    }
+    return response.json();
+  }
+
+  async getTools(): Promise<Record<string, string[]>> {
+    const response = await fetch(`${this.baseUrl}/tools`);
+    if (!response.ok) {
+      throw new Error(`Failed to get tools: ${response.statusText}`);
+    }
+    return response.json();
+  }
+
+  async runTool(
+    category: string,
+    toolName: string,
+    target?: string,
+    options?: Record<string, any>
+  ): Promise<ScanResult> {
+    const response = await fetch(`${this.baseUrl}/run_tool`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(this.token ? { Authorization: `Bearer ${this.token}` } : {}),
+      },
+      body: JSON.stringify({
+        method: "run_tool",
+        params: {
+          category,
+          tool_name: toolName,
+          target,
+          options,
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Tool execution failed: ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return {
+      scanId: data.result.scan_id,
+      status: data.result.status,
+      category,
+      tool: toolName,
+      target,
+      result: data.result.result,
+      error: data.result.error,
+    };
+  }
+
+  async getScanStatus(scanId: string): Promise<ScanResult> {
+    const response = await fetch(`${this.baseUrl}/scan/${scanId}`);
+    if (!response.ok) {
+      throw new Error(`Failed to get scan status: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      scanId,
+      status: data.status,
+      category: data.category,
+      tool: data.tool,
+      target: data.target,
+      startedAt: data.started_at,
+      completedAt: data.completed_at,
+      result: data.result,
+      error: data.error,
+    };
+  }
+
+  async listScans(): Promise<ScanResult[]> {
+    const response = await fetch(`${this.baseUrl}/scans`);
+    if (!response.ok) {
+      throw new Error(`Failed to list scans: ${response.statusText}`);
+    }
+    return response.json();
+  }
+}