@poolzin/pool-bot 2026.3.13 → 2026.3.15

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

@@ -0,0 +1,91 @@
+export interface ScanTarget {
+  target: string;
+  scanners?: string[];
+  options?: Record<string, unknown>;
+}
+
+export interface ScanResult {
+  id: string;
+  status: "pending" | "running" | "completed" | "failed";
+  findings: Array<{
+    severity: "info" | "low" | "medium" | "high" | "critical";
+    title: string;
+    description: string;
+    remediation?: string;
+  }>;
+  metadata: {
+    startedAt: string;
+    completedAt?: string;
+    duration?: number;
+  };
+}
+
+export interface HealthStatus {
+  status: string;
+  version?: string;
+  uptime?: number;
+}
+
+export interface ToolsResponse {
+  tools: string[];
+}
+
+export interface ScanResponse {
+  id: string;
+}
+
+export class HexStrikeClient {
+  private baseUrl: string;
+  private token?: string;
+
+  constructor(config: { host?: string; port?: number; token?: string } = {}) {
+    const host = config.host ?? "127.0.0.1";
+    const port = config.port ?? 8888;
+    this.baseUrl = `http://${host}:${port}`;
+    this.token = config.token;
+  }
+
+  async health(): Promise<HealthStatus> {
+    const response = await fetch(`${this.baseUrl}/health`);
+    if (!response.ok) throw new Error(`Health check failed: ${response.status}`);
+    return response.json() as Promise<HealthStatus>;
+  }
+
+  async getTools(): Promise<string[]> {
+    const response = await fetch(`${this.baseUrl}/api/tools`, {
+      headers: this.getHeaders(),
+    });
+    if (!response.ok) throw new Error(`Failed to get tools: ${response.status}`);
+    const data = (await response.json()) as ToolsResponse;
+    return data.tools ?? [];
+  }
+
+  async scan(target: ScanTarget): Promise<{ scanId: string }> {
+    const response = await fetch(`${this.baseUrl}/api/scan`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(target),
+    });
+    if (!response.ok) throw new Error(`Scan failed: ${response.status}`);
+    const data = (await response.json()) as ScanResponse;
+    return { scanId: data.id };
+  }
+
+  async getScanResult(scanId: string): Promise<ScanResult> {
+    const response = await fetch(`${this.baseUrl}/api/scan/${scanId}`, {
+      headers: this.getHeaders(),
+    });
+    if (!response.ok) throw new Error(`Failed to get scan: ${response.status}`);
+    return response.json() as Promise<ScanResult>;
+  }
+
+  private getHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+    };
+    if (this.token) {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    }
+    return headers;
+  }
+}

package/extensions/hexstrike-ai/src/index.ts

@@ -0,0 +1,170 @@
+import type { PoolBotPlugin } from "poolbot/plugin-sdk";
+import { HexStrikeServerManager } from "./server-manager.js";
+import { HexStrikeClient } from "./client.js";
+
+interface HexStrikeConfig {
+  port?: number;
+  host?: string;
+  autoStart?: boolean;
+  token?: string;
+  pythonPath?: string;
+}
+
+export default async function createPlugin(
+  ctx: PoolBotPlugin.Context
+): Promise<PoolBotPlugin.Instance> {
+  const config = ctx.config as HexStrikeConfig;
+  const serverManager = new HexStrikeServerManager({
+    port: config.port,
+    host: config.host,
+    pythonPath: config.pythonPath,
+  });
+
+  const client = new HexStrikeClient({
+    host: config.host,
+    port: config.port,
+    token: config.token,
+  });
+
+  // Auto-start server if configured
+  if (config.autoStart !== false) {
+    ctx.logger.info("Starting HexStrike AI server...");
+    try {
+      await serverManager.start();
+      ctx.logger.info("HexStrike AI server started successfully");
+    } catch (err) {
+      ctx.logger.error("Failed to start HexStrike AI server:", err);
+      throw err;
+    }
+  }
+
+  // Register CLI commands
+  ctx.cli
+    .command("security.status")
+    .description("Check HexStrike AI server status")
+    .action(async () => {
+      try {
+        const health = await client.health();
+        console.log("✅ HexStrike AI 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");
+      } catch (err) {
+        console.error("❌ HexStrike AI is not running");
+        console.error("   Error:", err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
+  ctx.cli
+    .command("security.tools")
+    .description("List available security scanners")
+    .action(async () => {
+      try {
+        const tools = await client.getTools();
+        console.log("🔧 Available security scanners:");
+        for (const tool of tools) {
+          console.log(`   • ${tool}`);
+        }
+        console.log(`\nTotal: ${tools.length} scanners`);
+      } catch (err) {
+        console.error("❌ Failed to get tools:", err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
+  ctx.cli
+    .command("security.scan")
+    .description("Run security scan on target")
+    .argument("<target>", "Target URL or IP to scan")
+    .option("-s, --scanners <scanners>", "Comma-separated list of scanners (default: all)")
+    .option("-o, --output <file>", "Save report to file")
+    .action(async (target: string, options: { scanners?: string; output?: string }) => {
+      try {
+        const scanners = options.scanners?.split(",").map(s => s.trim()).filter(Boolean);
+        console.log(`🚀 Starting security scan on ${target}...`);
+        if (scanners) {
+          console.log(`   Scanners: ${scanners.join(", ")}`);
+        }
+        
+        const scan = await client.scan({
+          target,
+          scanners,
+        });
+        
+        console.log(`✅ Scan started: ${scan.scanId}`);
+        console.log(`   Use 'poolbot security report ${scan.scanId}' to check results`);
+        
+        if (options.output) {
+          // TODO: Poll for results and save to file
+          console.log(`   Report will be saved to: ${options.output}`);
+        }
+      } catch (err) {
+        console.error("❌ Scan failed:", err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
+  ctx.cli
+    .command("security.report")
+    .description("Get security scan report")
+    .argument("<scan-id>", "Scan ID from security scan command")
+    .option("-f, --format <format>", "Output format: json, table (default: table)")
+    .action(async (scanId: string, options: { format?: string }) => {
+      try {
+        const result = await client.getScanResult(scanId);
+        const format = options.format ?? "table";
+        
+        if (format === "json") {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`📊 Scan Report: ${scanId}`);
+          console.log(`   Status: ${result.status}`);
+          console.log(`   Started: ${result.metadata.startedAt}`);
+          if (result.metadata.completedAt) {
+            console.log(`   Completed: ${result.metadata.completedAt}`);
+          }
+          
+          if (result.findings.length > 0) {
+            console.log(`\n🔍 Findings (${result.findings.length}):`);
+            for (const finding of result.findings) {
+              const icon = {
+                critical: "🔴",
+                high: "🟠",
+                medium: "🟡",
+                low: "🟢",
+                info: "⚪",
+              }[finding.severity] ?? "⚪";
+              console.log(`   ${icon} [${finding.severity.toUpperCase()}] ${finding.title}`);
+            }
+          } else {
+            console.log("\n✅ No findings detected");
+          }
+        }
+      } catch (err) {
+        console.error("❌ Failed to get report:", err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
+  ctx.cli
+    .command("security.stop")
+    .description("Stop HexStrike AI server")
+    .action(async () => {
+      ctx.logger.info("Stopping HexStrike AI server...");
+      await serverManager.stop();
+      console.log("✅ HexStrike AI server stopped");
+    });
+
+  return {
+    name: "hexstrike-ai",
+    version: "2026.3.13",
+    async onShutdown() {
+      ctx.logger.info("Stopping HexStrike AI server...");
+      await serverManager.stop();
+    },
+  };
+}
+
+export { HexStrikeServerManager, HexStrikeClient };
+export type { HexStrikeConfig };