@covibes/zeroshot 5.4.0 → 5.4.1

package/src/tui/data-poller.js

@@ -1,349 +0,0 @@
-/**
- * DataPoller - Aggregates cluster data for TUI display
- *
- * Polls all data sources at appropriate intervals:
- * - Cluster states (1s)
- * - Resource stats via pidusage (2s)
- * - New cluster detection (2s)
- * - Ledger message streaming (500ms per cluster)
- */
-
-const pidusage = require('pidusage');
-const Ledger = require('../ledger');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-class DataPoller {
-  constructor(orchestrator, options = {}) {
-    this.orchestrator = orchestrator;
-    this.intervals = [];
-    this.ledgers = new Map(); // clusterId -> Ledger instance
-    this.ledgerStopFns = new Map(); // clusterId -> stop function for pollForMessages
-    this.onUpdate = options.onUpdate || (() => {}); // Callback for updates
-    this.watchForNewClustersStopFn = null;
-  }
-
-  /**
-   * Start all polling intervals
-   */
-  start() {
-    // Poll cluster states (1s)
-    const clusterStateInterval = setInterval(() => {
-      this._pollClusterStates();
-    }, 1000);
-    this.intervals.push(clusterStateInterval);
-
-    // Poll resource stats (2s)
-    const resourceStatsInterval = setInterval(() => {
-      this._pollResourceStats();
-    }, 2000);
-    this.intervals.push(resourceStatsInterval);
-
-    // Watch for new clusters (2s)
-    this._watchForNewClusters();
-
-    // Defer initial polls to avoid blocking UI startup
-    // Run in background after 50ms to let UI render first
-    setTimeout(() => {
-      this._pollClusterStates();
-    }, 50);
-
-    setTimeout(() => {
-      this._pollResourceStats();
-    }, 100);
-  }
-
-  /**
-   * Stop all polling intervals and clean up resources
-   */
-  stop() {
-    // Clear all intervals
-    for (const intervalId of this.intervals) {
-      clearInterval(intervalId);
-    }
-    this.intervals = [];
-
-    // Stop watching for new clusters
-    if (this.watchForNewClustersStopFn) {
-      this.watchForNewClustersStopFn();
-      this.watchForNewClustersStopFn = null;
-    }
-
-    // Stop all ledger polling
-    for (const stopFn of this.ledgerStopFns.values()) {
-      stopFn();
-    }
-    this.ledgerStopFns.clear();
-
-    // Close all ledger connections
-    for (const ledger of this.ledgers.values()) {
-      try {
-        ledger.close();
-      } catch {
-        // Ignore errors during cleanup
-      }
-    }
-    this.ledgers.clear();
-  }
-
-  /**
-   * Poll cluster states (1s interval)
-   * Gets all clusters and their agent states from orchestrator
-   * @private
-   */
-  _pollClusterStates() {
-    try {
-      const clusters = this.orchestrator.listClusters();
-
-      // Get detailed status for each cluster
-      const clustersWithStatus = clusters.map((cluster) => {
-        try {
-          const status = this.orchestrator.getStatus(cluster.id);
-          // Add agentCount for stats calculation
-          return {
-            ...status,
-            agentCount: status.agents ? status.agents.length : 0,
-          };
-        } catch (error) {
-          console.error(
-            `[DataPoller] Failed to get status for cluster ${cluster.id}:`,
-            error.message
-          );
-          return {
-            id: cluster.id,
-            state: 'unknown',
-            createdAt: cluster.createdAt,
-            agents: [],
-            agentCount: 0,
-            messageCount: 0,
-          };
-        }
-      });
-
-      this.onUpdate({
-        type: 'cluster_state',
-        clusters: clustersWithStatus,
-      });
-    } catch (error) {
-      console.error('[DataPoller] _pollClusterStates error:', error.message);
-    }
-  }
-
-  /**
-   * Poll resource stats (2s interval)
-   * Uses pidusage to get CPU and memory for all agent processes
-   * @private
-   */
-  async _pollResourceStats() {
-    try {
-      const clusters = this.orchestrator.listClusters();
-      const stats = {};
-      const pids = this._collectClusterPids(clusters);
-
-      if (pids.length > 0) {
-        const pidStats = await this._safePidUsage(pids);
-        this._populatePidStats(stats, pids, pidStats);
-      }
-
-      this.onUpdate({
-        type: 'resource_stats',
-        stats,
-      });
-    } catch (error) {
-      console.error('[DataPoller] _pollResourceStats error:', error.message);
-    }
-  }
-
-  /**
-   * Watch for new clusters (2s interval)
-   * Uses orchestrator.watchForNewClusters to detect new clusters
-   * and start streaming their ledger messages
-   * @private
-   */
-  _watchForNewClusters() {
-    this.watchForNewClustersStopFn = this.orchestrator.watchForNewClusters((cluster) => {
-      // Lazy load ledger only when we need to stream messages
-      // This avoids loading all ledgers on startup
-      const ledger = this._loadLedgerForCluster(cluster, {
-        label: 'cluster',
-        requireExisting: true,
-      });
-
-      if (!ledger) {
-        return;
-      }
-
-      // Start streaming messages
-      this._streamLedgerMessages(cluster.id);
-
-      // Emit update about new cluster
-      this.onUpdate({
-        type: 'new_cluster',
-        cluster,
-      });
-    }, 2000);
-
-    // Also load ledgers for all existing clusters
-    const existingClusters = this.orchestrator.listClusters();
-    for (const cluster of existingClusters) {
-      const ledger = this._loadLedgerForCluster(cluster, { label: 'existing cluster' });
-      if (!ledger) {
-        continue;
-      }
-
-      this._streamLedgerMessages(cluster.id);
-    }
-  }
-
-  /**
-   * Stream ledger messages for a cluster (500ms interval)
-   * Uses ledger.pollForMessages to get new messages
-   * @param {string} clusterId - Cluster ID to stream messages from
-   * @private
-   */
-  _streamLedgerMessages(clusterId) {
-    const ledger = this.ledgers.get(clusterId);
-    if (!ledger) {
-      console.error(`[DataPoller] No ledger found for cluster ${clusterId}`);
-      return;
-    }
-
-    // Stop existing polling if any
-    const existingStopFn = this.ledgerStopFns.get(clusterId);
-    if (existingStopFn) {
-      existingStopFn();
-    }
-
-    // Start polling for messages
-    const stopFn = ledger.pollForMessages(
-      clusterId,
-      (message) => {
-        this.onUpdate({
-          type: 'new_message',
-          clusterId,
-          message,
-        });
-      },
-      500, // Poll every 500ms
-      50 // Show last 50 messages initially
-    );
-
-    this.ledgerStopFns.set(clusterId, stopFn);
-  }
-
-  /**
-   * Collect resource stats for all agent PIDs
-   * @returns {Object} Map of pid -> { cpu, memory }
-   * @private
-   */
-  async _collectResourceStats() {
-    const stats = {};
-    const clusters = this.orchestrator.listClusters();
-
-    for (const cluster of clusters) {
-      const pids = this._getClusterAgentPids(cluster);
-      for (const pid of pids) {
-        stats[pid] = await this._getSinglePidStat(pid);
-      }
-    }
-
-    return stats;
-  }
-
-  _collectClusterPids(clusters) {
-    const pids = [];
-
-    for (const cluster of clusters) {
-      pids.push(...this._getClusterAgentPids(cluster));
-    }
-
-    return pids;
-  }
-
-  _getClusterAgentPids(cluster) {
-    try {
-      const status = this.orchestrator.getStatus(cluster.id);
-      const pids = [];
-
-      for (const agent of status.agents || []) {
-        if (agent.pid) {
-          pids.push(agent.pid);
-        }
-      }
-
-      return pids;
-    } catch {
-      // Skip clusters that error
-      return [];
-    }
-  }
-
-  async _getSinglePidStat(pid) {
-    try {
-      const pidStat = await pidusage(pid);
-      return {
-        cpu: pidStat.cpu || 0,
-        memory: pidStat.memory || 0,
-      };
-    } catch {
-      // Process died - set to zero
-      return { cpu: 0, memory: 0 };
-    }
-  }
-
-  async _safePidUsage(pids) {
-    try {
-      return await pidusage(pids);
-    } catch {
-      return null;
-    }
-  }
-
-  _populatePidStats(stats, pids, pidStats) {
-    for (const pid of pids) {
-      const entry = pidStats?.[pid];
-      stats[pid] = {
-        cpu: entry?.cpu || 0,
-        memory: entry?.memory || 0,
-      };
-    }
-  }
-
-  _loadLedgerForCluster(cluster, options) {
-    const { label, requireExisting = false } = options;
-
-    try {
-      return this._ensureLedger(cluster.id, { requireExisting });
-    } catch (error) {
-      console.error(
-        `[DataPoller] Failed to load ledger for ${label} ${cluster.id}:`,
-        error.message
-      );
-      return null;
-    }
-  }
-
-  _ensureLedger(clusterId, { requireExisting = false } = {}) {
-    const existing = this.ledgers.get(clusterId);
-    if (existing) {
-      return existing;
-    }
-
-    const dbPath = this._getLedgerPath(clusterId);
-    if (requireExisting && !fs.existsSync(dbPath)) {
-      return null;
-    }
-
-    const ledger = new Ledger(dbPath);
-    this.ledgers.set(clusterId, ledger);
-    return ledger;
-  }
-
-  _getLedgerPath(clusterId) {
-    const storageDir = this.orchestrator.storageDir || path.join(os.homedir(), '.zeroshot');
-    return path.join(storageDir, `${clusterId}.db`);
-  }
-}
-
-module.exports = DataPoller;

package/src/tui/demo.js

@@ -1,208 +0,0 @@
-/**
- * TUI Dashboard Demo
- * Simple demonstration of the dashboard layout with mock data
- *
- * Run: node src/tui/demo.js
- * Press: [q] to quit
- */
-
-const blessed = require('blessed');
-const {
-  createLayout,
-  updateClustersTable,
-  updateAgentsTable,
-  updateStatsBox,
-  addLogEntry,
-} = require('./layout');
-const { formatTimestamp } = require('./formatters');
-
-// Create main screen
-const screen = blessed.screen({
-  mouse: true,
-  title: 'Cluster Dashboard - Demo',
-  smartCSR: true,
-});
-
-// Create layout
-const layout = createLayout(screen);
-
-// Mock data generators
-const mockClusters = [
-  {
-    id: 'cluster-swift-falcon',
-    status: 'running',
-    agentCount: 5,
-    config: 'default',
-    uptime: formatTimestamp(2 * 60 * 60 * 1000 + 30 * 60 * 1000), // 2h 30m
-  },
-  {
-    id: 'cluster-bold-panther',
-    status: 'running',
-    agentCount: 3,
-    config: 'simple',
-    uptime: formatTimestamp(45 * 60 * 1000), // 45m
-  },
-  {
-    id: 'cluster-quick-eagle',
-    status: 'stopped',
-    agentCount: 0,
-    config: 'default',
-    uptime: '0s',
-  },
-];
-
-const mockAgents = [
-  {
-    clusterId: 'cluster-swift-falcon',
-    id: 'worker-1',
-    role: 'worker',
-    status: 'running',
-    iteration: 3,
-    cpu: '12.5%',
-    memory: '245 MB',
-  },
-  {
-    clusterId: 'cluster-swift-falcon',
-    id: 'validator-req',
-    role: 'validator',
-    status: 'idle',
-    iteration: 0,
-    cpu: '0.1%',
-    memory: '128 MB',
-  },
-  {
-    clusterId: 'cluster-swift-falcon',
-    id: 'validator-sec',
-    role: 'validator',
-    status: 'idle',
-    iteration: 0,
-    cpu: '0.2%',
-    memory: '135 MB',
-  },
-  {
-    clusterId: 'cluster-bold-panther',
-    id: 'worker-2',
-    role: 'worker',
-    status: 'running',
-    iteration: 1,
-    cpu: '8.3%',
-    memory: '189 MB',
-  },
-  {
-    clusterId: 'cluster-bold-panther',
-    id: 'validator-qa',
-    role: 'validator',
-    status: 'running',
-    iteration: 1,
-    cpu: '5.1%',
-    memory: '156 MB',
-  },
-];
-
-const mockStats = {
-  activeClusters: 2,
-  totalAgents: 5,
-  usedMemory: '853 MB',
-  totalMemory: '8 GB',
-  totalCPU: '26.2%',
-};
-
-// Keyboard shortcuts
-screen.key(['q', 'C-c'], () => {
-  return process.exit(0);
-});
-
-screen.key(['r'], () => {
-  updateClustersTable(layout.clustersTable, mockClusters);
-  updateAgentsTable(layout.agentTable, mockAgents);
-  updateStatsBox(layout.statsBox, mockStats);
-  addLogEntry(layout.logsBox, 'Dashboard refreshed', 'info');
-  screen.render();
-});
-
-screen.key(['c'], () => {
-  addLogEntry(layout.logsBox, 'Cluster started: cluster-wandering-wolf', 'info');
-  screen.render();
-});
-
-screen.key(['k'], () => {
-  addLogEntry(layout.logsBox, 'Cluster killed: cluster-quick-eagle', 'warn');
-  screen.render();
-});
-
-screen.key(['s'], () => {
-  addLogEntry(layout.logsBox, 'Warning: High memory usage on cluster-swift-falcon', 'warn');
-  screen.render();
-});
-
-// Initialize with mock data
-updateClustersTable(layout.clustersTable, mockClusters);
-updateAgentsTable(layout.agentTable, mockAgents);
-updateStatsBox(layout.statsBox, mockStats);
-
-// Add initial log entries
-addLogEntry(layout.logsBox, 'Dashboard initialized', 'info');
-addLogEntry(layout.logsBox, 'Monitoring 2 active clusters', 'info');
-addLogEntry(layout.logsBox, 'System CPU: 26.2% | Memory: 853 MB / 8 GB', 'info');
-
-// Simulate live updates
-const updateInterval = setInterval(() => {
-  // Update uptime for running clusters
-  mockClusters.forEach((cluster) => {
-    if (cluster.status === 'running') {
-      const uptimeMs = Math.random() * 3 * 60 * 60 * 1000; // Random uptime
-      cluster.uptime = formatTimestamp(uptimeMs);
-    }
-  });
-
-  // Simulate CPU/Memory changes
-  mockAgents.forEach((agent) => {
-    if (agent.status === 'running') {
-      agent.cpu = (Math.random() * 20).toFixed(1) + '%';
-      agent.memory = Math.floor(Math.random() * 200 + 100) + ' MB';
-    }
-  });
-
-  mockStats.totalCPU = (Math.random() * 50).toFixed(1) + '%';
-
-  updateClustersTable(layout.clustersTable, mockClusters);
-  updateAgentsTable(layout.agentTable, mockAgents);
-  updateStatsBox(layout.statsBox, mockStats);
-
-  screen.render();
-}, 3000);
-
-// Display help on startup
-setTimeout(() => {
-  addLogEntry(
-    layout.logsBox,
-    'Press [r] to refresh | [c] to add cluster | [k] to kill | [s] for warning | [q] to quit',
-    'info'
-  );
-  screen.render();
-}, 500);
-
-// Cleanup on exit
-process.on('exit', () => {
-  clearInterval(updateInterval);
-});
-
-// Render initial screen
-screen.render();
-
-console.log(
-  '\n' +
-    '===============================================\n' +
-    '  Cluster Dashboard - Demo Mode\n' +
-    '===============================================\n' +
-    'Keyboard shortcuts:\n' +
-    '  [↑/↓]     Navigate between widgets\n' +
-    '  [Tab]     Next widget\n' +
-    '  [Shift+Tab] Previous widget\n' +
-    '  [r]       Refresh data\n' +
-    '  [c]       Simulate cluster start\n' +
-    '  [k]       Simulate cluster kill\n' +
-    '  [s]       Simulate warning\n' +
-    '  [q]       Quit\n' +
-    '===============================================\n\n'
-);

package/src/tui/formatters.js

@@ -1,129 +0,0 @@
-/**
- * TUI Display Formatters
- * Converts raw values to human-readable formats for terminal display
- */
-
-/**
- * Convert milliseconds to human-readable uptime string
- * @param {number} ms - Milliseconds
- * @returns {string} Formatted uptime (e.g., "5m 23s", "2h 15m", "3d 4h")
- */
-const formatTimestamp = (ms) => {
-  if (!ms || ms < 0) return '0s';
-
-  const seconds = Math.floor(ms / 1000);
-
-  if (seconds < 60) {
-    return `${seconds}s`;
-  }
-
-  const minutes = Math.floor(seconds / 60);
-  if (minutes < 60) {
-    const remainingSeconds = seconds % 60;
-    return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
-  }
-
-  const hours = Math.floor(minutes / 60);
-  if (hours < 24) {
-    const remainingMinutes = minutes % 60;
-    return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
-  }
-
-  const days = Math.floor(hours / 24);
-  const remainingHours = hours % 24;
-  return remainingHours > 0 ? `${days}d ${remainingHours}h` : `${days}d`;
-};
-
-/**
- * Convert bytes to human-readable size string
- * @param {number} bytes - Number of bytes
- * @returns {string} Formatted size (e.g., "245 MB", "1.2 GB", "512 KB")
- */
-const formatBytes = (bytes) => {
-  if (!bytes || bytes < 0) return '0 B';
-
-  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
-  let size = bytes;
-  let unitIndex = 0;
-
-  while (size >= 1000 && unitIndex < units.length - 1) {
-    size /= 1000;
-    unitIndex++;
-  }
-
-  const formatted = size < 10 ? size.toFixed(1) : Math.round(size);
-  return `${formatted} ${units[unitIndex]}`;
-};
-
-/**
- * Format CPU percentage with consistent precision
- * @param {number} percent - CPU percentage (0-100)
- * @returns {string} Formatted percentage (e.g., "12.3%", "0.1%")
- */
-const formatCPU = (percent) => {
-  if (typeof percent !== 'number' || percent < 0) return '0.0%';
-
-  // Assert normalized range (should never exceed 100% after per-core normalization)
-  let normalizedPercent = percent;
-  if (normalizedPercent > 100) {
-    console.warn(`[formatCPU] CPU percent ${percent}% exceeds 100% - normalization bug?`);
-    normalizedPercent = 100;
-  }
-
-  return `${normalizedPercent.toFixed(1)}%`;
-};
-
-/**
- * Map cluster state to unicode icon
- * @param {string} state - Cluster state (running, stopped, initializing, stopping, failed, killed)
- * @returns {string} Unicode icon representing state
- */
-const stateIcon = (state) => {
-  const icons = {
-    running: '●', // filled circle (green)
-    stopped: '○', // hollow circle
-    initializing: '◐', // half circle
-    stopping: '◑', // half circle other way
-    failed: '⚠', // warning
-    killed: '⚠', // warning
-  };
-
-  return icons[state] || '?';
-};
-
-/**
- * Truncate string with ellipsis if exceeds max length
- * @param {string} str - String to truncate
- * @param {number} maxLen - Maximum length
- * @returns {string} Truncated string with "..." if needed
- */
-const truncate = (str, maxLen) => {
-  if (!str || typeof str !== 'string') return '';
-  if (str.length <= maxLen) return str;
-
-  return str.substring(0, maxLen - 3) + '...';
-};
-
-/**
- * Format duration between two timestamps
- * @param {number} startMs - Start timestamp in milliseconds
- * @param {number} endMs - End timestamp in milliseconds (null = now)
- * @returns {string} Formatted duration (e.g., "5m 23s", "2h 15m")
- */
-const formatDuration = (startMs, endMs) => {
-  if (!startMs || startMs < 0) return '0s';
-
-  const end = endMs && endMs > 0 ? endMs : Date.now();
-  const duration = Math.max(0, end - startMs);
-
-  return formatTimestamp(duration);
-};
-
-module.exports = {
-  formatTimestamp,
-  formatBytes,
-  formatCPU,
-  stateIcon,
-  truncate,
-  formatDuration,
-};