cipher-security 5.0.0

package/lib/autonomous/parallel.js

@@ -0,0 +1,587 @@
+// Copyright (c) 2026 defconxt. All rights reserved.
+// Licensed under AGPL-3.0 — see LICENSE file for details.
+// CIPHER is a trademark of defconxt.
+
+/**
+ * Parallel agent execution engine for CIPHER autonomous operations.
+ *
+ * Provides Promise-based parallel execution of agent tasks with
+ * fan-out/fan-in, map-reduce, pipeline, and callback patterns.
+ *
+ * Python threading.Thread → Promise.all + concurrency limiter.
+ *
+ * @module autonomous/parallel
+ */
+
+import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { basename, dirname } from 'node:path';
+
+// ---------------------------------------------------------------------------
+// Data classes
+// ---------------------------------------------------------------------------
+
+export class AgentTask {
+  constructor({
+    taskId = randomUUID(),
+    name = '',
+    skillPath = '',
+    inputData = {},
+    status = 'pending',
+    result = null,
+    error = null,
+    startTime = 0,
+    endTime = 0,
+    workerId = 0,
+  } = {}) {
+    this.taskId = taskId;
+    this.name = name;
+    this.skillPath = skillPath;
+    this.inputData = inputData;
+    this.status = status;
+    this.result = result;
+    this.error = error;
+    this.startTime = startTime;
+    this.endTime = endTime;
+    this.workerId = workerId;
+  }
+}
+
+export class AgentResult {
+  constructor({
+    taskId = '',
+    success = false,
+    output = {},
+    duration = 0,
+    workerId = 0,
+    error = null,
+  } = {}) {
+    this.taskId = taskId;
+    this.success = success;
+    this.output = output;
+    this.duration = duration;
+    this.workerId = workerId;
+    this.error = error;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// WorkerPool — Promise-based concurrency limiter
+// ---------------------------------------------------------------------------
+
+export class WorkerPool {
+  /**
+   * @param {number} [maxWorkers=4]
+   */
+  constructor(maxWorkers = 4) {
+    this.maxWorkers = maxWorkers;
+    /** @type {Map<string, AgentTask>} */
+    this._tasks = new Map();
+    /** @type {Map<string, AgentResult>} */
+    this._results = new Map();
+    this._pendingCount = 0;
+    this._activeCount = 0;
+    this._completedCount = 0;
+    this._shutdown = false;
+    /** @type {AgentTask[]} */
+    this._queue = [];
+    /** @type {Array<{resolve: Function}>} */
+    this._waiters = [];
+  }
+
+  /**
+   * Submit a single task. Returns its taskId.
+   * @param {AgentTask} task
+   * @returns {string}
+   */
+  submit(task) {
+    this._tasks.set(task.taskId, task);
+    this._pendingCount += 1;
+    this._queue.push(task);
+    return task.taskId;
+  }
+
+  /**
+   * Submit several tasks at once.
+   * @param {AgentTask[]} tasks
+   * @returns {string[]}
+   */
+  submitBatch(tasks) {
+    return tasks.map(t => this.submit(t));
+  }
+
+  /**
+   * Return result for taskId, or null if not yet done.
+   * @param {string} taskId
+   * @returns {AgentResult|null}
+   */
+  getResult(taskId) {
+    return this._results.get(taskId) || null;
+  }
+
+  /** Return all results collected so far. */
+  getAllResults() {
+    return [...this._results.values()];
+  }
+
+  /**
+   * Execute all queued tasks with concurrency limit, then return results.
+   * @param {number} [timeout=300000] - ms
+   * @returns {Promise<AgentResult[]>}
+   */
+  async waitAll(timeout = 300000) {
+    const tasks = [...this._queue];
+    this._queue = [];
+
+    // Process tasks with concurrency limit
+    const inFlight = new Set();
+    let workerCounter = 0;
+
+    for (const task of tasks) {
+      if (this._shutdown) break;
+      if (task.status === 'cancelled') continue;
+
+      const workerId = workerCounter++ % this.maxWorkers;
+
+      const promise = this._executeTask(task, workerId).then(result => {
+        inFlight.delete(promise);
+        this._results.set(task.taskId, result);
+        task.status = result.success ? 'completed' : 'failed';
+        task.result = result.output;
+        task.error = result.error;
+        this._activeCount -= 1;
+        this._completedCount += 1;
+        this._pendingCount -= 1;
+      });
+
+      this._activeCount += 1;
+      inFlight.add(promise);
+
+      if (inFlight.size >= this.maxWorkers) {
+        await Promise.race(inFlight);
+      }
+    }
+
+    // Wait for remaining in-flight tasks
+    if (inFlight.size > 0) {
+      await Promise.race([
+        Promise.all(inFlight),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('waitAll timeout')), timeout)),
+      ]).catch(() => { /* timeout — return what we have */ });
+    }
+
+    // Notify any waiters
+    for (const w of this._waiters) w.resolve();
+    this._waiters = [];
+
+    return this.getAllResults();
+  }
+
+  /**
+   * Cancel a pending task.
+   * @param {string} taskId
+   * @returns {boolean}
+   */
+  cancel(taskId) {
+    const task = this._tasks.get(taskId);
+    if (task && task.status === 'pending') {
+      task.status = 'cancelled';
+      this._pendingCount -= 1;
+      this._results.set(taskId, new AgentResult({
+        taskId,
+        success: false,
+        output: {},
+        duration: 0,
+        workerId: 0,
+        error: 'cancelled',
+      }));
+      return true;
+    }
+    return false;
+  }
+
+  /** Cancel every pending task in the queue. */
+  cancelAll() {
+    for (const task of this._tasks.values()) {
+      if (task.status === 'pending') {
+        task.status = 'cancelled';
+        this._pendingCount -= 1;
+        this._results.set(task.taskId, new AgentResult({
+          taskId: task.taskId,
+          success: false,
+          output: {},
+          duration: 0,
+          workerId: 0,
+          error: 'cancelled',
+        }));
+      }
+    }
+  }
+
+  /** Return a snapshot of pool state. */
+  getStatus() {
+    return {
+      active: this._activeCount,
+      pending: this._pendingCount,
+      completed: this._completedCount,
+      totalTasks: this._tasks.size,
+      maxWorkers: this.maxWorkers,
+      shutdown: this._shutdown,
+    };
+  }
+
+  /** Signal workers to stop. */
+  shutdown() {
+    this._shutdown = true;
+  }
+
+  // -- internal -----------------------------------------------------------
+
+  /**
+   * @param {AgentTask} task
+   * @param {number} workerId
+   * @returns {Promise<AgentResult>}
+   */
+  async _executeTask(task, workerId = 0) {
+    const start = performance.now() / 1000;
+    try {
+      const output = {};
+
+      // Check skill path
+      if (task.skillPath && existsSync(task.skillPath)) {
+        output.skillLoaded = task.skillPath;
+        output.skillName = basename(dirname(task.skillPath));
+      } else {
+        output.skillLoaded = null;
+      }
+
+      // Run callable if present
+      const fn = task.inputData.fn;
+      if (typeof fn === 'function') {
+        const args = task.inputData.args || [];
+        const kwargs = task.inputData.kwargs || {};
+        const fnResult = await fn(...args, kwargs);
+        output.fnResult = fnResult;
+      } else {
+        output.inputEcho = task.inputData;
+      }
+
+      const duration = performance.now() / 1000 - start;
+      task.startTime = start;
+      task.endTime = start + duration;
+      task.workerId = workerId;
+
+      return new AgentResult({
+        taskId: task.taskId,
+        success: true,
+        output,
+        duration,
+        workerId,
+      });
+    } catch (exc) {
+      const duration = performance.now() / 1000 - start;
+      task.startTime = start;
+      task.endTime = start + duration;
+      task.workerId = workerId;
+
+      return new AgentResult({
+        taskId: task.taskId,
+        success: false,
+        output: {},
+        duration,
+        workerId,
+        error: `${exc.constructor.name}: ${exc.message}`,
+      });
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// ParallelScanner
+// ---------------------------------------------------------------------------
+
+export class ParallelScanner {
+  /**
+   * @param {WorkerPool} [pool]
+   */
+  constructor(pool) {
+    this.pool = pool || new WorkerPool();
+  }
+
+  /**
+   * Create one task per target, fan-out, collect results.
+   * @param {string[]} targets
+   * @param {string} [profile='pentest']
+   */
+  async scanTargets(targets, profile = 'pentest') {
+    const tasks = targets.map(target => new AgentTask({
+      name: `scan-${target}`,
+      inputData: {
+        fn: ParallelScanner._runScan,
+        args: [target, profile],
+      },
+    }));
+    const ids = this.pool.submitBatch(tasks);
+    const idSet = new Set(ids);
+    await this.pool.waitAll();
+    const allResults = this.pool.getAllResults();
+    const results = allResults.filter(r => idSet.has(r.taskId));
+    const idToTarget = Object.fromEntries(ids.map((id, i) => [id, targets[i]]));
+    return results.map(r => ({
+      taskId: r.taskId,
+      target: idToTarget[r.taskId] || 'unknown',
+      success: r.success,
+      output: r.output,
+      duration: r.duration,
+      error: r.error,
+    }));
+  }
+
+  /**
+   * Run domain-specific recon scans in parallel.
+   * @param {string[]} domains
+   */
+  async scanDomains(domains) {
+    const tasks = domains.map(domain => new AgentTask({
+      name: `domain-scan-${domain}`,
+      inputData: {
+        fn: ParallelScanner._runDomainScan,
+        args: [domain],
+      },
+    }));
+    const ids = this.pool.submitBatch(tasks);
+    const idSet = new Set(ids);
+    await this.pool.waitAll();
+    const allResults = this.pool.getAllResults();
+    const results = allResults.filter(r => idSet.has(r.taskId));
+    return {
+      domainsScanned: domains.length,
+      successful: results.filter(r => r.success).length,
+      failed: results.filter(r => !r.success).length,
+      results: results.map(r => ({
+        taskId: r.taskId,
+        success: r.success,
+        output: r.output,
+        error: r.error,
+      })),
+    };
+  }
+
+  static _runScan(target, profile) {
+    return {
+      target,
+      profile,
+      findings: [],
+      status: 'complete',
+      timestamp: Date.now() / 1000,
+    };
+  }
+
+  static _runDomainScan(domain) {
+    return {
+      domain,
+      dnsRecords: [],
+      subdomains: [],
+      ports: [],
+      status: 'complete',
+      timestamp: Date.now() / 1000,
+    };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// ParallelAnalyzer
+// ---------------------------------------------------------------------------
+
+export class ParallelAnalyzer {
+  /**
+   * @param {WorkerPool} [pool]
+   */
+  constructor(pool) {
+    this.pool = pool || new WorkerPool();
+  }
+
+  /**
+   * Analyze multiple diffs concurrently for security issues.
+   * @param {string[]} diffs
+   */
+  async analyzeDiffs(diffs) {
+    const tasks = diffs.map((diff, idx) => new AgentTask({
+      name: `diff-analysis-${idx}`,
+      inputData: {
+        fn: ParallelAnalyzer._analyzeSingleDiff,
+        args: [diff],
+      },
+    }));
+    const ids = this.pool.submitBatch(tasks);
+    const idSet = new Set(ids);
+    await this.pool.waitAll();
+    const allResults = this.pool.getAllResults();
+    const results = allResults.filter(r => idSet.has(r.taskId));
+    return results.map(r => ({
+      taskId: r.taskId,
+      success: r.success,
+      analysis: r.output?.fnResult || {},
+      error: r.error,
+    }));
+  }
+
+  /**
+   * Score multiple responses in parallel.
+   * @param {object[]} responses
+   */
+  async bulkScore(responses) {
+    const tasks = responses.map((resp, idx) => new AgentTask({
+      name: `score-${idx}`,
+      inputData: {
+        fn: ParallelAnalyzer._scoreResponse,
+        args: [resp],
+      },
+    }));
+    const ids = this.pool.submitBatch(tasks);
+    const idSet = new Set(ids);
+    await this.pool.waitAll();
+    const allResults = this.pool.getAllResults();
+    const results = allResults.filter(r => idSet.has(r.taskId));
+    return results.map(r => ({
+      taskId: r.taskId,
+      success: r.success,
+      score: r.output?.fnResult || {},
+      error: r.error,
+    }));
+  }
+
+  static _analyzeSingleDiff(diff) {
+    const lines = diff ? diff.trim().split('\n') : [];
+    const additions = lines.filter(l => l.startsWith('+')).length;
+    const deletions = lines.filter(l => l.startsWith('-')).length;
+    return {
+      totalLines: lines.length,
+      additions,
+      deletions,
+      riskIndicators: [],
+      severity: 'info',
+    };
+  }
+
+  static _scoreResponse(response) {
+    let score = 0.5;
+    const flags = [];
+    if ('error' in response) {
+      score -= 0.3;
+      flags.push('contains_error');
+    }
+    if (response.status === 'complete') {
+      score += 0.2;
+      flags.push('complete');
+    }
+    return {
+      score: Math.max(0.0, Math.min(1.0, score)),
+      flags,
+    };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// TaskOrchestrator
+// ---------------------------------------------------------------------------
+
+export class TaskOrchestrator {
+  /**
+   * @param {number} [maxWorkers=4]
+   */
+  constructor(maxWorkers = 4) {
+    this.maxWorkers = maxWorkers;
+    this._totalTasks = 0;
+    this._totalDuration = 0;
+    this._totalFailures = 0;
+  }
+
+  /**
+   * Submit all tasks, wait for completion, return results.
+   * @param {AgentTask[]} tasks
+   * @returns {Promise<AgentResult[]>}
+   */
+  async fanOut(tasks) {
+    const pool = new WorkerPool(this.maxWorkers);
+    pool.submitBatch(tasks);
+    const results = await pool.waitAll();
+    pool.shutdown();
+    this._recordMetrics(results);
+    return results;
+  }
+
+  /**
+   * Fan-out tasks; invoke callback as each completes.
+   * @param {AgentTask[]} tasks
+   * @param {(result: AgentResult) => void} callback
+   */
+  async fanOutWithCallback(tasks, callback) {
+    const pool = new WorkerPool(this.maxWorkers);
+    pool.submitBatch(tasks);
+    const results = await pool.waitAll();
+    for (const r of results) {
+      callback(r);
+    }
+    pool.shutdown();
+    this._recordMetrics(results);
+  }
+
+  /**
+   * Fan-out tasks then apply reduceFn to collected results.
+   * @param {AgentTask[]} tasks
+   * @param {(results: AgentResult[]) => *} reduceFn
+   */
+  async mapReduce(tasks, reduceFn) {
+    const results = await this.fanOut(tasks);
+    return reduceFn(results);
+  }
+
+  /**
+   * Execute stages sequentially; within each stage tasks run in parallel.
+   * @param {AgentTask[][]} stages
+   * @returns {Promise<AgentResult[]>}
+   */
+  async pipeline(stages) {
+    const allResults = [];
+    let priorResults = [];
+
+    for (const stageTasks of stages) {
+      for (const task of stageTasks) {
+        task.inputData.priorResults = priorResults.map(r => ({
+          taskId: r.taskId,
+          success: r.success,
+          output: r.output,
+          error: r.error,
+        }));
+      }
+
+      priorResults = await this.fanOut(stageTasks);
+      allResults.push(...priorResults);
+    }
+
+    return allResults;
+  }
+
+  /** Return throughput, average duration, and failure rate. */
+  getMetrics() {
+    const avg = this._totalTasks > 0 ? this._totalDuration / this._totalTasks : 0;
+    const failureRate = this._totalTasks > 0 ? this._totalFailures / this._totalTasks : 0;
+    return {
+      totalTasks: this._totalTasks,
+      totalDuration: Math.round(this._totalDuration * 10000) / 10000,
+      avgDuration: Math.round(avg * 10000) / 10000,
+      failureRate: Math.round(failureRate * 10000) / 10000,
+      maxWorkers: this.maxWorkers,
+    };
+  }
+
+  /** @param {AgentResult[]} results */
+  _recordMetrics(results) {
+    for (const r of results) {
+      this._totalTasks += 1;
+      this._totalDuration += r.duration;
+      if (!r.success) this._totalFailures += 1;
+    }
+  }
+}