@covibes/zeroshot 5.4.0 → 5.4.1

package/src/logic-engine.js

@@ -1,223 +0,0 @@
-/**
- * LogicEngine - JavaScript sandbox for agent decision logic
- *
- * Provides:
- * - Isolated VM for executing agent trigger logic
- * - Timeout enforcement (1 second)
- * - Ledger API access for queries
- * - Helper functions for common patterns
- * - Sandbox security (no fs, network, child_process)
- */
-
-const vm = require('vm');
-
-class LogicEngine {
-  constructor(messageBus, cluster) {
-    this.messageBus = messageBus;
-    this.cluster = cluster;
-    this.timeout = 1000; // 1 second
-  }
-
-  /**
-   * Evaluate a trigger logic script
-   * @param {String} script - JavaScript code to evaluate
-   * @param {Object} agent - Agent context
-   * @param {Object} message - Triggering message
-   * @returns {Boolean} Whether agent should wake up
-   */
-  evaluate(script, agent, message) {
-    try {
-      // Build sandbox context
-      const context = this._buildContext(agent, message);
-
-      // Create isolated context with frozen prototypes
-      // This prevents prototype pollution attacks
-      const isolatedContext = {};
-
-      // Freeze Object, Array, Function prototypes in the sandbox
-      isolatedContext.Object = Object.freeze({ ...Object });
-      isolatedContext.Array = Array;
-      isolatedContext.Function = Function;
-
-      // Copy safe context properties
-      Object.assign(isolatedContext, context);
-
-      // Wrap script to prevent prototype access
-      const wrappedScript = `(function() {
-        'use strict';
-        // Prevent prototype pollution
-        const frozenObject = Object;
-        const frozenArray = Array;
-        Object.freeze(frozenObject.prototype);
-        Object.freeze(frozenArray.prototype);
-
-        ${script}
-      })()`;
-
-      // Create and run in context
-      vm.createContext(isolatedContext);
-      const result = vm.runInContext(wrappedScript, isolatedContext, {
-        timeout: this.timeout,
-        displayErrors: true,
-      });
-
-      // Coerce to boolean
-      return Boolean(result);
-    } catch (error) {
-      console.error(`Logic evaluation error for agent ${agent.id}:`, error.message);
-      return false; // Default to false on error
-    }
-  }
-
-  /**
-   * Build sandbox context with APIs and helpers
-   * @private
-   */
-  _buildContext(agent, message) {
-    const clusterId = agent.cluster_id;
-
-    // Ledger API wrapper (auto-scoped to cluster)
-    const ledgerAPI = {
-      query: (criteria) => {
-        return this.messageBus.query({ ...criteria, cluster_id: clusterId });
-      },
-
-      findLast: (criteria) => {
-        return this.messageBus.findLast({ ...criteria, cluster_id: clusterId });
-      },
-
-      count: (criteria) => {
-        return this.messageBus.count({ ...criteria, cluster_id: clusterId });
-      },
-
-      since: (timestamp) => {
-        return this.messageBus.since({ cluster_id: clusterId, timestamp });
-      },
-    };
-
-    // Helper functions
-    const helpers = {
-      /**
-       * Check if all agents have responded to a topic since a timestamp
-       */
-      allResponded: (agents, topic, since) => {
-        const responses = ledgerAPI.query({ topic, since });
-        const responders = new Set(responses.map((r) => r.sender));
-        return agents.every((a) => responders.has(a.id || a));
-      },
-
-      /**
-       * Check if all responses have approved=true
-       */
-      hasConsensus: (topic, since) => {
-        const responses = ledgerAPI.query({ topic, since });
-        if (responses.length === 0) return false;
-        return responses.every((r) => r.content?.data?.approved === true);
-      },
-
-      /**
-       * Get time since last message on topic (in milliseconds)
-       */
-      timeSinceLastMessage: (topic) => {
-        const last = ledgerAPI.findLast({ topic });
-        if (!last) return Infinity;
-        return Date.now() - last.timestamp;
-      },
-
-      /**
-       * Check if a topic has any messages since timestamp
-       */
-      hasMessagesSince: (topic, since) => {
-        const count = ledgerAPI.count({ topic, since });
-        return count > 0;
-      },
-
-      /**
-       * Get cluster config based on complexity and task type
-       * Returns: { base: 'template-name', params: { ... } }
-       */
-      getConfig: require('./config-router').getConfig,
-    };
-
-    // Cluster API wrapper
-    const clusterAPI = {
-      id: clusterId,
-
-      getAgents: () => {
-        return this.cluster ? this.cluster.agents || [] : [];
-      },
-
-      getAgentsByRole: (role) => {
-        return this.cluster ? (this.cluster.agents || []).filter((a) => a.role === role) : [];
-      },
-
-      getAgent: (id) => {
-        return this.cluster ? (this.cluster.agents || []).find((a) => a.id === id) : null;
-      },
-    };
-
-    // Build context
-    return {
-      // Agent context
-      agent: {
-        id: agent.id,
-        role: agent.role,
-        iteration: agent.iteration || 0,
-      },
-
-      // Triggering message
-      message: message || null,
-
-      // APIs
-      ledger: ledgerAPI,
-      cluster: clusterAPI,
-      helpers,
-
-      // Safe built-ins
-      Set,
-      Map,
-      Array,
-      Object,
-      String,
-      Number,
-      Boolean,
-      Math,
-      Date,
-      JSON,
-
-      // No-op console (prevent output in production)
-      console: {
-        log: () => {},
-        error: () => {},
-        warn: () => {},
-        info: () => {},
-      },
-    };
-  }
-
-  /**
-   * Validate script syntax without executing
-   * @param {String} script - JavaScript code
-   * @returns {Object} { valid: Boolean, error: String }
-   */
-  validateScript(script) {
-    try {
-      // Wrap in function like evaluate() does
-      const wrappedScript = `(function() { ${script} })()`;
-      new vm.Script(wrappedScript);
-      return { valid: true, error: null };
-    } catch (error) {
-      return { valid: false, error: error.message };
-    }
-  }
-
-  /**
-   * Set timeout for script execution
-   * @param {Number} ms - Timeout in milliseconds
-   */
-  setTimeout(ms) {
-    this.timeout = ms;
-  }
-}
-
-module.exports = LogicEngine;

package/src/message-bus-bridge.js

@@ -1,139 +0,0 @@
-/**
- * MessageBusBridge - Bridges parent and child message buses
- *
- * Forwards specified topics between parent and child clusters while maintaining
- * isolation and preventing message loops.
- *
- * Features:
- * - Forward specified parent topics to child (contextStrategy.parentTopics)
- * - Forward child completion events to parent
- * - Namespace child topics to avoid collisions
- * - Prevent message loops via forwarding flags
- */
-
-class MessageBusBridge {
-  constructor(parentBus, childBus, config) {
-    this.parentBus = parentBus;
-    this.childBus = childBus;
-    this.config = config;
-
-    this.parentUnsubscribe = null;
-    this.childUnsubscribe = null;
-    this.active = false;
-
-    this._setupBridge();
-  }
-
-  /**
-   * Set up bidirectional message forwarding
-   * @private
-   */
-  _setupBridge() {
-    // Forward specified parent topics to child
-    if (this.config.parentTopics && this.config.parentTopics.length > 0) {
-      this.parentUnsubscribe = this.parentBus.subscribe((message) => {
-        this._forwardParentToChild(message);
-      });
-    }
-
-    // Forward child completion/failure events to parent
-    this.childUnsubscribe = this.childBus.subscribe((message) => {
-      this._forwardChildToParent(message);
-    });
-
-    this.active = true;
-  }
-
-  /**
-   * Forward parent message to child cluster
-   * @private
-   */
-  _forwardParentToChild(message) {
-    // Only forward messages from parent cluster
-    if (message.cluster_id !== this.config.parentClusterId) {
-      return;
-    }
-
-    // Only forward topics specified in config
-    if (!this.config.parentTopics.includes(message.topic)) {
-      return;
-    }
-
-    // Skip already-forwarded messages (prevent loops)
-    if (message.metadata?.forwarded) {
-      return;
-    }
-
-    // Forward to child with metadata flag
-    this.childBus.publish({
-      ...message,
-      cluster_id: this.config.childClusterId,
-      metadata: {
-        ...message.metadata,
-        forwarded: true,
-        forwardedFrom: this.config.parentClusterId,
-      },
-    });
-  }
-
-  /**
-   * Forward child message to parent cluster
-   * @private
-   */
-  _forwardChildToParent(message) {
-    // Only forward messages from child cluster
-    if (message.cluster_id !== this.config.childClusterId) {
-      return;
-    }
-
-    // Only forward completion/failure events
-    const forwardTopics = ['CLUSTER_COMPLETE', 'CLUSTER_FAILED', 'AGENT_ERROR'];
-    if (!forwardTopics.includes(message.topic)) {
-      return;
-    }
-
-    // Skip already-forwarded messages (prevent loops)
-    if (message.metadata?.forwarded) {
-      return;
-    }
-
-    // Forward to parent with namespaced topic and metadata flag
-    this.parentBus.publish({
-      ...message,
-      cluster_id: this.config.parentClusterId,
-      topic: `CHILD_${message.topic}`,
-      metadata: {
-        ...message.metadata,
-        forwarded: true,
-        forwardedFrom: this.config.childClusterId,
-        childClusterId: this.config.childClusterId,
-      },
-    });
-  }
-
-  /**
-   * Close the bridge and stop forwarding
-   */
-  close() {
-    if (this.parentUnsubscribe) {
-      this.parentUnsubscribe();
-      this.parentUnsubscribe = null;
-    }
-
-    if (this.childUnsubscribe) {
-      this.childUnsubscribe();
-      this.childUnsubscribe = null;
-    }
-
-    this.active = false;
-  }
-
-  /**
-   * Check if bridge is active
-   */
-  isActive() {
-    return this.active;
-  }
-}
-
-module.exports = MessageBusBridge;

package/src/message-bus.js

@@ -1,249 +0,0 @@
-/**
- * MessageBus - Pub/sub layer over Ledger with WebSocket support
- *
- * Provides:
- * - High-level publish/subscribe API
- * - WebSocket broadcasting for UI clients
- * - Topic-based routing
- * - Real-time event distribution
- */
-
-const EventEmitter = require('events');
-const Ledger = require('./ledger');
-
-// Expected listeners per cluster:
-// - 5 orchestrator subscriptions (CLUSTER_COMPLETE, CLUSTER_FAILED, AGENT_ERROR, AGENT_LIFECYCLE, CLUSTER_OPERATIONS)
-// - 1 ledger internal
-// - 1 per agent (can be 10+ with dynamic spawning)
-// - topic-specific listeners
-const MAX_LISTENERS = 50;
-
-class MessageBus extends EventEmitter {
-  constructor(ledger) {
-    super();
-    this.setMaxListeners(MAX_LISTENERS);
-    this.ledger = ledger || new Ledger();
-    this.wsClients = new Set();
-
-    // Forward ledger events
-    this.ledger.on('message', (message) => {
-      this.emit('message', message);
-      this._broadcastToWebSocket(message);
-    });
-  }
-
-  /**
-   * Publish a message to the ledger
-   * @param {Object} message - Message to publish
-   * @returns {Object} Published message with ID
-   */
-  publish(message) {
-    if (!message.cluster_id) {
-      throw new Error('cluster_id is required');
-    }
-
-    if (!message.topic) {
-      throw new Error('topic is required');
-    }
-
-    if (!message.sender) {
-      throw new Error('sender is required');
-    }
-
-    const published = this.ledger.append(message);
-
-    // If ledger is closed, append returns null - skip emission
-    if (!published) {
-      return null;
-    }
-
-    // Emit to topic-specific listeners
-    this.emit(`topic:${message.topic}`, published);
-
-    return published;
-  }
-
-  /**
-   * Subscribe to all messages
-   * @param {Function} callback - Called with each message
-   * @returns {Function} Unsubscribe function
-   */
-  subscribe(callback) {
-    this.on('message', callback);
-    return () => this.off('message', callback);
-  }
-
-  /**
-   * Subscribe to specific topic
-   * @param {String} topic - Topic to subscribe to
-   * @param {Function} callback - Called with matching messages
-   * @returns {Function} Unsubscribe function
-   */
-  subscribeTopic(topic, callback) {
-    const event = `topic:${topic}`;
-    this.on(event, callback);
-    return () => this.off(event, callback);
-  }
-
-  /**
-   * Subscribe to multiple topics
-   * @param {Array<String>} topics - Topics to subscribe to
-   * @param {Function} callback - Called with matching messages
-   * @returns {Function} Unsubscribe function
-   */
-  subscribeTopics(topics, callback) {
-    const unsubscribers = topics.map((topic) => this.subscribeTopic(topic, callback));
-    return () => unsubscribers.forEach((unsub) => unsub());
-  }
-
-  /**
-   * Query messages (passthrough to ledger)
-   */
-  query(criteria) {
-    return this.ledger.query(criteria);
-  }
-
-  /**
-   * Find last message (passthrough to ledger)
-   */
-  findLast(criteria) {
-    return this.ledger.findLast(criteria);
-  }
-
-  /**
-   * Count messages (passthrough to ledger)
-   */
-  count(criteria) {
-    return this.ledger.count(criteria);
-  }
-
-  /**
-   * Get messages since timestamp (passthrough to ledger)
-   */
-  since(params) {
-    return this.ledger.since(params);
-  }
-
-  /**
-   * Get all messages (passthrough to ledger)
-   */
-  getAll(cluster_id) {
-    return this.ledger.getAll(cluster_id);
-  }
-
-  /**
-   * Publish multiple messages atomically
-   * All messages are committed in a single transaction with contiguous timestamps.
-   * Use this for task completion to prevent message interleaving between agents.
-   *
-   * @param {Array<Object>} messages - Array of messages to publish
-   * @returns {Array<Object>} Published messages with IDs
-   */
-  batchPublish(messages) {
-    // Validate all messages
-    for (const message of messages) {
-      if (!message.cluster_id) {
-        throw new Error('cluster_id is required for all messages');
-      }
-      if (!message.topic) {
-        throw new Error('topic is required for all messages');
-      }
-      if (!message.sender) {
-        throw new Error('sender is required for all messages');
-      }
-    }
-
-    // Delegate to ledger's atomic batchAppend
-    const published = this.ledger.batchAppend(messages);
-
-    // Emit to topic-specific listeners for each message
-    for (const msg of published) {
-      this.emit(`topic:${msg.topic}`, msg);
-    }
-
-    return published;
-  }
-
-  /**
-   * Get aggregated token usage by role (passthrough to ledger)
-   * @param {String} cluster_id - Cluster ID
-   * @returns {Object} Token usage aggregated by role with _total key
-   */
-  getTokensByRole(cluster_id) {
-    return this.ledger.getTokensByRole(cluster_id);
-  }
-
-  /**
-   * Register a WebSocket client for broadcasts
-   * @param {WebSocket} ws - WebSocket connection
-   */
-  addWebSocketClient(ws) {
-    this.wsClients.add(ws);
-
-    ws.on('close', () => {
-      this.wsClients.delete(ws);
-    });
-
-    ws.on('error', () => {
-      this.wsClients.delete(ws);
-    });
-  }
-
-  /**
-   * Remove a WebSocket client
-   * @param {WebSocket} ws - WebSocket connection
-   */
-  removeWebSocketClient(ws) {
-    this.wsClients.delete(ws);
-  }
-
-  /**
-   * Broadcast message to all WebSocket clients
-   * @private
-   */
-  _broadcastToWebSocket(message) {
-    const payload = JSON.stringify({
-      type: 'message',
-      data: message,
-    });
-
-    for (const ws of this.wsClients) {
-      if (ws.readyState === 1) {
-        // OPEN
-        try {
-          ws.send(payload);
-        } catch (error) {
-          console.error('WebSocket send error:', error);
-          this.wsClients.delete(ws);
-        }
-      }
-    }
-  }
-
-  /**
-   * Close the message bus
-   */
-  close() {
-    // Close all WebSocket connections
-    for (const ws of this.wsClients) {
-      try {
-        ws.close();
-      } catch {
-        // Ignore errors on close
-      }
-    }
-    this.wsClients.clear();
-
-    // Close ledger
-    this.ledger.close();
-  }
-
-  /**
-   * Clear all messages (for testing)
-   */
-  clear() {
-    this.ledger.clear();
-  }
-}
-
-module.exports = MessageBus;