@f2a/network 0.1.2 → 0.2.0

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

@@ -1,221 +0,0 @@
-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

@@ -1,368 +0,0 @@
-/**
- * 信誉系统
- * 管理 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 {
-        // 忽略清理错误
-      }
-    }
-  }
-}