@bolloon/bolloon-agent 0.1.35 → 0.1.37

package/src/heartbeat/DaemonManager.ts

@@ -1,283 +0,0 @@
-/**
- * DaemonManager - 守护进程管理器
- * 支持自动重启、日志轮转、PID 管理
- */
-
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import type { DaemonConfig } from './types.js';
-
-export interface DaemonState {
-  pid: number;
-  startedAt: number;
-  restartCount: number;
-  lastRestartAt?: number;
-  lastError?: string;
-}
-
-export class DaemonManager {
-  private config: Required<DaemonConfig>;
-  private state: DaemonState | null = null;
-  private stopRequested: boolean = false;
-  private isChildProcess: boolean = false;
-
-  constructor(config: Partial<DaemonConfig> = {}) {
-    this.config = {
-      maxRestarts: config.maxRestarts || 5,
-      restartDelayMs: config.restartDelayMs || 5000,
-      logFile: config.logFile || path.join(process.env.HOME || '/tmp', '.bolloon', 'daemon.log'),
-      pidFile: config.pidFile || path.join(process.env.HOME || '/tmp', '.bolloon', 'daemon.pid')
-    };
-    this.isChildProcess = process.env.BOLLOON_DAEMON_CHILD === '1';
-  }
-
-  /**
-   * 获取当前守护进程状态
-   */
-  async getState(): Promise<DaemonState | null> {
-    try {
-      const pidData = await fs.readFile(this.config.pidFile, 'utf-8');
-      const pid = parseInt(pidData.trim(), 10);
-
-      if (isNaN(pid)) return null;
-
-      // 检查进程是否仍在运行
-      try {
-        process.kill(pid, 0); // Signal 0 只是检查进程是否存在
-        return { ...this.state!, pid };
-      } catch {
-        // 进程不存在
-        return null;
-      }
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * 检查是否已有守护进程在运行
-   */
-  async isRunning(): Promise<boolean> {
-    const state = await this.getState();
-    return state !== null;
-  }
-
-  /**
-   * 保存 PID 文件
-   */
-  private async savePid(): Promise<void> {
-    await fs.mkdir(path.dirname(this.config.pidFile), { recursive: true });
-    await fs.writeFile(this.config.pidFile, String(process.pid));
-    console.log(`[Daemon] PID saved: ${process.pid}`);
-  }
-
-  /**
-   * 删除 PID 文件
-   */
-  async clearPid(): Promise<void> {
-    try {
-      await fs.unlink(this.config.pidFile);
-    } catch {
-      // 忽略删除失败
-    }
-  }
-
-  /**
-   * 写入日志
-   */
-  private async writeLog(message: string): Promise<void> {
-    if (!this.config.logFile) return;
-
-    try {
-      await fs.mkdir(path.dirname(this.config.logFile), { recursive: true });
-      const timestamp = new Date().toISOString();
-      await fs.appendFile(this.config.logFile, `[${timestamp}] ${message}\n`);
-    } catch {
-      // 忽略日志写入失败
-    }
-  }
-
-  /**
-   * 启动主进程（父进程调用）
-   */
-  async spawn(processArgv: string[] = process.argv): Promise<void> {
-    // 检查是否已在运行
-    if (await this.isRunning()) {
-      console.log('[Daemon] Already running, pid:', (await this.getState())?.pid);
-      return;
-    }
-
-    this.state = {
-      pid: process.pid,
-      startedAt: Date.now(),
-      restartCount: 0
-    };
-
-    await this.savePid();
-    await this.writeLog('Daemon started');
-
-    // 设置优雅退出
-    this.setupGracefulShutdown();
-
-    // 注册信号处理
-    this.setupSignalHandlers();
-
-    console.log('[Daemon] Manager initialized');
-  }
-
-  /**
-   * 启动子进程并管理其生命周期
-   */
-  async runWithAutoRestart(childArgs: string[]): Promise<void> {
-    if (!this.isChildProcess) {
-      // 父进程：启动子进程
-      await this.runChildProcess(childArgs);
-      return;
-    }
-
-    // 子进程：正常运行主程序
-    console.log('[Daemon] Running as child process');
-  }
-
-  /**
-   * 启动子进程
-   */
-  private async runChildProcess(childArgs: string[]): Promise<void> {
-    const { spawn } = await import('child_process');
-    let consecutiveFailures = 0;
-
-    while (!this.stopRequested && consecutiveFailures < this.config.maxRestarts) {
-      console.log(`[Daemon] Spawning child process (attempt ${consecutiveFailures + 1}/${this.config.maxRestarts})`);
-
-      const child = spawn(process.execPath, childArgs, {
-        stdio: 'inherit',
-        env: { ...process.env, BOLLOON_DAEMON_CHILD: '1' }
-      });
-
-      child.on('exit', async (code, signal) => {
-        const reason = signal || `exit code ${code}`;
-        console.log(`[Daemon] Child exited: ${reason}`);
-
-        if (this.stopRequested) {
-          console.log('[Daemon] Stop requested, not restarting');
-          await this.clearPid();
-          process.exit(0);
-        }
-
-        consecutiveFailures++;
-        this.state = {
-          ...this.state!,
-          restartCount: consecutiveFailures,
-          lastRestartAt: Date.now(),
-          lastError: reason
-        };
-
-        if (consecutiveFailures < this.config.maxRestarts) {
-          console.log(`[Daemon] Restarting in ${this.config.restartDelayMs}ms...`);
-          await this.writeLog(`Child exited ${reason}, restarting (${consecutiveFailures}/${this.config.maxRestarts})`);
-
-          await new Promise(resolve => setTimeout(resolve, this.config.restartDelayMs));
-          // 继续 while 循环，重启子进程
-        } else {
-          console.error('[Daemon] Max restarts reached, giving up');
-          await this.writeLog(`Max restarts reached (${this.config.maxRestarts})`);
-          await this.clearPid();
-          process.exit(1);
-        }
-      });
-
-      child.on('error', async (err) => {
-        console.error('[Daemon] Child process error:', err.message);
-        await this.writeLog(`Child error: ${err.message}`);
-      });
-
-      // 等待子进程退出
-      await new Promise<void>((resolve) => {
-        child.on('exit', () => resolve());
-      });
-    }
-  }
-
-  /**
-   * 设置优雅退出
-   */
-  private setupGracefulShutdown(): void {
-    let isShuttingDown = false;
-
-    const shutdown = async () => {
-      if (isShuttingDown) return;
-      isShuttingDown = true;
-
-      console.log('[Daemon] Graceful shutdown...');
-      await this.writeLog('Graceful shutdown');
-      this.stopRequested = true;
-
-      await this.clearPid();
-      process.exit(0);
-    };
-
-    process.on('SIGTERM', shutdown);
-    process.on('SIGINT', shutdown);
-    process.on('uncaughtException', async (err) => {
-      console.error('[Daemon] Uncaught exception:', err);
-      await this.writeLog(`Uncaught exception: ${err.message}`);
-      await shutdown();
-    });
-  }
-
-  /**
-   * 设置信号处理
-   */
-  private setupSignalHandlers(): void {
-    process.on('SIGHUP', () => {
-      console.log('[Daemon] Received SIGHUP, reloading...');
-      // 可以实现配置重载逻辑
-    });
-  }
-
-  /**
-   * 请求停止守护进程
-   */
-  async stop(): Promise<void> {
-    const state = await this.getState();
-    if (state) {
-      console.log(`[Daemon] Sending SIGTERM to pid ${state.pid}`);
-      try {
-        process.kill(state.pid, 'SIGTERM');
-      } catch {
-        console.log('[Daemon] Process not found, clearing PID');
-      }
-    }
-    await this.clearPid();
-    this.stopRequested = true;
-  }
-
-  /**
-   * 获取重启次数
-   */
-  async getRestartCount(): Promise<number> {
-    return this.state?.restartCount || 0;
-  }
-
-  /**
-   * 检查是否可以继续重启
-   */
-  canRestart(): boolean {
-    return (this.state?.restartCount || 0) < this.config.maxRestarts;
-  }
-}
-
-// 全局实例
-let daemonManagerInstance: DaemonManager | null = null;
-
-export function getDaemonManager(): DaemonManager {
-  if (!daemonManagerInstance) {
-    daemonManagerInstance = new DaemonManager();
-  }
-  return daemonManagerInstance;
-}
-
-export function createDaemonManager(config?: Partial<DaemonConfig>): DaemonManager {
-  daemonManagerInstance = new DaemonManager(config);
-  return daemonManagerInstance;
-}

package/src/heartbeat/HealthMonitor.ts

@@ -1,316 +0,0 @@
-/**
- * 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;
-}