@bolloon/bolloon-agent 0.1.1 → 0.1.3

package/dist/heartbeat/StartupVerifier.js

@@ -0,0 +1,205 @@
+/**
+ * StartupVerifier - 启动自检验证器
+ * 在服务启动时验证所有关键组件
+ */
+export class StartupVerifier {
+    checks = new Map();
+    /**
+     * 添加检查项
+     */
+    addCheck(name) {
+        this.checks.set(name, { name, status: 'pending' });
+    }
+    /**
+     * 标记检查开始
+     */
+    startCheck(name) {
+        const check = this.checks.get(name);
+        if (check) {
+            check.status = 'running';
+            check.startTime = Date.now();
+        }
+    }
+    /**
+     * 标记检查完成
+     */
+    completeCheck(name, passed, message) {
+        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() {
+        const startTime = Date.now();
+        const critical_failures = [];
+        // 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) {
+            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) {
+            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) {
+            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) {
+        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() {
+        const report = await this.verify();
+        return report.success;
+    }
+    /**
+     * 获取检查状态
+     */
+    getChecks() {
+        return Array.from(this.checks.values());
+    }
+}
+// 导出便捷函数
+let startupVerifierInstance = null;
+export async function runStartupVerification() {
+    const verifier = new StartupVerifier();
+    startupVerifierInstance = verifier;
+    const report = await verifier.verify();
+    verifier.printReport(report);
+    return report;
+}
+export function getStartupVerifier() {
+    if (!startupVerifierInstance) {
+        startupVerifierInstance = new StartupVerifier();
+    }
+    return startupVerifierInstance;
+}

package/dist/heartbeat/Watchdog.js

@@ -0,0 +1,168 @@
+/**
+ * Watchdog - 看门狗机制
+ * 检测进程卡死、无响应等情况
+ */
+export class Watchdog {
+    config;
+    state;
+    checkIntervalId = null;
+    restartStrategies = new Map();
+    restartCount = 0;
+    callbacks;
+    constructor(config = {}, callbacks = {}) {
+        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, action) {
+        this.restartStrategies.set(level, action);
+    }
+    /**
+     * 记录活动（调用后更新 lastActivityTime）
+     */
+    recordActivity(component) {
+        this.state.lastActivityTime = Date.now();
+        if (component) {
+            this.callbacks.onLog?.(`[Watchdog] Activity from ${component}`);
+        }
+    }
+    /**
+     * 记录日志（同时触发活动检测）
+     */
+    log(message) {
+        this.recordActivity();
+        console.log(`[Watchdog] ${message}`);
+        this.callbacks.onLog?.(message);
+    }
+    /**
+     * 开始看门狗监控
+     */
+    start() {
+        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() {
+        if (this.checkIntervalId) {
+            clearInterval(this.checkIntervalId);
+            this.checkIntervalId = null;
+        }
+        console.log('[Watchdog] Stopped');
+    }
+    /**
+     * 报告健康检查结果
+     */
+    reportHealthCheck(success, details) {
+        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() {
+        return {
+            ...this.state,
+            uptime_ms: Date.now() - this.state.lastActivityTime,
+            restartCount: this.restartCount
+        };
+    }
+    /**
+     * 执行检查
+     */
+    check() {
+        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)}%`);
+        }
+    }
+    /**
+     * 触发重启
+     */
+    triggerRestart(level, reason) {
+        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() {
+        this.state.isTriggered = false;
+        this.state.triggerReason = undefined;
+        this.state.lastActivityTime = Date.now();
+    }
+}
+// 全局实例
+let watchdogInstance = null;
+export function getWatchdog() {
+    if (!watchdogInstance) {
+        watchdogInstance = new Watchdog();
+    }
+    return watchdogInstance;
+}
+export function createWatchdog(config, callbacks) {
+    watchdogInstance = new Watchdog(config, callbacks);
+    return watchdogInstance;
+}

package/dist/heartbeat/index.js

@@ -0,0 +1,84 @@
+/**
+ * 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 { runStartupVerification, getStartupVerifier } from './StartupVerifier.js';
+/**
+ * 初始化完整的 24h 心跳系统
+ */
+export async function initialize24hHeartbeat() {
+    // 1. 启动自检
+    const startupReport = await runStartupVerification();
+    if (!startupReport.success) {
+        console.warn('[24h] Startup verification failed, continuing anyway...');
+    }
+    // 2. 初始化健康监控
+    const healthMonitor = createHealthMonitor({
+        onStatusChange: (status) => {
+            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, () => {
+        console.log('[24h] Level 1 restart: Graceful restart...');
+        // 可以添加进程重启逻辑
+    });
+    watchdog.registerRestartStrategy(2, () => {
+        console.log('[24h] Level 2 restart: Process restart...');
+        // 可以添加进程重启逻辑
+    });
+    watchdog.registerRestartStrategy(3, () => {
+        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() {
+    const healthMonitor = getHealthMonitor();
+    return healthMonitor.check();
+}
+// Re-export singleton getters for convenience
+export { getHealthMonitor, createHealthMonitor };
+export { getWatchdog, createWatchdog };
+export { getDaemonManager, createDaemonManager };
+export { getStartupVerifier };

package/dist/heartbeat/types.js

@@ -0,0 +1,5 @@
+/**
+ * Bolloon 24h Heartbeat Types
+ * 健康检查、看门狗、守护进程的类型定义
+ */
+export {};