@covibes/zeroshot 1.0.1

package/src/tui/data-poller.js

@@ -0,0 +1,325 @@
+/**
+ * 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 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 = {};
+
+      // Collect all PIDs from all agents
+      const pids = [];
+      for (const cluster of clusters) {
+        try {
+          const status = this.orchestrator.getStatus(cluster.id);
+          for (const agent of status.agents || []) {
+            if (agent.pid) {
+              pids.push(agent.pid);
+            }
+          }
+        } catch {
+          // Skip clusters that error
+          continue;
+        }
+      }
+
+      // Get stats for all PIDs
+      if (pids.length > 0) {
+        try {
+          const pidStats = await pidusage(pids);
+
+          // Convert to map format: pid -> { cpu, memory }
+          for (const pid of pids) {
+            if (pidStats[pid]) {
+              stats[pid] = {
+                cpu: pidStats[pid].cpu || 0,
+                memory: pidStats[pid].memory || 0,
+              };
+            } else {
+              // Process died - set to zero
+              stats[pid] = { cpu: 0, memory: 0 };
+            }
+          }
+        } catch {
+          // pidusage throws if any process is dead
+          // Set all to zero and continue
+          for (const pid of pids) {
+            stats[pid] = { cpu: 0, memory: 0 };
+          }
+        }
+      }
+
+      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) => {
+      try {
+        // Lazy load ledger only when we need to stream messages
+        // This avoids loading all ledgers on startup
+        if (!this.ledgers.has(cluster.id)) {
+          const storageDir = this.orchestrator.storageDir || path.join(os.homedir(), '.zeroshot');
+          const dbPath = path.join(storageDir, `${cluster.id}.db`);
+
+          // Only load if database file exists
+          const fs = require('fs');
+          if (!fs.existsSync(dbPath)) {
+            return; // Skip non-existent ledgers
+          }
+
+          const ledger = new Ledger(dbPath);
+          this.ledgers.set(cluster.id, ledger);
+        }
+
+        // Start streaming messages
+        this._streamLedgerMessages(cluster.id);
+
+        // Emit update about new cluster
+        this.onUpdate({
+          type: 'new_cluster',
+          cluster,
+        });
+      } catch (error) {
+        console.error(
+          `[DataPoller] Failed to load ledger for cluster ${cluster.id}:`,
+          error.message
+        );
+      }
+    }, 2000);
+
+    // Also load ledgers for all existing clusters
+    const existingClusters = this.orchestrator.listClusters();
+    for (const cluster of existingClusters) {
+      try {
+        const storageDir = this.orchestrator.storageDir || path.join(os.homedir(), '.zeroshot');
+        const dbPath = path.join(storageDir, `${cluster.id}.db`);
+        const ledger = new Ledger(dbPath);
+        this.ledgers.set(cluster.id, ledger);
+        this._streamLedgerMessages(cluster.id);
+      } catch (error) {
+        console.error(
+          `[DataPoller] Failed to load ledger for existing cluster ${cluster.id}:`,
+          error.message
+        );
+      }
+    }
+  }
+
+  /**
+   * 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) {
+      try {
+        const status = this.orchestrator.getStatus(cluster.id);
+
+        for (const agent of status.agents || []) {
+          if (agent.pid) {
+            try {
+              const pidStat = await pidusage(agent.pid);
+              stats[agent.pid] = {
+                cpu: pidStat.cpu || 0,
+                memory: pidStat.memory || 0,
+              };
+            } catch {
+              // Process died - set to zero
+              stats[agent.pid] = { cpu: 0, memory: 0 };
+            }
+          }
+        }
+      } catch {
+        // Skip clusters that error
+        continue;
+      }
+    }
+
+    return stats;
+  }
+}
+
+module.exports = DataPoller;

package/src/tui/demo.js

@@ -0,0 +1,208 @@
+/**
+ * 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

@@ -0,0 +1,123 @@
+/**
+ * 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%';
+  if (percent > 100) percent = 100;
+
+  return `${percent.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,
+};