@f2a/network 0.1.2

package/packages/openclaw-adapter/src/reputation.test.ts

@@ -0,0 +1,221 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ReputationSystem } from './reputation';
+import { ReputationConfig } from './types';
+
+// Mock fs - 使用 factory 函数返回 mock 函数
+vi.mock('fs', () => {
+  return {
+    existsSync: vi.fn(),
+    readFileSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    mkdirSync: vi.fn(),
+    renameSync: vi.fn(),
+    unlinkSync: vi.fn(),
+  };
+});
+
+// Mock path
+vi.mock('path', () => ({
+  join: vi.fn((...args) => args.join('/')),
+}));
+
+describe('ReputationSystem', () => {
+  let system: ReputationSystem;
+  const mockConfig: ReputationConfig = {
+    initialScore: 50,
+    decayFactor: 0.95,
+    historyLimit: 10,
+    minScoreForDelegation: 30,
+  };
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+    const { existsSync } = await import('fs');
+    vi.mocked(existsSync).mockReturnValue(false);
+    system = new ReputationSystem(mockConfig, './test-data');
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe('getReputation', () => {
+    it('should return default reputation for new peer', () => {
+      const rep = system.getReputation('peer-1');
+      expect(rep.peerId).toBe('peer-1');
+      expect(rep.score).toBe(50);
+      expect(rep.totalTasks).toBe(0);
+    });
+
+    it('should return same reputation for existing peer', () => {
+      const rep1 = system.getReputation('peer-1');
+      const rep2 = system.getReputation('peer-1');
+      expect(rep1).toBe(rep2);
+    });
+  });
+
+  describe('recordSuccess', () => {
+    it('should increase score on success', () => {
+      system.recordSuccess('peer-1', 'task-1', 100);
+      const rep = system.getReputation('peer-1');
+      expect(rep.score).toBe(60);
+      expect(rep.successfulTasks).toBe(1);
+      expect(rep.totalTasks).toBe(1);
+    });
+
+    it('should update average response time using EMA', () => {
+      system.recordSuccess('peer-1', 'task-1', 100);
+      system.recordSuccess('peer-1', 'task-2', 200);
+      const rep = system.getReputation('peer-1');
+      // EMA: 100 * 0.7 + 200 * 0.3 = 70 + 60 = 130
+      expect(rep.avgResponseTime).toBe(130);
+    });
+
+    it('should cap score at 100', () => {
+      for (let i = 0; i < 10; i++) {
+        system.recordSuccess('peer-1', `task-${i}`, 100);
+      }
+      const rep = system.getReputation('peer-1');
+      expect(rep.score).toBe(100);
+    });
+  });
+
+  describe('recordFailure', () => {
+    it('should decrease score on failure', () => {
+      system.recordFailure('peer-1', 'task-1', 'timeout');
+      const rep = system.getReputation('peer-1');
+      expect(rep.score).toBe(30);
+      expect(rep.failedTasks).toBe(1);
+    });
+
+    it('should not go below 0', () => {
+      system.recordFailure('peer-1', 'task-1');
+      system.recordFailure('peer-1', 'task-2');
+      system.recordFailure('peer-1', 'task-3');
+      const rep = system.getReputation('peer-1');
+      expect(rep.score).toBe(0);
+    });
+  });
+
+  describe('recordRejection', () => {
+    it('should decrease score on rejection', () => {
+      system.recordRejection('peer-1', 'task-1', 'busy');
+      const rep = system.getReputation('peer-1');
+      expect(rep.score).toBe(45);
+    });
+  });
+
+  describe('isAllowed', () => {
+    it('should return true for allowed peer', () => {
+      system.recordSuccess('peer-1', 'task-1', 100);
+      system.recordSuccess('peer-1', 'task-2', 100);
+      system.recordSuccess('peer-1', 'task-3', 100);
+      expect(system.isAllowed('peer-1')).toBe(true);
+    });
+
+    it('should return false for disallowed peer when enabled', () => {
+      // Create a system with enabled reputation check
+      // enabled: true - 启用信誉检查，低于 minScoreForService 的节点将被拒绝
+      // minScoreForService: 35 - 服务最低信誉门槛（默认50分，失败一次扣20分，所以30分会低于35）
+      const strictConfig = { ...mockConfig, enabled: true, minScoreForService: 35 };
+      const strictSystem = new ReputationSystem(strictConfig, './test-data');
+      strictSystem.recordFailure('peer-1', 'task-1'); // score goes from 50 to 30
+      expect(strictSystem.isAllowed('peer-1')).toBe(false);
+    });
+  });
+
+  describe('getAllReputations', () => {
+    it('should return all reputations sorted by score', () => {
+      system.recordSuccess('peer-a', 'task-1', 100);
+      system.recordSuccess('peer-a', 'task-2', 100);
+      system.recordSuccess('peer-b', 'task-1', 100);
+      
+      const allReps = system.getAllReputations();
+      expect(allReps[0].peerId).toBe('peer-a');
+      expect(allReps[0].score).toBe(70);
+      expect(allReps[1].peerId).toBe('peer-b');
+      expect(allReps[1].score).toBe(60);
+    });
+
+    it('should limit results when specified', () => {
+      system.recordSuccess('peer-a', 'task-1', 100);
+      system.recordSuccess('peer-b', 'task-1', 100);
+      system.recordSuccess('peer-c', 'task-1', 100);
+      
+      const allReps = system.getAllReputations();
+      // getAllReputations doesn't have limit param, so we get all
+      expect(allReps.length).toBe(3);
+    });
+  });
+
+  // P0 修复：测试防抖保存功能
+  describe('debounced save', () => {
+    it('should debounce multiple save calls', async () => {
+      const { writeFileSync, renameSync } = await import('fs');
+      
+      // 连续调用多次 recordSuccess，每个都会触发 save
+      system.recordSuccess('peer-1', 'task-1', 100);
+      system.recordSuccess('peer-1', 'task-2', 100);
+      system.recordSuccess('peer-1', 'task-3', 100);
+      
+      // 此时应该还没有写入（防抖延迟内）
+      expect(writeFileSync).not.toHaveBeenCalled();
+      
+      // 等待足够长的时间让定时器执行
+      vi.advanceTimersByTime(200);
+      
+      // 执行 setImmediate 回调
+      await vi.runAllTimersAsync();
+      
+      // 应该有写入调用（防抖将多次合并为一次或多次，取决于实现）
+      expect(writeFileSync).toHaveBeenCalled();
+      expect(renameSync).toHaveBeenCalled();
+    });
+
+    it('should use async write to avoid blocking', async () => {
+      const { writeFileSync } = await import('fs');
+      
+      system.recordSuccess('peer-1', 'task-1', 100);
+      
+      // 在 timer 执行前，writeFileSync 不应该被调用（因为是 setImmediate）
+      expect(writeFileSync).not.toHaveBeenCalled();
+      
+      // 等待足够时间
+      vi.advanceTimersByTime(200);
+      await vi.runAllTimersAsync();
+      
+      // 现在应该被调用了
+      expect(writeFileSync).toHaveBeenCalled();
+    });
+  });
+
+  describe('flush', () => {
+    it('should immediately save pending data', async () => {
+      const { writeFileSync, renameSync } = await import('fs');
+      
+      // 调用 recordSuccess 触发 save（设置 savePending = true）
+      system.recordSuccess('peer-1', 'task-1', 100);
+      
+      // 不等待任何 timer，直接调用 flush
+      // flush 应该立即同步保存待保存的数据
+      system.flush();
+      
+      // flush 是同步的，应该立即调用 writeFileSync
+      expect(writeFileSync).toHaveBeenCalled();
+      expect(renameSync).toHaveBeenCalled();
+    });
+
+    it('should not save if no pending data', async () => {
+      const { writeFileSync } = await import('fs');
+      
+      // 创建一个新的 system，没有任何操作
+      const freshSystem = new ReputationSystem(mockConfig, './test-data-fresh');
+      
+      // 没有待保存的数据，flush 不应该触发写入
+      freshSystem.flush();
+      
+      expect(writeFileSync).not.toHaveBeenCalled();
+    });
+  });
+});

package/packages/openclaw-adapter/src/reputation.ts

@@ -0,0 +1,368 @@
+/**
+ * 信誉系统
+ * 管理 Peer 的信誉分数
+ */
+
+import { existsSync, readFileSync, writeFileSync, renameSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import type { 
+  ReputationEntry, 
+  ReputationEvent, 
+  ReputationConfig,
+  TaskResponse 
+} from './types.js';
+import { pluginLogger as logger } from './logger.js';
+
+/** 防抖保存配置 */
+interface DebounceConfig {
+  /** 防抖延迟时间（毫秒） */
+  delayMs: number;
+  /** 最大等待时间（毫秒） */
+  maxWaitMs: number;
+}
+
+export class ReputationSystem {
+  private config: ReputationConfig;
+  private entries: Map<string, ReputationEntry> = new Map();
+  private dataPath: string;
+  
+  // 防抖写入相关
+  private savePending: boolean = false;
+  private saveTimer?: NodeJS.Timeout;
+  private lastSaveTime: number = Date.now();  // 初始化为当前时间，避免首次调用立即触发
+  private debounceConfig: DebounceConfig = {
+    delayMs: 100,    // 100ms 防抖延迟
+    maxWaitMs: 1000  // 最多等待 1 秒
+  };
+
+  constructor(config: ReputationConfig, dataDir: string) {
+    this.config = config;
+    this.dataPath = join(dataDir, 'reputation.json');
+    this.load();
+  }
+
+  /**
+   * 获取 Peer 信誉
+   */
+  getReputation(peerId: string): ReputationEntry {
+    if (!this.entries.has(peerId)) {
+      this.entries.set(peerId, this.createDefaultEntry(peerId));
+    }
+    return this.entries.get(peerId)!;
+  }
+
+  /**
+   * 记录任务成功
+   */
+  recordSuccess(peerId: string, taskId: string, latency: number): void {
+    const entry = this.getReputation(peerId);
+    
+    entry.successfulTasks++;
+    entry.totalTasks++;
+    entry.score = Math.min(100, entry.score + 10);
+    entry.avgResponseTime = this.updateAvgResponseTime(entry, latency);
+    entry.lastInteraction = Date.now();
+    
+    entry.history.push({
+      type: 'task_success',
+      taskId,
+      delta: +10,
+      timestamp: Date.now()
+    });
+
+    this.trimHistory(entry);
+    this.save();
+  }
+
+  /**
+   * 记录任务失败
+   */
+  recordFailure(peerId: string, taskId: string, reason?: string): void {
+    const entry = this.getReputation(peerId);
+    
+    entry.failedTasks++;
+    entry.totalTasks++;
+    entry.score = Math.max(0, entry.score - 20);
+    entry.lastInteraction = Date.now();
+    
+    entry.history.push({
+      type: 'task_failure',
+      taskId,
+      delta: -20,
+      timestamp: Date.now(),
+      reason
+    });
+
+    this.trimHistory(entry);
+    this.save();
+  }
+
+  /**
+   * 记录任务拒绝
+   */
+  recordRejection(peerId: string, taskId: string, reason?: string): void {
+    const entry = this.getReputation(peerId);
+    
+    entry.totalTasks++;
+    entry.score = Math.max(0, entry.score - 5);
+    entry.lastInteraction = Date.now();
+    
+    entry.history.push({
+      type: 'task_rejected',
+      taskId,
+      delta: -5,
+      timestamp: Date.now(),
+      reason
+    });
+
+    this.trimHistory(entry);
+    this.save();
+  }
+
+  /**
+   * 记录超时
+   */
+  recordTimeout(peerId: string, taskId: string): void {
+    const entry = this.getReputation(peerId);
+    
+    entry.totalTasks++;
+    entry.score = Math.max(0, entry.score - 15);
+    entry.lastInteraction = Date.now();
+    
+    entry.history.push({
+      type: 'timeout',
+      taskId,
+      delta: -15,
+      timestamp: Date.now()
+    });
+
+    this.trimHistory(entry);
+    this.save();
+  }
+
+  /**
+   * 记录恶意行为
+   */
+  recordMalicious(peerId: string, reason: string): void {
+    const entry = this.getReputation(peerId);
+    
+    entry.score = Math.max(0, entry.score - 50);
+    entry.lastInteraction = Date.now();
+    
+    entry.history.push({
+      type: 'malicious',
+      delta: -50,
+      timestamp: Date.now(),
+      reason
+    });
+
+    this.trimHistory(entry);
+    this.save();
+  }
+
+  /**
+   * 检查是否允许服务
+   */
+  isAllowed(peerId: string): boolean {
+    if (!this.config.enabled) return true;
+    
+    const entry = this.getReputation(peerId);
+    return entry.score >= this.config.minScoreForService;
+  }
+
+  /**
+   * 获取所有信誉记录
+   */
+  getAllReputations(): ReputationEntry[] {
+    return Array.from(this.entries.values());
+  }
+
+  /**
+   * 清理过期记录
+   */
+  cleanup(maxAgeDays: number = 30): void {
+    const cutoff = Date.now() - (maxAgeDays * 24 * 60 * 60 * 1000);
+    
+    for (const [peerId, entry] of this.entries) {
+      if (entry.lastInteraction < cutoff && entry.totalTasks === 0) {
+        this.entries.delete(peerId);
+      }
+    }
+    
+    this.save();
+  }
+
+  /**
+   * 获取高信誉节点
+   */
+  getHighReputationNodes(minScore: number): ReputationEntry[] {
+    return Array.from(this.entries.values())
+      .filter(entry => entry.score >= minScore);
+  }
+
+  /**
+   * 创建默认条目
+   */
+  private createDefaultEntry(peerId: string): ReputationEntry {
+    return {
+      peerId,
+      score: this.config.initialScore,
+      successfulTasks: 0,
+      failedTasks: 0,
+      totalTasks: 0,
+      avgResponseTime: 0,
+      lastInteraction: 0,
+      history: []
+    };
+  }
+
+  /**
+   * 更新平均响应时间
+   */
+  private updateAvgResponseTime(entry: ReputationEntry, newLatency: number): number {
+    if (entry.avgResponseTime === 0) {
+      return newLatency;
+    }
+    // 指数移动平均
+    return entry.avgResponseTime * 0.7 + newLatency * 0.3;
+  }
+
+  /**
+   * 修剪历史记录
+   */
+  private trimHistory(entry: ReputationEntry, maxSize: number = 100): void {
+    if (entry.history.length > maxSize) {
+      entry.history = entry.history.slice(-maxSize);
+    }
+  }
+
+  /**
+   * 加载数据
+   */
+  private load(): void {
+    if (existsSync(this.dataPath)) {
+      try {
+        const data = JSON.parse(readFileSync(this.dataPath, 'utf-8'));
+        for (const entry of data) {
+          this.entries.set(entry.peerId, entry);
+        }
+        logger.info('加载了 %d 条信誉记录', this.entries.size);
+      } catch (e) {
+        logger.error('加载信誉数据失败: error=%s', e);
+      }
+    }
+  }
+
+  /**
+   * 保存数据（防抖 + 异步写入）
+   * 
+   * P0 修复：使用防抖机制避免高并发下的阻塞问题
+   * - 短时间内多次调用只触发一次实际写入
+   * - 使用异步写入避免阻塞主线程
+   * - 原子写入保证数据完整性
+   */
+  private save(): void {
+    // 标记有待保存的数据
+    this.savePending = true;
+    
+    // 如果已有定时器，先清除
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+    }
+    
+    const now = Date.now();
+    const timeSinceLastSave = now - this.lastSaveTime;
+    
+    // 如果距离上次保存超过 maxWaitMs，立即保存
+    if (timeSinceLastSave >= this.debounceConfig.maxWaitMs) {
+      this.doSave();
+      return;
+    }
+    
+    // 否则设置防抖定时器
+    this.saveTimer = setTimeout(() => {
+      if (this.savePending) {
+        this.doSave();
+      }
+    }, this.debounceConfig.delayMs);
+  }
+  
+  /**
+   * 执行实际的保存操作（异步）
+   */
+  private doSave(): void {
+    this.savePending = false;
+    this.saveTimer = undefined;
+    this.lastSaveTime = Date.now();
+    
+    const tempPath = `${this.dataPath}.tmp`;
+    
+    // 使用 setImmediate 将文件操作移到下一个事件循环
+    // 避免阻塞当前操作
+    setImmediate(() => {
+      try {
+        const data = Array.from(this.entries.values());
+        const jsonContent = JSON.stringify(data, null, 2);
+        
+        // 1. 写入临时文件
+        writeFileSync(tempPath, jsonContent, { encoding: 'utf-8' });
+        
+        // 2. 原子重命名（在 POSIX 系统上是原子操作）
+        renameSync(tempPath, this.dataPath);
+      } catch (e) {
+        logger.error('保存信誉数据失败: error=%s', e);
+        
+        // 清理临时文件（如果存在）
+        try {
+          if (existsSync(tempPath)) {
+            unlinkSync(tempPath);
+          }
+        } catch {
+          // 忽略清理错误
+        }
+      }
+    });
+  }
+  
+  /**
+   * 强制同步保存（用于关闭时）
+   */
+  flush(): void {
+    // 清除防抖定时器
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+      this.saveTimer = undefined;
+    }
+    
+    // 如果有待保存的数据，立即同步保存
+    if (this.savePending) {
+      this.savePending = false;
+      this.doSaveSync();
+    }
+  }
+  
+  /**
+   * 同步保存操作（用于关闭时确保数据持久化）
+   */
+  private doSaveSync(): void {
+    const tempPath = `${this.dataPath}.tmp`;
+    
+    try {
+      const data = Array.from(this.entries.values());
+      const jsonContent = JSON.stringify(data, null, 2);
+      
+      writeFileSync(tempPath, jsonContent, { encoding: 'utf-8' });
+      renameSync(tempPath, this.dataPath);
+    } catch (e) {
+      logger.error('同步保存信誉数据失败: error=%s', e);
+      
+      try {
+        if (existsSync(tempPath)) {
+          unlinkSync(tempPath);
+        }
+      } catch {
+        // 忽略清理错误
+      }
+    }
+  }
+}