@bolloon/bolloon-agent 0.1.0 → 0.1.2

package/src/heartbeat/HealthMonitor.ts

@@ -0,0 +1,316 @@
+/**
+ * HealthMonitor - 健康检查核心
+ * 监控 P2P、Iroh、LLM、内存等关键指标
+ */
+
+import type { HealthStatus, HealthCheckResult, HealthCheckProvider } from './types.js';
+import { getMinimax } from '../constraints/index.js';
+
+export class HealthMonitor implements HealthCheckProvider {
+  private lastHeartbeatTime: number = Date.now();
+  private checkIntervalId: ReturnType<typeof setInterval> | null = null;
+  private onStatusChange?: (status: HealthStatus) => void;
+
+  constructor(private config: {
+    checkIntervalMs?: number;
+    onStatusChange?: (status: HealthStatus) => void;
+  } = {}) {
+    this.onStatusChange = config.onStatusChange;
+  }
+
+  /**
+   * 执行完整健康检查
+   */
+  async check(): Promise<HealthStatus> {
+    const checks: HealthStatus['checks'] = {
+      p2p: await this.checkP2P(),
+      iroh: await this.checkIroh(),
+      llm: await this.checkLLM(),
+      memory: await this.checkMemory(),
+      heartbeat: await this.checkHeartbeat()
+    };
+
+    // 计算整体状态
+    const errors = Object.values(checks).filter(c => c.status === 'error').length;
+    let status: HealthStatus['status'] = 'healthy';
+    if (errors >= 3) {
+      status = 'unhealthy';
+    } else if (errors >= 1) {
+      status = 'degraded';
+    }
+
+    const healthStatus: HealthStatus = {
+      status,
+      timestamp: new Date().toISOString(),
+      uptime_seconds: process.uptime(),
+      checks,
+      recommendations: this.generateRecommendations(checks)
+    };
+
+    this.onStatusChange?.(healthStatus);
+    return healthStatus;
+  }
+
+  /**
+   * 检查 P2P 连接状态
+   */
+  async checkP2P(): Promise<HealthCheckResult> {
+    const start = Date.now();
+    try {
+      // 从全局状态获取 HyperswarmCommunicator
+      const comm = (global as any).hyperswarmComm;
+      if (!comm) {
+        return { status: 'ok', message: 'P2P not initialized yet', latency_ms: Date.now() - start };
+      }
+
+      const connections = comm.getConnections?.() || [];
+      return {
+        status: 'ok',
+        message: `Connected to ${connections.length} peers`,
+        details: { peer_count: connections.length },
+        latency_ms: Date.now() - start
+      };
+    } catch (err: any) {
+      return { status: 'error', message: err.message, latency_ms: Date.now() - start };
+    }
+  }
+
+  /**
+   * 检查 Iroh 节点状态
+   */
+  async checkIroh(): Promise<HealthCheckResult> {
+    const start = Date.now();
+    try {
+      const { irohTransport } = await import('../network/iroh-transport.js');
+
+      if (!irohTransport.isRunning?.()) {
+        return { status: 'error', message: 'Iroh not running', latency_ms: Date.now() - start };
+      }
+
+      const nodeId = irohTransport.getNodeId?.() || '';
+      const peers = irohTransport.getPeers?.() || [];
+      const pendingOffline = irohTransport.getPendingOfflineCount?.() || 0;
+
+      return {
+        status: 'ok',
+        message: `Iroh running, ${peers.length} peers`,
+        details: {
+          nodeId: nodeId.substring(0, 16) + '...',
+          peer_count: peers.length,
+          pending_offline_messages: pendingOffline
+        },
+        latency_ms: Date.now() - start
+      };
+    } catch (err: any) {
+      return { status: 'error', message: err.message, latency_ms: Date.now() - start };
+    }
+  }
+
+  /**
+   * 检查 LLM 连接状态
+   */
+  async checkLLM(): Promise<HealthCheckResult> {
+    const start = Date.now();
+    try {
+      const minimax = getMinimax();
+
+      if (!minimax) {
+        return { status: 'error', message: 'LLM not initialized', latency_ms: Date.now() - start };
+      }
+
+      // 执行 ping 测试
+      const latency = await this.pingLLM(minimax);
+      return {
+        status: 'ok',
+        message: 'LLM responsive',
+        details: { latency_ms: latency },
+        latency_ms: Date.now() - start
+      };
+    } catch (err: any) {
+      return { status: 'error', message: err.message, latency_ms: Date.now() - start };
+    }
+  }
+
+  /**
+   * 检查内存使用
+   */
+  async checkMemory(): Promise<HealthCheckResult> {
+    const start = Date.now();
+    try {
+      const usage = process.memoryUsage();
+      const heapUsedPercent = (usage.heapUsed / usage.heapTotal) * 100;
+      const rssPercent = (usage.rss / (1024 * 1024 * 1024)) * 100; // GB
+
+      // 获取系统总内存 (macOS/Linux)
+      let systemMemoryPercent = 0;
+      try {
+        if (process.platform === 'darwin' || process.platform === 'linux') {
+          const { execSync } = require('child_process');
+          if (process.platform === 'darwin') {
+            const total = execSync('sysctl -n hw.memsize').toString().trim();
+            const free = execSync('vm_stat | grep "Pages free" | awk \'{print $3}\' | tr -d "."');
+            const pageSize = execSync('sysctl -n vm.pagesize').toString().trim();
+            systemMemoryPercent = ((parseInt(free) * parseInt(pageSize)) / parseInt(total)) * 100;
+          }
+        }
+      } catch {
+        // 忽略系统内存获取失败
+      }
+
+      const isHealthy = heapUsedPercent < 80;
+
+      return {
+        status: isHealthy ? 'ok' : 'error',
+        message: isHealthy ? 'Memory usage normal' : 'Memory usage high',
+        details: {
+          heap_used_mb: Math.round(usage.heapUsed / 1024 / 1024),
+          heap_total_mb: Math.round(usage.heapTotal / 1024 / 1024),
+          heap_used_percent: Math.round(heapUsedPercent * 10) / 10,
+          rss_mb: Math.round(usage.rss / 1024 / 1024)
+        },
+        latency_ms: Date.now() - start
+      };
+    } catch (err: any) {
+      return { status: 'error', message: err.message, latency_ms: Date.now() - start };
+    }
+  }
+
+  /**
+   * 检查心跳活跃度
+   */
+  async checkHeartbeat(): Promise<HealthCheckResult> {
+    const start = Date.now();
+    const elapsed = Date.now() - this.lastHeartbeatTime;
+
+    // 获取 SocialHeartbeat 状态
+    const heartbeat = (global as any).socialHeartbeat;
+    let agentsCount = 0;
+    let antColonyEnabled = false;
+
+    if (heartbeat) {
+      const agents = heartbeat.getDiscoveredAgents?.();
+      agentsCount = agents?.length || 0;
+      antColonyEnabled = heartbeat.isAntColonyEnabled?.() || false;
+    }
+
+    return {
+      status: elapsed < 60000 ? 'ok' : 'error',
+      message: elapsed < 60000
+        ? `Heartbeat active ${Math.round(elapsed / 1000)}s ago`
+        : 'Heartbeat inactive for > 60s',
+      details: {
+        last_heartbeat_ms: elapsed,
+        discovered_agents: agentsCount,
+        ant_colony_enabled: antColonyEnabled
+      },
+      latency_ms: Date.now() - start
+    };
+  }
+
+  /**
+   * 记录心跳活跃
+   */
+  recordHeartbeat(): void {
+    this.lastHeartbeatTime = Date.now();
+  }
+
+  /**
+   * 获取当前状态（不执行检查）
+   */
+  getQuickStatus(): { status: string; lastHeartbeat: number; memoryUsage: number } {
+    const usage = process.memoryUsage();
+    return {
+      status: 'active',
+      lastHeartbeat: this.lastHeartbeatTime,
+      memoryUsage: Math.round((usage.heapUsed / usage.heapTotal) * 100)
+    };
+  }
+
+  /**
+   * 生成健康建议
+   */
+  private generateRecommendations(checks: HealthStatus['checks']): string[] {
+    const recommendations: string[] = [];
+
+    if (checks.p2p.status === 'error') {
+      recommendations.push('P2P 连接失败，建议检查网络');
+    }
+    if (checks.iroh.status === 'error') {
+      recommendations.push('Iroh 节点未运行，消息可能无法发送');
+    }
+    if (checks.llm.status === 'error') {
+      recommendations.push('LLM 连接失败，检查 API 密钥配置');
+    }
+    if (checks.memory.status === 'error') {
+      recommendations.push('内存使用率过高，考虑重启服务');
+    }
+    if (checks.heartbeat.status === 'error') {
+      recommendations.push('心跳长时间未活跃，检查系统是否卡死');
+    }
+
+    return recommendations;
+  }
+
+  /**
+   * Ping LLM 测试响应
+   */
+  private async pingLLM(minimax: any): Promise<number> {
+    const start = Date.now();
+    try {
+      // 简单的 chat 测试
+      if (minimax.chat) {
+        await minimax.chat('ping', 'test', { maxTokens: 1 });
+      } else if (minimax.ping) {
+        await minimax.ping();
+      }
+      return Date.now() - start;
+    } catch {
+      // 如果 ping 失败，返回一个较大的值但不是错误
+      return Date.now() - start;
+    }
+  }
+
+  /**
+   * 开始定期健康检查
+   */
+  startPeriodicCheck(intervalMs: number = 60000, callback?: (status: HealthStatus) => void): void {
+    if (this.checkIntervalId) {
+      clearInterval(this.checkIntervalId);
+    }
+
+    const checkFn = async () => {
+      const status = await this.check();
+      callback?.(status);
+      this.onStatusChange?.(status);
+    };
+
+    this.checkIntervalId = setInterval(checkFn, intervalMs);
+    // 立即执行一次
+    checkFn();
+  }
+
+  /**
+   * 停止定期检查
+   */
+  stopPeriodicCheck(): void {
+    if (this.checkIntervalId) {
+      clearInterval(this.checkIntervalId);
+      this.checkIntervalId = null;
+    }
+  }
+}
+
+// 全局实例
+let healthMonitorInstance: HealthMonitor | null = null;
+
+export function getHealthMonitor(): HealthMonitor {
+  if (!healthMonitorInstance) {
+    healthMonitorInstance = new HealthMonitor();
+  }
+  return healthMonitorInstance;
+}
+
+export function createHealthMonitor(config?: { onStatusChange?: (status: HealthStatus) => void }): HealthMonitor {
+  healthMonitorInstance = new HealthMonitor(config);
+  return healthMonitorInstance;
+}

package/src/heartbeat/StartupVerifier.ts

@@ -0,0 +1,223 @@
+/**
+ * StartupVerifier - 启动自检验证器
+ * 在服务启动时验证所有关键组件
+ */
+
+import type { StartupReport, StartupCheck } from './types.js';
+
+export class StartupVerifier {
+  private checks: Map<string, StartupCheck> = new Map();
+
+  /**
+   * 添加检查项
+   */
+  addCheck(name: string): void {
+    this.checks.set(name, { name, status: 'pending' });
+  }
+
+  /**
+   * 标记检查开始
+   */
+  startCheck(name: string): void {
+    const check = this.checks.get(name);
+    if (check) {
+      check.status = 'running';
+      check.startTime = Date.now();
+    }
+  }
+
+  /**
+   * 标记检查完成
+   */
+  completeCheck(name: string, passed: boolean, message?: string): void {
+    const check = this.checks.get(name);
+    if (check) {
+      check.status = passed ? 'passed' : 'failed';
+      check.message = message;
+      check.duration_ms = Date.now() - (check.startTime || Date.now());
+    }
+  }
+
+  /**
+   * 运行所有自检
+   */
+  async verify(): Promise<StartupReport> {
+    const startTime = Date.now();
+    const critical_failures: string[] = [];
+
+    // 1. 检查 Node.js 版本
+    this.addCheck('node_version');
+    this.startCheck('node_version');
+    const nodeVersion = process.version;
+    const majorVersion = parseInt(nodeVersion.replace('v', '').split('.')[0], 10);
+    if (majorVersion >= 18) {
+      this.completeCheck('node_version', true, `Node.js ${nodeVersion}`);
+    } else {
+      this.completeCheck('node_version', false, `Node.js ${nodeVersion} too old, need >= 18`);
+      critical_failures.push('Node.js version too old');
+    }
+
+    // 2. 检查必要目录
+    this.addCheck('required_directories');
+    this.startCheck('required_directories');
+    try {
+      const fs = await import('fs/promises');
+      const paths = [
+        process.env.HOME ? `${process.env.HOME}/.bolloon` : '/tmp/.bolloon',
+        '/tmp'
+      ];
+      for (const p of paths) {
+        await fs.access(p);
+      }
+      this.completeCheck('required_directories', true, 'All required directories accessible');
+    } catch (err: any) {
+      this.completeCheck('required_directories', false, err.message);
+      critical_failures.push('Cannot access required directories');
+    }
+
+    // 3. 检查 LLM 配置
+    this.addCheck('llm_config');
+    this.startCheck('llm_config');
+    const hasLlmKey = !!(
+      process.env.OPENAI_API_KEY ||
+      process.env.ANTHROPIC_API_KEY ||
+      process.env.MINIMAX_API_KEY ||
+      process.env.OPENROUTER_API_KEY ||
+      process.env.GEMINI_API_KEY ||
+      process.env.OLLAMA_BASE_URL
+    );
+    if (hasLlmKey) {
+      this.completeCheck('llm_config', true, 'LLM API key found');
+    } else {
+      this.completeCheck('llm_config', false, 'No LLM API key configured (optional)');
+      // LLM 配置不是致命的，只是警告
+    }
+
+    // 4. 检查 P2P 依赖
+    this.addCheck('p2p_modules');
+    this.startCheck('p2p_modules');
+    try {
+      await import('@diap/sdk');
+      this.completeCheck('p2p_modules', true, '@diap/sdk available');
+    } catch (err: any) {
+      this.completeCheck('p2p_modules', false, `@diap/sdk not available: ${err.message}`);
+      critical_failures.push('@diap/sdk module not found');
+    }
+
+    // 5. 检查 IPFS 连接
+    this.addCheck('ipfs_connection');
+    this.startCheck('ipfs_connection');
+    try {
+      const ipfsRes = await fetch('http://127.0.0.1:5001/api/v0/id', {
+        method: 'POST',
+        signal: AbortSignal.timeout(3000)
+      });
+      if (ipfsRes.ok) {
+        this.completeCheck('ipfs_connection', true, 'IPFS local node accessible');
+      } else {
+        this.completeCheck('ipfs_connection', false, 'IPFS returned error');
+      }
+    } catch (err: any) {
+      this.completeCheck('ipfs_connection', false, 'IPFS not accessible (optional)');
+    }
+
+    // 6. 检查内存
+    this.addCheck('memory');
+    this.startCheck('memory');
+    const usage = process.memoryUsage();
+    const heapPercent = (usage.heapUsed / usage.heapTotal) * 100;
+    if (heapPercent < 90) {
+      this.completeCheck('memory', true, `Heap usage ${heapPercent.toFixed(1)}%`);
+    } else {
+      this.completeCheck('memory', false, `Heap usage critical: ${heapPercent.toFixed(1)}%`);
+      critical_failures.push('Memory usage too high at startup');
+    }
+
+    // 7. 检查网络
+    this.addCheck('network');
+    this.startCheck('network');
+    try {
+      const res = await fetch('https://www.google.com/generate_204', {
+        signal: AbortSignal.timeout(5000)
+      });
+      this.completeCheck('network', true, 'Internet connection available');
+    } catch {
+      this.completeCheck('network', false, 'No internet connection (optional)');
+    }
+
+    const totalDuration = Date.now() - startTime;
+
+    return {
+      success: critical_failures.length === 0,
+      checks: Array.from(this.checks.values()),
+      total_duration_ms: totalDuration,
+      critical_failures
+    };
+  }
+
+  /**
+   * 打印检查报告
+   */
+  printReport(report: StartupReport): void {
+    console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('🚀 Bolloon 启动自检报告');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+    for (const check of report.checks) {
+      const icon = check.status === 'passed' ? '✅' :
+                   check.status === 'failed' ? '❌' :
+                   check.status === 'running' ? '⏳' : '⭕';
+      const duration = check.duration_ms ? ` (${check.duration_ms}ms)` : '';
+      console.log(`  ${icon} ${check.name}${duration}`);
+      if (check.message) {
+        console.log(`     ${check.message}`);
+      }
+    }
+
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log(`总计耗时: ${report.total_duration_ms}ms`);
+
+    if (report.success) {
+      console.log('✅ 所有关键检查通过！');
+    } else {
+      console.log('❌ 关键检查失败:');
+      for (const failure of report.critical_failures) {
+        console.log(`   · ${failure}`);
+      }
+    }
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+  }
+
+  /**
+   * 快速验证（不打印）
+   */
+  async quickCheck(): Promise<boolean> {
+    const report = await this.verify();
+    return report.success;
+  }
+
+  /**
+   * 获取检查状态
+   */
+  getChecks(): StartupCheck[] {
+    return Array.from(this.checks.values());
+  }
+}
+
+// 导出便捷函数
+let startupVerifierInstance: StartupVerifier | null = null;
+
+export async function runStartupVerification(): Promise<StartupReport> {
+  const verifier = new StartupVerifier();
+  startupVerifierInstance = verifier;
+  const report = await verifier.verify();
+  verifier.printReport(report);
+  return report;
+}
+
+export function getStartupVerifier(): StartupVerifier {
+  if (!startupVerifierInstance) {
+    startupVerifierInstance = new StartupVerifier();
+  }
+  return startupVerifierInstance;
+}