@bolloon/bolloon-agent 0.1.1 → 0.1.2

package/dist/heartbeat/DaemonManager.js

@@ -0,0 +1,242 @@
+/**
+ * DaemonManager - 守护进程管理器
+ * 支持自动重启、日志轮转、PID 管理
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class DaemonManager {
+    config;
+    state = null;
+    stopRequested = false;
+    isChildProcess = false;
+    constructor(config = {}) {
+        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() {
+        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() {
+        const state = await this.getState();
+        return state !== null;
+    }
+    /**
+     * 保存 PID 文件
+     */
+    async savePid() {
+        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() {
+        try {
+            await fs.unlink(this.config.pidFile);
+        }
+        catch {
+            // 忽略删除失败
+        }
+    }
+    /**
+     * 写入日志
+     */
+    async writeLog(message) {
+        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 = process.argv) {
+        // 检查是否已在运行
+        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) {
+        if (!this.isChildProcess) {
+            // 父进程：启动子进程
+            await this.runChildProcess(childArgs);
+            return;
+        }
+        // 子进程：正常运行主程序
+        console.log('[Daemon] Running as child process');
+    }
+    /**
+     * 启动子进程
+     */
+    async runChildProcess(childArgs) {
+        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((resolve) => {
+                child.on('exit', () => resolve());
+            });
+        }
+    }
+    /**
+     * 设置优雅退出
+     */
+    setupGracefulShutdown() {
+        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();
+        });
+    }
+    /**
+     * 设置信号处理
+     */
+    setupSignalHandlers() {
+        process.on('SIGHUP', () => {
+            console.log('[Daemon] Received SIGHUP, reloading...');
+            // 可以实现配置重载逻辑
+        });
+    }
+    /**
+     * 请求停止守护进程
+     */
+    async stop() {
+        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() {
+        return this.state?.restartCount || 0;
+    }
+    /**
+     * 检查是否可以继续重启
+     */
+    canRestart() {
+        return (this.state?.restartCount || 0) < this.config.maxRestarts;
+    }
+}
+// 全局实例
+let daemonManagerInstance = null;
+export function getDaemonManager() {
+    if (!daemonManagerInstance) {
+        daemonManagerInstance = new DaemonManager();
+    }
+    return daemonManagerInstance;
+}
+export function createDaemonManager(config) {
+    daemonManagerInstance = new DaemonManager(config);
+    return daemonManagerInstance;
+}

package/dist/heartbeat/HealthMonitor.js

@@ -0,0 +1,285 @@
+/**
+ * HealthMonitor - 健康检查核心
+ * 监控 P2P、Iroh、LLM、内存等关键指标
+ */
+import { getMinimax } from '../constraints/index.js';
+export class HealthMonitor {
+    config;
+    lastHeartbeatTime = Date.now();
+    checkIntervalId = null;
+    onStatusChange;
+    constructor(config = {}) {
+        this.config = config;
+        this.onStatusChange = config.onStatusChange;
+    }
+    /**
+     * 执行完整健康检查
+     */
+    async check() {
+        const 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 = 'healthy';
+        if (errors >= 3) {
+            status = 'unhealthy';
+        }
+        else if (errors >= 1) {
+            status = 'degraded';
+        }
+        const healthStatus = {
+            status,
+            timestamp: new Date().toISOString(),
+            uptime_seconds: process.uptime(),
+            checks,
+            recommendations: this.generateRecommendations(checks)
+        };
+        this.onStatusChange?.(healthStatus);
+        return healthStatus;
+    }
+    /**
+     * 检查 P2P 连接状态
+     */
+    async checkP2P() {
+        const start = Date.now();
+        try {
+            // 从全局状态获取 HyperswarmCommunicator
+            const comm = global.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) {
+            return { status: 'error', message: err.message, latency_ms: Date.now() - start };
+        }
+    }
+    /**
+     * 检查 Iroh 节点状态
+     */
+    async checkIroh() {
+        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) {
+            return { status: 'error', message: err.message, latency_ms: Date.now() - start };
+        }
+    }
+    /**
+     * 检查 LLM 连接状态
+     */
+    async checkLLM() {
+        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) {
+            return { status: 'error', message: err.message, latency_ms: Date.now() - start };
+        }
+    }
+    /**
+     * 检查内存使用
+     */
+    async checkMemory() {
+        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) {
+            return { status: 'error', message: err.message, latency_ms: Date.now() - start };
+        }
+    }
+    /**
+     * 检查心跳活跃度
+     */
+    async checkHeartbeat() {
+        const start = Date.now();
+        const elapsed = Date.now() - this.lastHeartbeatTime;
+        // 获取 SocialHeartbeat 状态
+        const heartbeat = global.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() {
+        this.lastHeartbeatTime = Date.now();
+    }
+    /**
+     * 获取当前状态（不执行检查）
+     */
+    getQuickStatus() {
+        const usage = process.memoryUsage();
+        return {
+            status: 'active',
+            lastHeartbeat: this.lastHeartbeatTime,
+            memoryUsage: Math.round((usage.heapUsed / usage.heapTotal) * 100)
+        };
+    }
+    /**
+     * 生成健康建议
+     */
+    generateRecommendations(checks) {
+        const recommendations = [];
+        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 测试响应
+     */
+    async pingLLM(minimax) {
+        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 = 60000, callback) {
+        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() {
+        if (this.checkIntervalId) {
+            clearInterval(this.checkIntervalId);
+            this.checkIntervalId = null;
+        }
+    }
+}
+// 全局实例
+let healthMonitorInstance = null;
+export function getHealthMonitor() {
+    if (!healthMonitorInstance) {
+        healthMonitorInstance = new HealthMonitor();
+    }
+    return healthMonitorInstance;
+}
+export function createHealthMonitor(config) {
+    healthMonitorInstance = new HealthMonitor(config);
+    return healthMonitorInstance;
+}