@f2a/network 0.1.2 → 0.2.0

package/packages/openclaw-adapter/src/node-manager.ts

@@ -1,429 +0,0 @@
-/**
- * F2A Node Manager
- * 管理 F2A Network 服务的生命周期
- */
-
-import { spawn, ChildProcess } from 'child_process';
-import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
-import { join } from 'path';
-import { promisify } from 'util';
-import type { F2ANodeConfig, Result } from './types.js';
-import { nodeLogger as logger } from './logger.js';
-
-const sleep = promisify(setTimeout);
-
-// PID 文件路径
-const PID_FILE_NAME = 'f2a-node.pid';
-
-/** 健康检查重启配置 */
-interface HealthCheckRestartConfig {
-  /** 最大连续重启次数 */
-  maxRestarts: number;
-  /** 重启计数重置时间窗口（毫秒） */
-  resetWindowMs: number;
-  /** 冷却期基础时间（毫秒） */
-  cooldownBaseMs: number;
-  /** 冷却期最大时间（毫秒） */
-  cooldownMaxMs: number;
-}
-
-/** 默认重启配置 */
-const DEFAULT_RESTART_CONFIG: HealthCheckRestartConfig = {
-  maxRestarts: 3,           // 最多连续重启 3 次
-  resetWindowMs: 60000,     // 1 分钟内重置计数
-  cooldownBaseMs: 5000,     // 冷却期基础 5 秒
-  cooldownMaxMs: 60000      // 冷却期最大 60 秒
-};
-
-export class F2ANodeManager {
-  private process: ChildProcess | null = null;
-  private config: F2ANodeConfig;
-  private healthCheckInterval?: NodeJS.Timeout;
-  private pidFilePath: string;
-  
-  // P1 修复：健康检查重启限制
-  private restartConfig: HealthCheckRestartConfig;
-  private consecutiveRestarts: number = 0;
-  private lastRestartTime: number = 0;
-  private isRestarting: boolean = false;
-
-  constructor(config: Partial<F2ANodeConfig>) {
-    this.config = {
-      nodePath: config.nodePath || './F2A',
-      controlPort: config.controlPort || 9001,
-      controlToken: config.controlToken || this.generateToken(),
-      p2pPort: config.p2pPort || 9000,
-      enableMDNS: config.enableMDNS ?? true,
-      bootstrapPeers: config.bootstrapPeers || []
-    };
-    this.pidFilePath = join(this.config.nodePath, PID_FILE_NAME);
-    this.restartConfig = { ...DEFAULT_RESTART_CONFIG };
-    
-    // 启动时清理孤儿进程
-    this.cleanupOrphanProcesses();
-  }
-
-  /**
-   * 清理孤儿进程
-   * 检查 PID 文件中记录的进程是否仍在运行，如果是则尝试清理
-   */
-  private cleanupOrphanProcesses(): void {
-    if (!existsSync(this.pidFilePath)) {
-      return;
-    }
-
-    try {
-      const pidStr = readFileSync(this.pidFilePath, 'utf-8').trim();
-      const pid = parseInt(pidStr, 10);
-
-      if (isNaN(pid)) {
-        // PID 文件无效，删除
-        unlinkSync(this.pidFilePath);
-        return;
-      }
-
-      // 检查进程是否存在
-      try {
-        process.kill(pid, 0); // 不实际发送信号，只检查进程是否存在
-        // 进程存在，尝试终止
-        logger.info('发现孤儿进程，尝试终止: pid=%d', pid);
-        try {
-          process.kill(pid, 'SIGTERM');
-          // 等待进程终止
-          setTimeout(() => {
-            try {
-              process.kill(pid, 0); // 检查是否还在运行
-              process.kill(pid, 'SIGKILL'); // 强制终止
-            } catch {
-              // 进程已终止
-            }
-          }, 3000);
-        } catch (killError) {
-          // 无法终止，可能是权限问题
-          logger.warn('无法终止孤儿进程: pid=%d, error=%s', pid, killError);
-        }
-      } catch {
-        // 进程不存在，只删除 PID 文件
-      }
-
-      // 删除 PID 文件
-      unlinkSync(this.pidFilePath);
-      logger.info('孤儿进程清理完成');
-    } catch (error) {
-      logger.warn('清理孤儿进程失败: error=%s', error);
-    }
-  }
-
-  /**
-   * 保存 PID 到文件
-   */
-  private savePid(pid: number): void {
-    try {
-      writeFileSync(this.pidFilePath, String(pid), { mode: 0o644 });
-      logger.info('PID 文件已保存: path=%s', this.pidFilePath);
-    } catch (error) {
-      logger.warn('保存 PID 文件失败: error=%s', error);
-    }
-  }
-
-  /**
-   * 删除 PID 文件
-   */
-  private removePidFile(): void {
-    try {
-      if (existsSync(this.pidFilePath)) {
-        unlinkSync(this.pidFilePath);
-      }
-    } catch (error) {
-      logger.warn('删除 PID 文件失败: error=%s', error);
-    }
-  }
-
-  /**
-   * 确保 F2A Node 在运行
-   */
-  async ensureRunning(): Promise<Result<void>> {
-    if (await this.isRunning()) {
-      logger.info('Node 已在运行');
-      return { success: true };
-    }
-
-    return this.start();
-  }
-
-  /**
-   * 启动 F2A Node
-   */
-  async start(): Promise<Result<void>> {
-    const daemonPath = join(this.config.nodePath, 'dist/daemon/index.js');
-
-    if (!existsSync(daemonPath)) {
-      return {
-        success: false,
-        error: `F2A Node 未找到: ${daemonPath}\n请先运行: cd ${this.config.nodePath} && npm install && npm run build`
-      };
-    }
-
-    logger.info('启动 Node...');
-    logger.info('Control Port: %d', this.config.controlPort);
-    logger.info('P2P Port: %d', this.config.p2pPort);
-
-    try {
-      this.process = spawn('node', [daemonPath], {
-        cwd: this.config.nodePath,
-        env: {
-          ...process.env,
-          F2A_CONTROL_PORT: String(this.config.controlPort),
-          F2A_CONTROL_TOKEN: this.config.controlToken,
-          F2A_P2P_PORT: String(this.config.p2pPort),
-          F2A_ENABLE_MDNS: String(this.config.enableMDNS),
-          F2A_BOOTSTRAP_PEERS: JSON.stringify(this.config.bootstrapPeers)
-        },
-        detached: true,
-        stdio: ['ignore', 'pipe', 'pipe']
-      });
-
-      // 记录子进程 PID
-      const pid = this.process.pid;
-      if (pid) {
-        this.savePid(pid);
-      }
-
-      // 监听进程退出事件
-      this.process.on('exit', (code, signal) => {
-        logger.info('Node 进程退出: code=%s, signal=%s', code, signal);
-        this.removePidFile();
-        this.process = null;
-      });
-
-      this.process.on('error', (err) => {
-        logger.error('Node 进程错误: error=%s', err);
-        this.removePidFile();
-      });
-
-      this.process.unref();
-
-      // 记录日志
-      this.process.stdout?.on('data', (data) => {
-        logger.info('Node stdout: %s', data.toString().trim());
-      });
-
-      this.process.stderr?.on('data', (data) => {
-        logger.error('Node stderr: %s', data.toString().trim());
-      });
-
-      // 等待启动完成
-      await this.waitForReady(30000);
-
-      // 启动健康检查
-      this.startHealthCheck();
-
-      // P1 修复：成功启动后重置重启计数器
-      this.consecutiveRestarts = 0;
-
-      logger.info('Node 启动成功');
-      return { success: true };
-
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      this.removePidFile();
-      return { success: false, error: errorMsg };
-    }
-  }
-
-  /**
-   * 停止 F2A Node
-   */
-  async stop(): Promise<void> {
-    if (this.healthCheckInterval) {
-      clearInterval(this.healthCheckInterval);
-    }
-
-    if (this.process) {
-      logger.info('停止 Node...');
-      
-      // 尝试优雅关闭
-      this.process.kill('SIGTERM');
-      
-      // 等待 5 秒
-      await sleep(5000);
-      
-      // 如果还在运行，强制关闭
-      if (this.process.exitCode === null) {
-        this.process.kill('SIGKILL');
-      }
-      
-      this.process = null;
-    } else {
-      // 没有当前进程引用，但可能存在孤儿进程
-      // 尝试从 PID 文件读取并终止
-      if (existsSync(this.pidFilePath)) {
-        try {
-          const pidStr = readFileSync(this.pidFilePath, 'utf-8').trim();
-          const pid = parseInt(pidStr, 10);
-          if (!isNaN(pid)) {
-            logger.info('尝试终止残留进程: pid=%d', pid);
-            try {
-              process.kill(pid, 'SIGTERM');
-              await sleep(3000);
-              try {
-                process.kill(pid, 0);
-                process.kill(pid, 'SIGKILL');
-              } catch {
-                // 进程已终止
-              }
-            } catch {
-              // 进程不存在或无权限
-            }
-          }
-        } catch (error) {
-          logger.warn('清理残留进程失败: error=%s', error);
-        }
-      }
-    }
-
-    // 清理 PID 文件
-    this.removePidFile();
-  }
-
-  /**
-   * 检查 Node 是否运行中
-   */
-  async isRunning(): Promise<boolean> {
-    try {
-      const response = await fetch(`http://localhost:${this.config.controlPort}/health`, {
-        headers: {
-          'Authorization': `Bearer ${this.config.controlToken}`
-        }
-      });
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * 获取 Node 状态
-   */
-  async getStatus(): Promise<Result<{
-    running: boolean;
-    peerId?: string;
-    connectedPeers?: number;
-    uptime?: number;
-  }>> {
-    try {
-      const response = await fetch(`http://localhost:${this.config.controlPort}/status`, {
-        headers: {
-          'Authorization': `Bearer ${this.config.controlToken}`
-        }
-      });
-
-      if (!response.ok) {
-        return { success: false, error: 'Node 未响应' };
-      }
-
-      const data = await response.json() as { running: boolean; peerId?: string; connectedPeers?: number; uptime?: number };
-      return { success: true, data };
-
-    } catch (error) {
-      return { 
-        success: false, 
-        error: error instanceof Error ? error.message : String(error) 
-      };
-    }
-  }
-
-  /**
-   * 等待 Node 就绪
-   */
-  private async waitForReady(timeout: number): Promise<void> {
-    const start = Date.now();
-    
-    while (Date.now() - start < timeout) {
-      if (await this.isRunning()) {
-        return;
-      }
-      await sleep(500);
-    }
-    
-    throw new Error('Node 启动超时');
-  }
-
-  /**
-   * 启动健康检查
-   * 
-   * P1 修复：添加重启次数限制和冷却期，防止无限重启循环
-   */
-  private startHealthCheck(): void {
-    this.healthCheckInterval = setInterval(async () => {
-      // 如果正在重启，跳过本次检查
-      if (this.isRestarting) {
-        return;
-      }
-
-      const isHealthy = await this.isRunning();
-      if (!isHealthy && this.process) {
-        // 检查是否达到重启限制
-        const now = Date.now();
-        
-        // 如果距离上次重启超过重置窗口，重置计数
-        if (now - this.lastRestartTime > this.restartConfig.resetWindowMs) {
-          this.consecutiveRestarts = 0;
-        }
-        
-        // 检查是否达到最大重启次数
-        if (this.consecutiveRestarts >= this.restartConfig.maxRestarts) {
-          logger.error(
-            'Node 健康检查失败，已达到最大重启次数: maxRestarts=%d, resetWindowMs=%d',
-            this.restartConfig.maxRestarts,
-            Math.round(this.restartConfig.resetWindowMs / 1000)
-          );
-          return;
-        }
-        
-        // 计算冷却期（指数退避）
-        const cooldownMs = Math.min(
-          this.restartConfig.cooldownBaseMs * Math.pow(2, this.consecutiveRestarts),
-          this.restartConfig.cooldownMaxMs
-        );
-        
-        logger.warn(
-          'Node 健康检查失败，尝试重启: attempt=%d/%d, cooldownMs=%d',
-          this.consecutiveRestarts + 1,
-          this.restartConfig.maxRestarts,
-          Math.round(cooldownMs / 1000)
-        );
-        
-        this.isRestarting = true;
-        this.consecutiveRestarts++;
-        this.lastRestartTime = now;
-        
-        try {
-          await this.stop();
-          await sleep(cooldownMs);
-          await this.start();
-        } catch (error) {
-          logger.error('重启失败: error=%s', error);
-        } finally {
-          this.isRestarting = false;
-        }
-      }
-    }, 30000); // 每 30 秒检查一次
-  }
-
-  /**
-   * 生成随机 Token
-   */
-  private generateToken(): string {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    let token = 'f2a-';
-    for (let i = 0; i < 32; i++) {
-      token += chars.charAt(Math.floor(Math.random() * chars.length));
-    }
-    return token;
-  }
-
-  getConfig(): F2ANodeConfig {
-    return { ...this.config };
-  }
-}