@bolloon/bolloon-agent 0.1.0 → 0.1.2

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