@bolloon/bolloon-agent 0.1.1 → 0.1.3

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;
+}

package/src/heartbeat/Watchdog.ts

@@ -0,0 +1,198 @@
+/**
+ * Watchdog - 看门狗机制
+ * 检测进程卡死、无响应等情况
+ */
+
+import type { WatchdogConfig, WatchdogState, RestartStrategy, RestartLevel } from './types.js';
+
+export interface WatchdogCallbacks {
+  onRestart?: (level: RestartLevel, reason: string) => void;
+  onLog?: (message: string) => void;
+  onHealthCheckFailed?: (failures: number) => void;
+}
+
+export class Watchdog {
+  private config: Required<WatchdogConfig>;
+  private state: WatchdogState;
+  private checkIntervalId: ReturnType<typeof setInterval> | null = null;
+  private restartStrategies: Map<RestartLevel, () => void | Promise<void>> = new Map();
+  private restartCount: number = 0;
+  private callbacks: WatchdogCallbacks;
+
+  constructor(config: Partial<WatchdogConfig> = {}, callbacks: WatchdogCallbacks = {}) {
+    this.config = {
+      silentThresholdMs: config.silentThresholdMs || 300000, // 5 分钟无日志
+      maxConsecutiveFailures: config.maxConsecutiveFailures || 3,
+      checkIntervalMs: config.checkIntervalMs || 30000 // 30 秒检查一次
+    };
+    this.state = {
+      lastActivityTime: Date.now(),
+      consecutiveFailures: 0,
+      isTriggered: false
+    };
+    this.callbacks = callbacks;
+  }
+
+  /**
+   * 注册重启策略
+   */
+  registerRestartStrategy(level: RestartLevel, action: () => void | Promise<void>): void {
+    this.restartStrategies.set(level, action);
+  }
+
+  /**
+   * 记录活动（调用后更新 lastActivityTime）
+   */
+  recordActivity(component?: string): void {
+    this.state.lastActivityTime = Date.now();
+    if (component) {
+      this.callbacks.onLog?.(`[Watchdog] Activity from ${component}`);
+    }
+  }
+
+  /**
+   * 记录日志（同时触发活动检测）
+   */
+  log(message: string): void {
+    this.recordActivity();
+    console.log(`[Watchdog] ${message}`);
+    this.callbacks.onLog?.(message);
+  }
+
+  /**
+   * 开始看门狗监控
+   */
+  start(): void {
+    if (this.checkIntervalId) return;
+
+    console.log(`[Watchdog] Started - silent threshold: ${this.config.silentThresholdMs}ms, check interval: ${this.config.checkIntervalMs}ms`);
+
+    this.checkIntervalId = setInterval(() => {
+      this.check();
+    }, this.config.checkIntervalMs);
+  }
+
+  /**
+   * 停止看门狗
+   */
+  stop(): void {
+    if (this.checkIntervalId) {
+      clearInterval(this.checkIntervalId);
+      this.checkIntervalId = null;
+    }
+    console.log('[Watchdog] Stopped');
+  }
+
+  /**
+   * 报告健康检查结果
+   */
+  reportHealthCheck(success: boolean, details?: string): void {
+    if (success) {
+      this.state.consecutiveFailures = 0;
+      this.recordActivity('health_check');
+    } else {
+      this.state.consecutiveFailures++;
+      console.log(`[Watchdog] Health check failed (${this.state.consecutiveFailures}/${this.config.maxConsecutiveFailures}): ${details || 'unknown'}`);
+      this.callbacks.onHealthCheckFailed?.(this.state.consecutiveFailures);
+
+      if (this.state.consecutiveFailures >= this.config.maxConsecutiveFailures) {
+        this.triggerRestart(1, `Health check failed ${this.state.consecutiveFailures} times`);
+      }
+    }
+  }
+
+  /**
+   * 获取当前状态
+   */
+  getState(): WatchdogState & { uptime_ms: number; restartCount: number } {
+    return {
+      ...this.state,
+      uptime_ms: Date.now() - this.state.lastActivityTime,
+      restartCount: this.restartCount
+    };
+  }
+
+  /**
+   * 执行检查
+   */
+  private check(): void {
+    const now = Date.now();
+    const silentTime = now - this.state.lastActivityTime;
+
+    // 检查是否沉默太久
+    if (silentTime > this.config.silentThresholdMs) {
+      console.warn(`[Watchdog] No activity for ${Math.round(silentTime / 1000)}s`);
+      this.triggerRestart(1, `No activity for ${Math.round(silentTime / 1000)}s`);
+      return;
+    }
+
+    // 检查内存使用
+    const usage = process.memoryUsage();
+    const heapUsedPercent = (usage.heapUsed / usage.heapTotal) * 100;
+    if (heapUsedPercent > 90) {
+      console.warn(`[Watchdog] Memory usage critical: ${heapUsedPercent.toFixed(1)}%`);
+      this.triggerRestart(1, `Memory usage ${heapUsedPercent.toFixed(1)}%`);
+    }
+  }
+
+  /**
+   * 触发重启
+   */
+  private triggerRestart(level: RestartLevel, reason: string): void {
+    if (this.state.isTriggered) {
+      console.log(`[Watchdog] Already triggered, ignoring restart request: ${reason}`);
+      return;
+    }
+
+    this.state.isTriggered = true;
+    this.state.triggerReason = reason;
+    this.restartCount++;
+
+    console.error(`[Watchdog] 🔴 TRIGGERED: ${reason} (restart #${this.restartCount})`);
+
+    const strategy = this.restartStrategies.get(level);
+    if (strategy) {
+      try {
+        this.callbacks.onRestart?.(level, reason);
+        const result = strategy();
+        if (result instanceof Promise) {
+          result.catch(err => {
+            console.error('[Watchdog] Restart action failed:', err);
+          });
+        }
+      } catch (err) {
+        console.error('[Watchdog] Failed to execute restart strategy:', err);
+      }
+    } else {
+      console.warn(`[Watchdog] No restart strategy registered for level ${level}`);
+      this.callbacks.onRestart?.(level, reason);
+    }
+  }
+
+  /**
+   * 重置触发状态（允许再次触发）
+   */
+  reset(): void {
+    this.state.isTriggered = false;
+    this.state.triggerReason = undefined;
+    this.state.lastActivityTime = Date.now();
+  }
+}
+
+// 全局实例
+let watchdogInstance: Watchdog | null = null;
+
+export function getWatchdog(): Watchdog {
+  if (!watchdogInstance) {
+    watchdogInstance = new Watchdog();
+  }
+  return watchdogInstance;
+}
+
+export function createWatchdog(
+  config?: Partial<WatchdogConfig>,
+  callbacks?: WatchdogCallbacks
+): Watchdog {
+  watchdogInstance = new Watchdog(config, callbacks);
+  return watchdogInstance;
+}

package/src/heartbeat/index.ts

@@ -0,0 +1,108 @@
+/**
+ * Bolloon 24h Heartbeat Module
+ * 24 小时稳定运行心跳闭环
+ */
+
+export * from './types.js';
+export * from './HealthMonitor.js';
+export * from './Watchdog.js';
+export * from './DaemonManager.js';
+export * from './StartupVerifier.js';
+
+import { createHealthMonitor, getHealthMonitor } from './HealthMonitor.js';
+import { createWatchdog, getWatchdog } from './Watchdog.js';
+import { createDaemonManager, getDaemonManager } from './DaemonManager.js';
+import { StartupVerifier, runStartupVerification, getStartupVerifier } from './StartupVerifier.js';
+import type { HealthStatus } from './types.js';
+
+/**
+ * 初始化完整的 24h 心跳系统
+ */
+export async function initialize24hHeartbeat(): Promise<{
+  healthMonitor: ReturnType<typeof createHealthMonitor>;
+  watchdog: ReturnType<typeof createWatchdog>;
+  daemonManager: ReturnType<typeof createDaemonManager>;
+  startupVerifier: StartupVerifier;
+}> {
+  // 1. 启动自检
+  const startupReport = await runStartupVerification();
+  if (!startupReport.success) {
+    console.warn('[24h] Startup verification failed, continuing anyway...');
+  }
+
+  // 2. 初始化健康监控
+  const healthMonitor = createHealthMonitor({
+    onStatusChange: (status: HealthStatus) => {
+      if (status.status !== 'healthy') {
+        console.warn(`[24h] Health status: ${status.status}`);
+        for (const rec of status.recommendations || []) {
+          console.warn(`[24h]   → ${rec}`);
+        }
+      }
+    }
+  });
+
+  // 3. 初始化看门狗
+  const watchdog = createWatchdog(
+    { silentThresholdMs: 300000, maxConsecutiveFailures: 3, checkIntervalMs: 30000 },
+    {
+      onLog: (msg) => console.log(`[24h-Watchdog] ${msg}`),
+      onHealthCheckFailed: (failures) => console.warn(`[24h] Health check failures: ${failures}`),
+      onRestart: (level, reason) => {
+        console.error(`[24h] Restart triggered (level ${level}): ${reason}`);
+      }
+    }
+  );
+
+  // 4. 连接健康监控和看门狗
+  healthMonitor.startPeriodicCheck(60000, (status) => {
+    const hasError = Object.values(status.checks).some(c => c.status === 'error');
+    watchdog.reportHealthCheck(!hasError, status.status);
+  });
+
+  // 5. 初始化守护进程管理器
+  const daemonManager = createDaemonManager({
+    maxRestarts: 5,
+    restartDelayMs: 5000
+  });
+
+  // 6. 注册看门狗重启策略
+  watchdog.registerRestartStrategy(1 as const, () => {
+    console.log('[24h] Level 1 restart: Graceful restart...');
+    // 可以添加进程重启逻辑
+  });
+
+  watchdog.registerRestartStrategy(2 as const, () => {
+    console.log('[24h] Level 2 restart: Process restart...');
+    // 可以添加进程重启逻辑
+  });
+
+  watchdog.registerRestartStrategy(3 as const, () => {
+    console.log('[24h] Level 3 restart: System notification...');
+    // 可以发送通知
+  });
+
+  // 7. 启动看门狗
+  watchdog.start();
+
+  console.log('[24h] 24h heartbeat system initialized');
+  console.log(`[24h] Health checks: every 60s`);
+  console.log(`[24h] Watchdog checks: every 30s`);
+  console.log(`[24h] Max restarts: 5`);
+
+  return { healthMonitor, watchdog, daemonManager, startupVerifier: getStartupVerifier() };
+}
+
+/**
+ * 获取健康状态 JSON
+ */
+export async function getHealthStatus(): Promise<HealthStatus> {
+  const healthMonitor = getHealthMonitor();
+  return healthMonitor.check();
+}
+
+// Re-export singleton getters for convenience
+export { getHealthMonitor, createHealthMonitor };
+export { getWatchdog, createWatchdog };
+export { getDaemonManager, createDaemonManager };
+export { getStartupVerifier };

package/src/heartbeat/types.ts

@@ -0,0 +1,82 @@
+/**
+ * Bolloon 24h Heartbeat Types
+ * 健康检查、看门狗、守护进程的类型定义
+ */
+
+export interface HealthCheckResult {
+  status: 'ok' | 'error';
+  message?: string;
+  details?: Record<string, unknown>;
+  latency_ms?: number;
+}
+
+export interface HealthStatus {
+  status: 'healthy' | 'degraded' | 'unhealthy';
+  timestamp: string;
+  uptime_seconds: number;
+  checks: {
+    p2p: HealthCheckResult;
+    iroh: HealthCheckResult;
+    llm: HealthCheckResult;
+    memory: HealthCheckResult;
+    heartbeat: HealthCheckResult;
+  };
+  recommendations?: string[];
+}
+
+export interface WatchdogConfig {
+  /** 无日志时间阈值 (ms) */
+  silentThresholdMs: number;
+  /** 健康检查失败阈值 */
+  maxConsecutiveFailures: number;
+  /** 检查间隔 (ms) */
+  checkIntervalMs: number;
+}
+
+export interface WatchdogState {
+  lastActivityTime: number;
+  consecutiveFailures: number;
+  isTriggered: boolean;
+  triggerReason?: string;
+}
+
+export interface DaemonConfig {
+  /** 最大重启次数 */
+  maxRestarts: number;
+  /** 重启延迟 (ms) */
+  restartDelayMs: number;
+  /** 日志文件路径 */
+  logFile?: string;
+  /** PID 文件路径 */
+  pidFile?: string;
+}
+
+export interface StartupCheck {
+  name: string;
+  status: 'pending' | 'running' | 'passed' | 'failed';
+  message?: string;
+  duration_ms?: number;
+  startTime?: number;
+}
+
+export interface StartupReport {
+  success: boolean;
+  checks: StartupCheck[];
+  total_duration_ms: number;
+  critical_failures: string[];
+}
+
+export type RestartLevel = 1 | 2 | 3;
+
+export interface RestartStrategy {
+  level: RestartLevel;
+  action: () => void | Promise<void>;
+  reason: string;
+}
+
+export interface HealthCheckProvider {
+  checkP2P(): Promise<HealthCheckResult>;
+  checkIroh(): Promise<HealthCheckResult>;
+  checkLLM(): Promise<HealthCheckResult>;
+  checkMemory(): Promise<HealthCheckResult>;
+}

package/src/llm/config-store.ts

@@ -157,7 +157,23 @@ class LLMConfigStore {
     try {
       await fs.mkdir(CONFIG_DIR, { recursive: true });
       const data = await fs.readFile(CONFIG_PATH, 'utf-8');
-      this.config = JSON.parse(data);
+      const loadedConfig = JSON.parse(data);
+
+      // 确保加载的配置包含所有默认供应商，缺失的用默认值补充
+      const defaultProviders = Object.keys(DEFAULT_PROVIDER_CONFIGS) as ModelProvider[];
+      for (const provider of defaultProviders) {
+        if (!loadedConfig.providers[provider]) {
+          loadedConfig.providers[provider] = { ...DEFAULT_PROVIDER_CONFIGS[provider] };
+        }
+      }
+
+      // 确保有 activeProvider
+      const activeProvider = loadedConfig.activeProvider as ModelProvider;
+      if (!activeProvider || !DEFAULT_PROVIDER_CONFIGS[activeProvider]) {
+        loadedConfig.activeProvider = 'ollama';
+      }
+
+      this.config = loadedConfig;
     } catch {
       this.config = getDefaultConfig();
       await this.save();
@@ -302,11 +318,13 @@ export function getPiSDKConfig(): {
     return { provider: 'ollama' };
   }
 
-  const activeConfig = config.providers[config.activeProvider];
+  const activeProvider = config.activeProvider as ModelProvider;
+  const activeConfig = config.providers[activeProvider] || {};
+  const defaultConfig = DEFAULT_PROVIDER_CONFIGS[activeProvider] || { baseUrl: '', model: '' };
   return {
-    provider: config.activeProvider,
+    provider: activeProvider,
     apiKey: activeConfig.apiKey || undefined,
-    baseUrl: activeConfig.baseUrl !== DEFAULT_PROVIDER_CONFIGS[config.activeProvider].baseUrl ? activeConfig.baseUrl : undefined,
-    model: activeConfig.model !== DEFAULT_PROVIDER_CONFIGS[config.activeProvider].model ? activeConfig.model : undefined
+    baseUrl: activeConfig.baseUrl !== defaultConfig.baseUrl ? activeConfig.baseUrl : undefined,
+    model: activeConfig.model !== defaultConfig.model ? activeConfig.model : undefined
   };
 }

package/src/network/iroh-transport.ts

@@ -82,11 +82,11 @@ export class IrohTransport {
   private requestIdToNodeId: Map<string, string> = new Map();
 
   async start(secretKey?: string, enablePersistence = false): Promise<{ nodeId: string; addr: string }> {
-    if (this.endpoint) {
+    if (this.endpoint && this.ownNodeId) {
       // 已启动，返回当前信息
       return {
         nodeId: this.ownNodeId,
-        addr: this.endpoint.listenAddresses()[0]?.toString() || ''
+        addr: this.ownNodeId // iroh 没有 listenAddresses，用 nodeId 作为 addr
       };
     }
 
@@ -114,7 +114,7 @@ export class IrohTransport {
 
     return {
       nodeId: this.endpoint.nodeId(),
-      addr: this.endpoint.addr() || this.endpoint.nodeId(),
+      addr: this.ownNodeId // iroh 没有 addr()，用 nodeId
     };
   }