@poolzin/pool-bot 2026.3.13 → 2026.3.15

package/extensions/agency-agents/src/AgencyAgentsService.ts

@@ -0,0 +1,288 @@
+import type { AgencyAgent, AgentTask, AgentCollaboration, AgentMessage, AgentReview } from "./types.js";
+
+export class AgencyAgentsService {
+  private agents: Map<string, AgencyAgent> = new Map();
+  private tasks: Map<string, AgentTask> = new Map();
+  private collaborations: Map<string, AgentCollaboration> = new Map();
+
+  private messages: Map<string, AgentMessage> = new Map();
+  private reviews: Map<string, AgentReview> = new Map();
+
+  registerAgent(agent: AgencyAgent): void {
+    this.agents.set(agent.name.toLowerCase(), agent);
+  }
+
+  getAgent(name: string): AgencyAgent | undefined {
+    return this.agents.get(name.toLowerCase());
+  }
+
+  listAgents(category?: string): AgencyAgent[] {
+    const agents = Array.from(this.agents.values());
+    if (category) {
+      return agents.filter((a) => a.category.toLowerCase() === category.toLowerCase());
+    }
+    return agents;
+  }
+
+  findAgentsForTask(task: string): Array<{ agent: AgencyAgent; score: number }> {
+    const taskLower = task.toLowerCase();
+    const keywords = taskLower.split(/\s+/).filter((k) => k.length > 3);
+
+    const scored = Array.from(this.agents.values()).map((agent) => {
+      let score = 0;
+      const text = `${agent.name} ${agent.description} ${agent.category} ${agent.capabilities?.join(" ") || ""}`.toLowerCase();
+
+      for (const keyword of keywords) {
+        if (text.includes(keyword)) score += 2;
+      }
+
+      if (taskLower.includes("frontend") && agent.category === "engineering") score += 5;
+      if (taskLower.includes("backend") && agent.category === "engineering") score += 5;
+      if (taskLower.includes("design") && agent.category === "design") score += 5;
+      if (taskLower.includes("marketing") && agent.category === "marketing") score += 5;
+      if (taskLower.includes("test") && agent.category === "testing") score += 5;
+      if (taskLower.includes("product") && agent.category === "product") score += 5;
+      if (taskLower.includes("devops") && agent.category === "engineering") score += 5;
+
+      return { agent, score };
+    });
+
+    return scored.sort((a, b) => b.score - a.score);
+  }
+
+  createTask(agentName: string, task: string, context?: string, parentTaskId?: string): AgentTask {
+    const id = `task_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    const now = new Date();
+
+    const agentTask: AgentTask = {
+      id,
+      agentName,
+      task,
+      context,
+      status: "pending",
+      createdAt: now,
+      updatedAt: now,
+      parentTaskId,
+      subtasks: [],
+      dependencies: [],
+    };
+
+    this.tasks.set(id, agentTask);
+
+    if (parentTaskId) {
+      const parent = this.tasks.get(parentTaskId);
+      if (parent) {
+        parent.subtasks = parent.subtasks || [];
+        parent.subtasks.push(id);
+      }
+    }
+
+    return agentTask;
+  }
+
+  getTask(id: string): AgentTask | undefined {
+    return this.tasks.get(id);
+  }
+
+  updateTaskStatus(id: string, status: AgentTask["status"], output?: string): AgentTask | undefined {
+    const task = this.tasks.get(id);
+    if (task) {
+      task.status = status;
+      task.updatedAt = new Date();
+      if (output !== undefined) {
+        task.output = output;
+      }
+    }
+    return task;
+  }
+
+  listTasks(agentName?: string, status?: AgentTask["status"]): AgentTask[] {
+    let tasks = Array.from(this.tasks.values());
+
+    if (agentName) {
+      tasks = tasks.filter((t) => t.agentName.toLowerCase() === agentName.toLowerCase());
+    }
+
+    if (status) {
+      tasks = tasks.filter((t) => t.status === status);
+    }
+
+    return tasks.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+  }
+
+  createCollaboration(
+    name: string,
+    description: string,
+    leadAgent: string,
+    participatingAgents: string[]
+  ): AgentCollaboration {
+    const id = `collab_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    const now = new Date();
+
+    const collaboration: AgentCollaboration = {
+      id,
+      name,
+      description,
+      leadAgent,
+      participatingAgents: [leadAgent, ...participatingAgents.filter((a) => a !== leadAgent)],
+      tasks: [],
+      status: "planning",
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    this.collaborations.set(id, collaboration);
+    return collaboration;
+  }
+
+  getCollaboration(id: string): AgentCollaboration | undefined {
+    return this.collaborations.get(id);
+  }
+
+  addTaskToCollaboration(collaborationId: string, task: AgentTask): void {
+    const collaboration = this.collaborations.get(collaborationId);
+    if (collaboration) {
+      collaboration.tasks.push(task);
+      collaboration.updatedAt = new Date();
+    }
+  }
+
+  updateCollaborationStatus(id: string, status: AgentCollaboration["status"]): void {
+    const collaboration = this.collaborations.get(id);
+    if (collaboration) {
+      collaboration.status = status;
+      collaboration.updatedAt = new Date();
+    }
+  }
+
+  listCollaborations(status?: AgentCollaboration["status"]): AgentCollaboration[] {
+    let collabs = Array.from(this.collaborations.values());
+    if (status) {
+      collabs = collabs.filter((c) => c.status === status);
+    }
+    return collabs.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+  }
+
+  createMessage(
+    fromAgent: string,
+    toAgent: string,
+    collaborationId: string,
+    content: string,
+    type: AgentMessage["type"]
+  ): AgentMessage {
+    const id = `msg_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    const message: AgentMessage = {
+      id,
+      fromAgent,
+      toAgent,
+      collaborationId,
+      content,
+      type,
+      timestamp: new Date(),
+    };
+
+    this.messages.set(id, message);
+    return message;
+  }
+
+  getMessagesForCollaboration(collaborationId: string): AgentMessage[] {
+    return Array.from(this.messages.values())
+      .filter((m) => m.collaborationId === collaborationId)
+      .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+  }
+
+  createReview(
+    taskId: string,
+    reviewerAgent: string,
+    revieweeAgent: string,
+    feedback: string,
+    approvalStatus: AgentReview["approvalStatus"],
+    suggestions?: string[]
+  ): AgentReview {
+    const id = `review_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    const review: AgentReview = {
+      id,
+      taskId,
+      reviewerAgent,
+      revieweeAgent,
+      feedback,
+      approvalStatus,
+      suggestions,
+      createdAt: new Date(),
+    };
+
+    this.reviews.set(id, review);
+    return review;
+  }
+
+  getReviewsForTask(taskId: string): AgentReview[] {
+    return Array.from(this.reviews.values())
+      .filter((r) => r.taskId === taskId)
+      .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+  }
+
+  generateSystemPrompt(agentName: string, task?: string, context?: string): string | undefined {
+    const agent = this.agents.get(agentName.toLowerCase());
+    if (!agent) return undefined;
+
+    let prompt = `# ${agent.name}\n\n`;
+    prompt += `${agent.description}\n\n`;
+    prompt += `${agent.content}\n\n`;
+
+    if (agent.capabilities?.length) {
+      prompt += `## Capabilities\n\n`;
+      for (const cap of agent.capabilities) {
+        prompt += `- ${cap}\n`;
+      }
+      prompt += `\n`;
+    }
+
+    if (task) {
+      prompt += `---\n\n`;
+      prompt += `## Current Task\n\n${task}\n\n`;
+    }
+
+    if (context) {
+      prompt += `## Additional Context\n\n${context}\n\n`;
+    }
+
+    prompt += `---\n\n`;
+    prompt += `You are now activated as ${agent.name}. Embody this personality fully and deliver exceptional work.`;
+
+    return prompt;
+  }
+
+  getAgentCapabilities(agentName: string): string[] {
+    const agent = this.agents.get(agentName.toLowerCase());
+    return agent?.capabilities || [];
+  }
+
+  getStats(): {
+    totalAgents: number;
+    totalTasks: number;
+    activeCollaborations: number;
+    tasksByStatus: Record<AgentTask["status"], number>;
+  } {
+    const tasks = Array.from(this.tasks.values());
+    const tasksByStatus: Record<AgentTask["status"], number> = {
+      pending: 0,
+      in_progress: 0,
+      completed: 0,
+      failed: 0,
+      reviewing: 0,
+    };
+
+    for (const task of tasks) {
+      tasksByStatus[task.status]++;
+    }
+
+    return {
+      totalAgents: this.agents.size,
+      totalTasks: this.tasks.size,
+      activeCollaborations: Array.from(this.collaborations.values()).filter(
+        (c) => c.status === "active"
+      ).length,
+      tasksByStatus,
+    };
+  }
+}

package/extensions/agency-agents/src/types.ts

@@ -0,0 +1,147 @@
+export interface AgencyAgent {
+  name: string;
+  description: string;
+  color?: string;
+  category: string;
+  content: string;
+  capabilities: string[];
+  tools?: string[];
+}
+
+export interface AgentTask {
+  id: string;
+  agentName: string;
+  task: string;
+  context?: string;
+  status: "pending" | "in_progress" | "completed" | "failed" | "reviewing";
+  output?: string;
+  createdAt: Date;
+  updatedAt: Date;
+  parentTaskId?: string;
+  subtasks?: string[];
+  dependencies?: string[];
+}
+
+export interface AgentCollaboration {
+  id: string;
+  name: string;
+  description: string;
+  leadAgent: string;
+  participatingAgents: string[];
+  tasks: AgentTask[];
+  status: "planning" | "active" | "completed" | "paused";
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface WorkflowStep {
+  id: string;
+  name: string;
+  description: string;
+  agent: string;
+  task: string;
+  dependencies: string[];
+  status: "pending" | "in_progress" | "completed" | "failed";
+  output?: string;
+}
+
+export interface Workflow {
+  id: string;
+  name: string;
+  description: string;
+  category: string;
+  steps: WorkflowStep[];
+  status: "draft" | "active" | "completed" | "paused";
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface AgentMessage {
+  id: string;
+  fromAgent: string;
+  toAgent: string;
+  collaborationId: string;
+  content: string;
+  type: "request" | "response" | "update" | "review" | "handoff";
+  timestamp: Date;
+}
+
+export interface AgentReview {
+  id: string;
+  taskId: string;
+  reviewerAgent: string;
+  revieweeAgent: string;
+  feedback: string;
+  approvalStatus: "approved" | "changes_requested" | "pending";
+  suggestions?: string[];
+  createdAt: Date;
+}
+
+export interface AgencyAgentsConfig {
+  agentsDirectory?: string;
+  workflowsDirectory?: string;
+  enableCollaboration?: boolean;
+  maxConcurrentTasks?: number;
+  taskTimeoutMs?: number;
+  defaultReviewers?: string[];
+}
+
+export type AgentCategory =
+  | "engineering"
+  | "design"
+  | "marketing"
+  | "product"
+  | "testing"
+  | "strategy"
+  | "support"
+  | "project-management"
+  | "specialized"
+  | "spatial-computing"
+  | "integrations";
+
+export const AGENT_CATEGORIES: Record<AgentCategory, { label: string; description: string }> = {
+  engineering: {
+    label: "Engineering",
+    description: "Software development, architecture, DevOps, and technical implementation",
+  },
+  design: {
+    label: "Design",
+    description: "UI/UX design, visual design, brand identity, and user research",
+  },
+  marketing: {
+    label: "Marketing",
+    description: "Content creation, growth hacking, social media, and market analysis",
+  },
+  product: {
+    label: "Product",
+    description: "Product management, roadmap planning, and user feedback synthesis",
+  },
+  testing: {
+    label: "Testing",
+    description: "Quality assurance, testing strategies, and performance benchmarking",
+  },
+  strategy: {
+    label: "Strategy",
+    description: "Business strategy, project planning, and coordination playbooks",
+  },
+  support: {
+    label: "Support",
+    description: "Customer support, documentation, and operational assistance",
+  },
+  "project-management": {
+    label: "Project Management",
+    description: "Project coordination, sprint planning, and team orchestration",
+  },
+  specialized: {
+    label: "Specialized",
+    description: "Domain-specific agents for unique use cases and advanced scenarios",
+  },
+  "spatial-computing": {
+    label: "Spatial Computing",
+    description: "XR, VisionOS, and spatial interface development",
+  },
+  integrations: {
+    label: "Integrations",
+    description: "Third-party tool integrations and connector development",
+  },
+};

package/extensions/agency-agents/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+  },
+})

package/extensions/hexstrike-ai/README.md

@@ -0,0 +1,98 @@
+# HexStrike AI Extension for PoolBot
+
+Security scanning platform with 150+ integrated scanners (nmap, nuclei, sqlmap, gobuster, wpscan, etc.) now fully integrated into PoolBot.
+
+## Features
+
+- **150+ Security Scanners**: nmap, nuclei, sqlmap, gobuster, wpscan, nikto, dirb, and more
+- **Integrated Server**: Python server runs embedded within PoolBot
+- **CLI Commands**: Full CLI integration via `poolbot security`
+- **Gateway RPC**: Remote procedure calls for distributed setups
+- **Telemetry**: Events and metrics integrated with PoolBot telemetry
+
+## Installation
+
+The extension is automatically installed with PoolBot. Python dependencies:
+
+```bash
+cd extensions/hexstrike-ai
+pip3 install -r src/server/requirements.txt
+```
+
+## Usage
+
+### Check Server Status
+
+```bash
+poolbot security status
+```
+
+### List Available Scanners
+
+```bash
+poolbot security tools
+```
+
+### Run Security Scan
+
+```bash
+# Quick scan with default scanners
+poolbot security scan https://example.com
+
+# Scan with specific scanners
+poolbot security scan https://example.com --scanners nmap,nuclei
+
+# Full scan with all scanners
+poolbot security scan https://example.com --full
+```
+
+### Get Scan Report
+
+```bash
+poolbot security report <scan-id>
+```
+
+### Stop Server
+
+```bash
+poolbot security stop
+```
+
+## Configuration
+
+Add to your PoolBot config (`~/.poolbot/config.json`):
+
+```json
+{
+  "hexstrikeAi": {
+    "port": 8888,
+    "host": "127.0.0.1",
+    "autoStart": true,
+    "pythonPath": "python3",
+    "maxConcurrentScans": 3,
+    "scanTimeout": 3600
+  }
+}
+```
+
+## Architecture
+
+```
+PoolBot CLI → Extension HexStrike AI → Python Server (port 8888)
+                    ↓
+            Gateway RPC (distributed)
+                    ↓
+            Telemetry Events
+```
+
+## API Endpoints
+
+- `GET /health` - Health check
+- `GET /api/tools` - List available scanners
+- `POST /api/scan` - Start new scan
+- `GET /api/scan/:id` - Get scan results
+- `GET /api/scans` - List all scans
+
+## License
+
+MIT

package/extensions/hexstrike-ai/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/hexstrike-ai/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/hexstrike-ai/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@poolbot/hexstrike-ai",
+  "version": "2026.3.13",
+  "description": "HexStrike AI Security Platform - Integrated Server for PoolBot",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start:server": "python3 src/server/hexstrike_server.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", "scanning", "pentest", "nmap", "nuclei"],
+  "author": "PoolBot Team",
+  "license": "MIT"
+}

package/extensions/hexstrike-ai/poolbot.plugin.json

@@ -0,0 +1,31 @@
+{
+  "id": "hexstrike-ai",
+  "name": "HexStrike AI",
+  "version": "2026.3.13",
+  "description": "Security scanning platform with 150+ scanners integrated into PoolBot",
+  "author": "PoolBot Team",
+  "main": "dist/index.js",
+  "capabilities": ["security", "scanning", "pentest", "vulnerability-assessment"],
+  "commands": [
+    "security.status",
+    "security.tools",
+    "security.scan",
+    "security.report",
+    "security.stop"
+  ],
+  "hooks": ["onInit", "onShutdown"],
+  "config": {
+    "port": 8888,
+    "host": "127.0.0.1",
+    "autoStart": true,
+    "pythonPath": "python3",
+    "scanners": ["nmap", "nuclei", "sqlmap", "gobuster", "wpscan", "nikto", "dirb"],
+    "maxConcurrentScans": 3,
+    "scanTimeout": 3600
+  },
+  "permissions": [
+    "gateway.rpc",
+    "telemetry.events",
+    "config.read"
+  ]
+}