@poolzin/pool-bot 2026.3.15 → 2026.3.16

package/extensions/dexter/src/agent.ts

@@ -0,0 +1,375 @@
+import { EventEmitter } from "events";
+
+interface DexterAgentConfig {
+  model?: string;
+  apiKey?: string;
+  financialDatasetsApiKey?: string;
+  exaApiKey?: string;
+  maxSteps?: number;
+}
+
+interface FinancialData {
+  ticker: string;
+  metric: string;
+  value: number;
+  period?: string;
+  date?: string;
+}
+
+interface ResearchResult {
+  query: string;
+  answer: string;
+  sources: Array<{
+    title: string;
+    url: string;
+    snippet: string;
+  }>;
+  financialData?: FinancialData[];
+  confidence: number;
+  stepsExecuted: number;
+}
+
+export class DexterAgent extends EventEmitter {
+  private config: DexterAgentConfig;
+  private activeQueries: Map<string, ResearchResult>;
+
+  constructor(config: DexterAgentConfig = {}) {
+    super();
+    this.config = config;
+    this.activeQueries = new Map();
+  }
+
+  async research(query: string): Promise<ResearchResult> {
+    const queryId = `query_${Date.now()}`;
+    
+    this.emit("start", { query, queryId });
+    
+    const result: ResearchResult = {
+      query,
+      answer: "",
+      sources: [],
+      financialData: [],
+      confidence: 0,
+      stepsExecuted: 0,
+    };
+
+    try {
+      const steps = this.planResearch(query);
+      
+      for (const step of steps) {
+        this.emit("step", { queryId, step, number: result.stepsExecuted + 1 });
+        
+        const stepResult = await this.executeStep(step);
+        result.stepsExecuted++;
+        
+        if (stepResult.type === "financial_data") {
+          result.financialData?.push(...stepResult.data);
+        } else if (stepResult.type === "web_search") {
+          result.sources.push(...stepResult.sources);
+        }
+        
+        if (result.stepsExecuted >= (this.config.maxSteps ?? 10)) {
+          break;
+        }
+      }
+      
+      result.answer = this.synthesizeAnswer(query, result);
+      result.confidence = this.calculateConfidence(result);
+      
+      this.activeQueries.set(queryId, result);
+      this.emit("complete", { queryId, result });
+      
+      return result;
+    } catch (error) {
+      this.emit("error", { queryId, error });
+      throw error;
+    }
+  }
+
+  private planResearch(query: string): Array<{ type: string; params: Record<string, any> }> {
+    const steps: Array<{ type: string; params: Record<string, any> }> = [];
+    
+    const tickerMatch = query.match(/\b([A-Z]{1,5})\b/);
+    if (tickerMatch) {
+      const ticker = tickerMatch[1];
+      
+      if (query.toLowerCase().includes("revenue") || query.toLowerCase().includes("income")) {
+        steps.push({
+          type: "financial_search",
+          params: { ticker, metric: "income_statements", limit: 4 },
+        });
+      }
+      
+      if (query.toLowerCase().includes("balance") || query.toLowerCase().includes("assets") || query.toLowerCase().includes("liabilities")) {
+        steps.push({
+          type: "financial_search",
+          params: { ticker, metric: "balance_sheets", limit: 4 },
+        });
+      }
+      
+      if (query.toLowerCase().includes("cash flow") || query.toLowerCase().includes("free cash")) {
+        steps.push({
+          type: "financial_search",
+          params: { ticker, metric: "cash_flow_statements", limit: 4 },
+        });
+      }
+      
+      if (query.toLowerCase().includes("metrics") || query.toLowerCase().includes("ratios") || query.toLowerCase().includes("pe ratio") || query.toLowerCase().includes("market cap")) {
+        steps.push({
+          type: "financial_metrics",
+          params: { ticker },
+        });
+      }
+    }
+    
+    if (query.toLowerCase().includes("news") || query.toLowerCase().includes("recent") || query.toLowerCase().includes("latest")) {
+      steps.push({
+        type: "web_search",
+        params: { 
+          query: `${tickerMatch ? tickerMatch[1] + " " : ""}${query}`,
+          numResults: 5,
+        },
+      });
+    }
+    
+    if (steps.length === 0) {
+      steps.push({
+        type: "web_search",
+        params: { query, numResults: 5 },
+      });
+    }
+    
+    return steps;
+  }
+
+  private async executeStep(
+    step: { type: string; params: Record<string, any> }
+  ): Promise<any> {
+    switch (step.type) {
+      case "financial_search": {
+        const { ticker, metric, limit } = step.params;
+        
+        if (!this.config.financialDatasetsApiKey) {
+          return {
+            type: "financial_data",
+            data: [],
+            simulated: true,
+            message: "Financial datasets API key not configured",
+          };
+        }
+        
+        const response = await fetch(
+          `https://api.financialdatasets.ai/financials/${ticker.toLowerCase()}/${metric}?limit=${limit}`,
+          {
+            headers: {
+              "X-API-Key": this.config.financialDatasetsApiKey!,
+            },
+          }
+        );
+        
+        if (!response.ok) {
+          throw new Error(`Financial API error: ${response.statusText}`);
+        }
+        
+        const data = await response.json();
+        return {
+          type: "financial_data",
+          data: this.parseFinancialData(data, metric),
+        };
+      }
+      
+      case "financial_metrics": {
+        const { ticker } = step.params;
+        
+        if (!this.config.financialDatasetsApiKey) {
+          return {
+            type: "financial_data",
+            data: [],
+            simulated: true,
+          };
+        }
+        
+        const response = await fetch(
+          `https://api.financialdatasets.ai/metrics/${ticker.toLowerCase()}`,
+          {
+            headers: {
+              "X-API-Key": this.config.financialDatasetsApiKey!,
+            },
+          }
+        );
+        
+        if (!response.ok) {
+          throw new Error(`Metrics API error: ${response.statusText}`);
+        }
+        
+        const data = await response.json();
+        return {
+          type: "financial_data",
+          data: this.parseMetricsData(data),
+        };
+      }
+      
+      case "web_search": {
+        const { query, numResults } = step.params;
+        
+        if (this.config.exaApiKey) {
+          const response = await fetch("https://api.exa.ai/search", {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "x-api-key": this.config.exaApiKey,
+            },
+            body: JSON.stringify({
+              query,
+              numResults: numResults || 5,
+              useAutoprompt: true,
+              type: "auto",
+            }),
+          });
+          
+          if (response.ok) {
+            const data = await response.json();
+            return {
+              type: "web_search",
+              sources: data.results?.map((r: any) => ({
+                title: r.title,
+                url: r.url,
+                snippet: r.text || r.summary || "",
+              })) || [],
+            };
+          }
+        }
+        
+        return {
+          type: "web_search",
+          sources: [],
+          simulated: true,
+          message: "Exa API key not configured",
+        };
+      }
+      
+      default:
+        return { type: "unknown" };
+    }
+  }
+
+  private parseFinancialData(data: any, metric: string): FinancialData[] {
+    const results: FinancialData[] = [];
+    
+    if (data?.financials) {
+      for (const financial of data.financials) {
+        if (metric === "income_statements" && financial.income_statement) {
+          const is = financial.income_statement;
+          results.push(
+            { ticker: data.ticker, metric: "revenue", value: is.revenue, period: financial.period, date: financial.fiscal_year },
+            { ticker: data.ticker, metric: "net_income", value: is.net_income, period: financial.period, date: financial.fiscal_year },
+            { ticker: data.ticker, metric: "operating_income", value: is.operating_income, period: financial.period, date: financial.fiscal_year }
+          );
+        }
+        
+        if (metric === "balance_sheets" && financial.balance_sheet) {
+          const bs = financial.balance_sheet;
+          results.push(
+            { ticker: data.ticker, metric: "total_assets", value: bs.total_assets, period: financial.period, date: financial.fiscal_year },
+            { ticker: data.ticker, metric: "total_liabilities", value: bs.total_liabilities, period: financial.period, date: financial.fiscal_year },
+            { ticker: data.ticker, metric: "total_equity", value: bs.total_equity, period: financial.period, date: financial.fiscal_year }
+          );
+        }
+        
+        if (metric === "cash_flow_statements" && financial.cash_flow_statement) {
+          const cf = financial.cash_flow_statement;
+          results.push(
+            { ticker: data.ticker, metric: "operating_cash_flow", value: cf.operating_cash_flow, period: financial.period, date: financial.fiscal_year },
+            { ticker: data.ticker, metric: "free_cash_flow", value: cf.free_cash_flow, period: financial.period, date: financial.fiscal_year }
+          );
+        }
+      }
+    }
+    
+    return results;
+  }
+
+  private parseMetricsData(data: any): FinancialData[] {
+    const results: FinancialData[] = [];
+    
+    if (data?.metrics) {
+      const m = data.metrics;
+      results.push(
+        { ticker: data.ticker, metric: "market_cap", value: m.market_cap, date: data.as_of_date },
+        { ticker: data.ticker, metric: "pe_ratio", value: m.price_to_earnings_ratio, date: data.as_of_date },
+        { ticker: data.ticker, metric: "pb_ratio", value: m.price_to_book_ratio, date: data.as_of_date },
+        { ticker: data.ticker, metric: "debt_to_equity", value: m.debt_to_equity, date: data.as_of_date },
+        { ticker: data.ticker, metric: "roe", value: m.return_on_equity, date: data.as_of_date }
+      );
+    }
+    
+    return results;
+  }
+
+  private synthesizeAnswer(_query: string, result: ResearchResult): string {
+    const parts: string[] = [];
+    
+    if (result.financialData && result.financialData.length > 0) {
+      parts.push("📊 **Financial Data:**\n");
+      const byTicker = new Map<string, FinancialData[]>();
+      
+      for (const data of result.financialData) {
+        if (!byTicker.has(data.ticker)) {
+          byTicker.set(data.ticker, []);
+        }
+        byTicker.get(data.ticker)!.push(data);
+      }
+      
+      for (const [ticker, data] of byTicker.entries()) {
+        parts.push(`**${ticker}**:`);
+        for (const item of data.slice(0, 8)) {
+          const formattedValue = typeof item.value === "number" 
+            ? item.value > 1e9 
+              ? `$${(item.value / 1e9).toFixed(2)}B`
+              : `$${item.value.toLocaleString()}`
+            : String(item.value);
+          parts.push(`  • ${item.metric.replace(/_/g, " ")}: ${formattedValue}${item.period ? ` (${item.period})` : ""}`);
+        }
+        parts.push("");
+      }
+    }
+    
+    if (result.sources.length > 0) {
+      parts.push("📰 **Sources:**\n");
+      for (const source of result.sources.slice(0, 5)) {
+        parts.push(`• [${source.title}](${source.url})`);
+      }
+    }
+    
+    if (result.stepsExecuted > 0) {
+      parts.push(`\n🔍 Research completed in ${result.stepsExecuted} step(s)`);
+    }
+    
+    return parts.join("\n") || "No relevant data found.";
+  }
+
+  private calculateConfidence(result: ResearchResult): number {
+    let score = 0;
+    
+    if (result.financialData && result.financialData.length > 0) {
+      score += 0.4;
+    }
+    
+    if (result.sources.length > 0) {
+      score += Math.min(0.3, result.sources.length * 0.06);
+    }
+    
+    if (result.stepsExecuted > 0) {
+      score += 0.3;
+    }
+    
+    return Math.min(1.0, score);
+  }
+
+  getActiveQueries(): Array<{ queryId: string; result: ResearchResult }> {
+    return Array.from(this.activeQueries.entries()).map(([queryId, result]) => ({
+      queryId,
+      result,
+    }));
+  }
+}

package/extensions/dexter/src/index.ts

@@ -0,0 +1,129 @@
+import { DexterAgent } from "./agent.js";
+
+interface DexterConfig {
+  model?: string;
+  apiKey?: string;
+  financialDatasetsApiKey?: string;
+  exaApiKey?: string;
+  maxSteps?: number;
+  autoStart?: boolean;
+}
+
+export default async function createPlugin(
+  ctx: any
+): Promise<any> {
+  const config = ctx.config as DexterConfig;
+  
+  const agent = new DexterAgent({
+    model: config.model ?? "gpt-4o",
+    apiKey: config.apiKey,
+    financialDatasetsApiKey: config.financialDatasetsApiKey,
+    exaApiKey: config.exaApiKey,
+    maxSteps: config.maxSteps ?? 10,
+  });
+
+  agent.on("start", ({ query, queryId: _queryId }) => {
+    ctx.logger.info(`🔍 Dexter research started: ${query}`);
+  });
+
+  agent.on("step", ({ queryId: _queryId, step, number }) => {
+    ctx.logger.info(`   Step ${number}: ${step.type}`);
+  });
+
+  agent.on("complete", ({ queryId: _queryId2, result }) => {
+    ctx.logger.info(`✅ Dexter research completed`);
+    ctx.logger.info(`   Confidence: ${(result.confidence * 100).toFixed(0)}%`);
+    ctx.logger.info(`   Steps: ${result.stepsExecuted}`);
+    ctx.logger.info(`   Sources: ${result.sources.length}`);
+  });
+
+  agent.on("error", ({ queryId: _queryId3, error }) => {
+    ctx.logger.error(`❌ Dexter research failed`, error);
+  });
+
+  ctx.cli
+    .command("finance.research")
+    .description("Run financial research query")
+    .argument("<query>", "Research question (e.g., 'AAPL revenue growth last 4 quarters')")
+    .option("-o, --output <file>", "Save results to file")
+    .action(async (query: string, options?: { output?: string }) => {
+      try {
+        console.log(`🔍 Starting financial research...`);
+        console.log(`   Query: ${query}\n`);
+        
+        const result = await agent.research(query);
+        
+        console.log(result.answer);
+        
+        if (options?.output && result) {
+          const fs = await import("fs");
+          fs.writeFileSync(options.output, JSON.stringify(result, null, 2));
+          console.log(`\n💾 Results saved to: ${options.output}`);
+        }
+      } catch (err) {
+        console.error("❌ Research failed:", err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
+  ctx.cli
+    .command("finance.status")
+    .description("Check Dexter agent status")
+    .action(async () => {
+      const queries = agent.getActiveQueries();
+      console.log("📊 Dexter Financial Research Agent");
+      console.log(`   Active Queries: ${queries.length}`);
+      
+      if (queries.length > 0) {
+        console.log("\n   Recent Queries:");
+      for (const { result } of queries.slice(-5)) {
+        console.log(`   • ${result.query}`);
+        console.log(`     Confidence: ${(result.confidence * 100).toFixed(0)}% | Steps: ${result.stepsExecuted}`);
+      }
+      }
+      
+      if (!config.financialDatasetsApiKey) {
+        console.log("\n⚠️  Warning: Financial datasets API key not configured");
+        console.log("   Set FINANCIAL_DATASETS_API_KEY environment variable for live data");
+      }
+      
+      if (!config.exaApiKey) {
+        console.log("\n⚠️  Warning: Exa API key not configured");
+        console.log("   Set EXA_API_KEY environment variable for web search");
+      }
+    });
+
+  ctx.cli
+    .command("finance.queries")
+    .description("List recent research queries")
+    .action(async () => {
+      const queries = agent.getActiveQueries();
+      
+      if (queries.length === 0) {
+        console.log("ℹ️  No research queries yet");
+        return;
+      }
+      
+      console.log("📊 Recent Research Queries:\n");
+      for (const { queryId: _queryId, result } of queries) {
+        const statusIcon = result.confidence > 0.7 ? "✅" : result.confidence > 0.4 ? "🟡" : "🟠";
+        console.log(`${statusIcon} ${_queryId}`);
+        console.log(`   Query: ${result.query}`);
+        console.log(`   Confidence: ${(result.confidence * 100).toFixed(0)}%`);
+        console.log(`   Steps: ${result.stepsExecuted}`);
+        console.log(`   Sources: ${result.sources.length}`);
+        if (result.financialData && result.financialData.length > 0) {
+          console.log(`   Financial Data Points: ${result.financialData.length}`);
+        }
+        console.log();
+      }
+    });
+
+  return {
+    name: "dexter",
+    version: "2026.3.8",
+  };
+}
+
+export { DexterAgent };
+export type { DexterConfig };

package/extensions/dexter/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "resolveJsonModule": true,
+    "baseUrl": ".",
+    "paths": {
+      "poolbot/*": ["../../packages/poolbot/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/extensions/hackingtool/README.md

@@ -0,0 +1,75 @@
+# HackingTool Extension for PoolBot
+
+Comprehensive penetration testing platform with 100+ security tools integrated into PoolBot.
+
+## Features
+
+- **100+ Security Tools**: Information gathering, SQL injection, XSS, phishing, wireless attacks, and more
+- **Automated Scanning**: Run security tools with simple CLI commands
+- **Real-time Monitoring**: Track active scans and view results
+- **Multi-Category Support**: 16+ categories of security testing tools
+
+## Installation
+
+```bash
+cd extensions/hackingtool
+pnpm install
+pnpm install:deps  # Install Python dependencies
+pnpm build
+```
+
+## Usage
+
+### Check Status
+```bash
+poolbot pentest.status
+```
+
+### List Available Tools
+```bash
+poolbot pentest.tools
+```
+
+### Run Security Scan
+```bash
+# Network scanning with nmap
+poolbot pentest.scan information_gathering nmap 192.168.1.1
+
+# SQL injection testing
+poolbot pentest.scan sql_injection sqlmap "http://example.com/page?id=1"
+
+# Directory brute-forcing
+poolbot pentest.scan web_attack dirb "http://example.com"
+```
+
+### View Active Scans
+```bash
+poolbot pentest.scans
+```
+
+### Stop Server
+```bash
+poolbot pentest.stop
+```
+
+## Tool Categories
+
+- **Anonymity**: Anonmously Surf, Multitor
+- **Information Gathering**: nmap, RED HAWK, ReconDog, Shodanfy
+- **SQL Injection**: Sqlmap, NoSqlMap, DSSS
+- **Web Attack**: Sublist3r, Dirb, CheckURL, Blazy
+- **XSS Attack**: DalFox, XSStrike, XSS-Freak
+- **Phishing**: Setoolkit, SocialFish, Evilginx2
+- **Wireless**: WiFi-Pumpkin, Wifite, Fluxion
+- **Payload Creation**: MSFvenom, Venom, The FatRat
+- **And 8+ more categories**
+
+## Requirements
+
+- Python 3.8+
+- Node.js 18+
+- Security tools installed on system (optional, tools will run in simulated mode if not available)
+
+## License
+
+MIT

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

@@ -0,0 +1,34 @@
+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 declare class HackingToolClient extends EventEmitter {
+    private baseUrl;
+    private token?;
+    constructor(config?: HackingToolClientConfig);
+    health(): Promise<{
+        status: string;
+        version: string;
+        uptime: number;
+        activeScans: number;
+        toolsAvailable: number;
+    }>;
+    getTools(): Promise<Record<string, string[]>>;
+    runTool(category: string, toolName: string, target?: string, options?: Record<string, any>): Promise<ScanResult>;
+    getScanStatus(scanId: string): Promise<ScanResult>;
+    listScans(): Promise<ScanResult[]>;
+}
+export {};