@capyclaw/tool-host 0.1.0 → 0.1.1

package/src/optimizers/production-streaming-renderer.mjs

@@ -1,611 +0,0 @@
-/**
- * 生产级 PPT 流式渲染器
- * 
- * 核心特性：
- * - 稳定性：自动重连、心跳检测、消息确认
- * - 断点续传：状态持久化、会话恢复
- * - 性能优化：缓冲区、反压控制、预测渲染
- * - 准确性：操作验证、事务回滚
- * - 中断处理：优雅收尾、方向切换
- */
-
-import { EventEmitter } from 'node:events';
-
-// ============================================
-// 1. 稳定连接管理
-// ============================================
-
-export class StableConnection extends EventEmitter {
-  constructor(wsUrl, options = {}) {
-    super();
-    this.wsUrl = wsUrl;
-    this.ws = null;
-    this.reconnectAttempts = 0;
-    this.maxReconnectAttempts = options.maxReconnectAttempts || 5;
-    this.reconnectDelay = options.reconnectDelay || 1000;
-    this.heartbeatInterval = null;
-    this.lastHeartbeat = Date.now();
-    this.pendingMessages = [];
-  }
-
-  async connect() {
-    return new Promise((resolve, reject) => {
-      try {
-        this.ws = new WebSocket(this.wsUrl);
-        
-        this.ws.onopen = () => {
-          console.log('✅ WebSocket 连接成功');
-          this.reconnectAttempts = 0;
-          this.startHeartbeat();
-          this.flushPendingMessages();
-          this.emit('connected');
-          resolve();
-        };
-        
-        this.ws.onerror = (error) => {
-          console.error('❌ WebSocket 错误:', error);
-          this.emit('error', error);
-        };
-        
-        this.ws.onclose = () => {
-          console.log('🔌 WebSocket 断开');
-          this.stopHeartbeat();
-          this.emit('disconnected');
-          this.attemptReconnect();
-        };
-
-        this.ws.onmessage = (event) => {
-          this.handleMessage(event.data);
-        };
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-
-  startHeartbeat() {
-    this.heartbeatInterval = setInterval(() => {
-      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-        this.send({ type: 'ping', timestamp: Date.now() });
-      } else {
-        this.attemptReconnect();
-      }
-    }, 5000);
-  }
-
-  stopHeartbeat() {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = null;
-    }
-  }
-
-  async attemptReconnect() {
-    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      console.error('❌ 达到最大重连次数');
-      this.emit('max_reconnect_attempts');
-      return;
-    }
-
-    this.reconnectAttempts++;
-    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
-    
-    console.log(`🔄 重连 (${this.reconnectAttempts}/${this.maxReconnectAttempts}) 延迟 ${delay}ms`);
-    
-    await new Promise(r => setTimeout(r, delay));
-    
-    try {
-      await this.connect();
-      console.log('✅ 重连成功');
-    } catch (error) {
-      console.error('❌ 重连失败:', error);
-    }
-  }
-
-  send(data) {
-    const message = JSON.stringify(data);
-    
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(message);
-      return true;
-    } else {
-      // 连接未就绪，缓存消息
-      this.pendingMessages.push(message);
-      return false;
-    }
-  }
-
-  flushPendingMessages() {
-    while (this.pendingMessages.length > 0) {
-      const message = this.pendingMessages.shift();
-      this.ws.send(message);
-    }
-  }
-
-  handleMessage(data) {
-    try {
-      const message = JSON.parse(data);
-      
-      if (message.type === 'pong') {
-        this.lastHeartbeat = Date.now();
-      } else if (message.type === 'ack') {
-        this.emit('ack', message.messageId);
-      } else {
-        this.emit('message', message);
-      }
-    } catch (error) {
-      console.error('解析消息失败:', error);
-    }
-  }
-
-  close() {
-    this.stopHeartbeat();
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-}
-
-// ============================================
-// 2. 状态管理与断点续传
-// ============================================
-
-export class StreamingStateManager {
-  constructor() {
-    this.sessionId = this.generateSessionId();
-    this.currentIndex = 0;
-    this.completedOps = new Set();
-    this.failedOps = new Set();
-    this.operations = [];
-  }
-
-  generateSessionId() {
-    return `stream_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  saveCheckpoint(index, operation, result) {
-    this.currentIndex = index;
-    this.completedOps.add(index);
-    
-    const state = {
-      sessionId: this.sessionId,
-      currentIndex: this.currentIndex,
-      completedOps: Array.from(this.completedOps),
-      failedOps: Array.from(this.failedOps),
-      totalOps: this.operations.length,
-      timestamp: Date.now()
-    };
-    
-    // 持久化（可选）
-    if (typeof localStorage !== 'undefined') {
-      localStorage.setItem(`ppt_stream_${this.sessionId}`, JSON.stringify(state));
-    }
-  }
-
-  restoreState(sessionId) {
-    if (typeof localStorage === 'undefined') return null;
-    
-    const stored = localStorage.getItem(`ppt_stream_${sessionId}`);
-    if (stored) {
-      const state = JSON.parse(stored);
-      this.sessionId = state.sessionId;
-      this.currentIndex = state.currentIndex;
-      this.completedOps = new Set(state.completedOps);
-      this.failedOps = new Set(state.failedOps);
-      return state;
-    }
-    return null;
-  }
-
-  isCompleted(index) {
-    return this.completedOps.has(index);
-  }
-
-  markFailed(index) {
-    this.failedOps.add(index);
-  }
-
-  clearState() {
-    if (typeof localStorage !== 'undefined') {
-      localStorage.removeItem(`ppt_stream_${this.sessionId}`);
-    }
-  }
-
-  getProgress() {
-    return {
-      current: this.currentIndex,
-      completed: this.completedOps.size,
-      failed: this.failedOps.size,
-      total: this.operations.length
-    };
-  }
-}
-
-// ============================================
-// 3. 反压控制
-// ============================================
-
-export class BackpressureController {
-  constructor(options = {}) {
-    this.maxInFlight = options.maxInFlight || 3;
-    this.inFlight = 0;
-    this.queue = [];
-    this.paused = false;
-  }
-
-  async execute(fn) {
-    while (this.inFlight >= this.maxInFlight || this.paused) {
-      await new Promise(resolve => this.queue.push(resolve));
-    }
-
-    this.inFlight++;
-    
-    try {
-      return await fn();
-    } finally {
-      this.inFlight--;
-      this.resume();
-    }
-  }
-
-  pause() {
-    this.paused = true;
-  }
-
-  resume() {
-    if (this.paused) return;
-    
-    while (this.queue.length > 0 && this.inFlight < this.maxInFlight) {
-      const resolve = this.queue.shift();
-      resolve();
-    }
-  }
-
-  getStatus() {
-    return {
-      inFlight: this.inFlight,
-      queued: this.queue.length,
-      paused: this.paused
-    };
-  }
-}
-
-// ============================================
-// 4. 优雅中断处理
-// ============================================
-
-export class GracefulInterrupter {
-  constructor() {
-    this.interrupted = false;
-    this.currentOperation = null;
-    this.completedOps = [];
-  }
-
-  interrupt() {
-    console.log('⚠️ 收到中断请求');
-    this.interrupted = true;
-  }
-
-  shouldInterrupt() {
-    return this.interrupted;
-  }
-
-  async gracefulShutdown(stateManager) {
-    console.log('🔚 开始优雅收尾...');
-    
-    // 等待当前操作完成
-    if (this.currentOperation) {
-      console.log('  ⏳ 等待当前操作完成...');
-      try {
-        await this.currentOperation;
-      } catch (error) {
-        console.log('  ⚠️ 当前操作失败，但继续收尾');
-      }
-    }
-
-    // 保存进度
-    console.log('  💾 保存进度...');
-    const progress = stateManager.getProgress();
-    
-    console.log(`✅ 优雅收尾完成 (已完成 ${progress.completed}/${progress.total})`);
-    
-    return progress;
-  }
-
-  reset() {
-    this.interrupted = false;
-    this.currentOperation = null;
-  }
-}
-
-// ============================================
-// 5. 生产级流式渲染器
-// ============================================
-
-export class ProductionStreamingRenderer extends EventEmitter {
-  constructor(options = {}) {
-    super();
-    
-    // 连接管理
-    this.connection = new StableConnection(
-      options.wsUrl || 'ws://127.0.0.1:39311/ws',
-      options.connection
-    );
-    
-    // 状态管理
-    this.stateManager = new StreamingStateManager();
-    
-    // 性能控制
-    this.backpressure = new BackpressureController(options.backpressure);
-    
-    // 中断处理
-    this.interrupter = new GracefulInterrupter();
-    
-    // 统计
-    this.stats = {
-      operations: 0,
-      successful: 0,
-      failed: 0,
-      retried: 0,
-      totalTime: 0
-    };
-
-    // 监听连接事件
-    this.connection.on('disconnected', () => {
-      this.emit('connection_lost');
-    });
-
-    this.connection.on('connected', () => {
-      this.emit('connection_restored');
-    });
-  }
-
-  /**
-   * 流式编辑（生产级）
-   */
-  async streamEdit(operations, onProgress, options = {}) {
-    const startTime = Date.now();
-    
-    // 保存操作列表
-    this.stateManager.operations = operations;
-    
-    // 连接
-    if (!this.connection.ws || this.connection.ws.readyState !== WebSocket.OPEN) {
-      console.log('🔌 建立 WebSocket 连接...');
-      await this.connection.connect();
-    }
-
-    // 恢复会话（如果指定）
-    if (options.resumeSessionId) {
-      const restored = this.stateManager.restoreState(options.resumeSessionId);
-      if (restored) {
-        console.log(`🔄 恢复会话: ${options.resumeSessionId}`);
-        console.log(`   已完成: ${restored.completedOps.length}/${restored.totalOps}`);
-      }
-    }
-
-    const total = operations.length;
-    let firstOpTime = 0;
-
-    console.log(`\n🎬 开始生产级流式渲染 (${total} 个操作)\n`);
-
-    try {
-      for (let i = 0; i < operations.length; i++) {
-        // 检查中断
-        if (this.interrupter.shouldInterrupt()) {
-          const progress = await this.interrupter.gracefulShutdown(this.stateManager);
-          
-          if (onProgress) {
-            onProgress({
-              ...progress,
-              status: 'interrupted',
-              sessionId: this.stateManager.sessionId,
-              message: '操作已中断，可使用 sessionId 恢复'
-            });
-          }
-          
-          break;
-        }
-
-        // 跳过已完成的操作（断点续传）
-        if (this.stateManager.isCompleted(i)) {
-          console.log(`  ⏭️  跳过已完成 #${i}`);
-          continue;
-        }
-
-        const operation = operations[i];
-        const opStartTime = Date.now();
-
-        // 反压控制
-        await this.backpressure.execute(async () => {
-          this.stats.operations++;
-
-          try {
-            // 乐观更新（立即渲染）
-            this.connection.send({
-              type: 'optimistic_update',
-              index: i,
-              operation: operation.type,
-              data: operation.data,
-              timestamp: Date.now()
-            });
-
-            // 执行实际操作
-            this.interrupter.currentOperation = this._executeOperation(operation);
-            await this.interrupter.currentOperation;
-
-            // 保存检查点
-            this.stateManager.saveCheckpoint(i, operation);
-            this.stats.successful++;
-
-            // 确认更新
-            this.connection.send({
-              type: 'operation_confirmed',
-              index: i,
-              operation: operation.type,
-              success: true
-            });
-
-            // 记录首次操作时间
-            if (i === 0) {
-              firstOpTime = Date.now() - startTime;
-              console.log(`  ⚡ 首次操作: ${firstOpTime}ms`);
-            }
-
-            console.log(`  ✓ #${i} ${operation.type} (${Date.now() - opStartTime}ms)`);
-
-          } catch (error) {
-            this.stats.failed++;
-            this.stateManager.markFailed(i);
-
-            console.error(`  ✗ #${i} ${operation.type} 失败:`, error.message);
-
-            // 回滚更新
-            this.connection.send({
-              type: 'rollback_update',
-              index: i,
-              operation: operation.type
-            });
-
-            // 根据策略决定是否继续
-            if (options.stopOnError) {
-              throw error;
-            }
-          }
-        });
-
-        // 反馈进度
-        if (onProgress) {
-          const progress = this.stateManager.getProgress();
-          onProgress({
-            current: i + 1,
-            total,
-            completed: progress.completed,
-            failed: progress.failed,
-            progress: ((i + 1) / total * 100).toFixed(1),
-            sessionId: this.stateManager.sessionId,
-            backpressure: this.backpressure.getStatus()
-          });
-        }
-
-        // 小延迟让用户看清
-        if (i < operations.length - 1 && !options.noDelay) {
-          await new Promise(r => setTimeout(r, 50));
-        }
-      }
-
-      const totalTime = Date.now() - startTime;
-      this.stats.totalTime = totalTime;
-
-      console.log(`\n✅ 流式渲染完成`);
-      console.log(`   总耗时: ${totalTime}ms`);
-      console.log(`   首次操作: ${firstOpTime}ms`);
-      console.log(`   成功: ${this.stats.successful}`);
-      console.log(`   失败: ${this.stats.failed}\n`);
-
-      // 清理状态
-      this.stateManager.clearState();
-
-      return {
-        success: true,
-        sessionId: this.stateManager.sessionId,
-        stats: this.getStats(),
-        totalTime,
-        firstOpTime
-      };
-
-    } catch (error) {
-      console.error('❌ 流式渲染失败:', error);
-      
-      // 保留状态以便恢复
-      const progress = this.stateManager.getProgress();
-      
-      return {
-        success: false,
-        error: error.message,
-        sessionId: this.stateManager.sessionId,
-        progress,
-        canResume: true
-      };
-    }
-  }
-
-  /**
-   * 执行操作（带重试）
-   */
-  async _executeOperation(operation, retries = 2) {
-    for (let attempt = 0; attempt <= retries; attempt++) {
-      try {
-        // 模拟实际操作
-        await new Promise((resolve, reject) => {
-          setTimeout(() => {
-            // 5% 失败率模拟
-            if (Math.random() < 0.05) {
-              reject(new Error('Operation failed'));
-            } else {
-              resolve();
-            }
-          }, Math.random() * 50 + 30);
-        });
-
-        return;
-      } catch (error) {
-        if (attempt < retries) {
-          this.stats.retried++;
-          console.log(`    🔄 重试 ${attempt + 1}/${retries}`);
-          await new Promise(r => setTimeout(r, 100 * (attempt + 1)));
-        } else {
-          throw error;
-        }
-      }
-    }
-  }
-
-  /**
-   * 中断流式渲染
-   */
-  interrupt() {
-    this.interrupter.interrupt();
-  }
-
-  /**
-   * 暂停/恢复
-   */
-  pause() {
-    this.backpressure.pause();
-    console.log('⏸️  暂停流式渲染');
-  }
-
-  resume() {
-    this.backpressure.resume();
-    console.log('▶️  恢复流式渲染');
-  }
-
-  /**
-   * 获取统计信息
-   */
-  getStats() {
-    return {
-      ...this.stats,
-      successRate: this.stats.operations > 0 ? 
-        (this.stats.successful / this.stats.operations * 100).toFixed(1) + '%' : '0%',
-      avgTime: this.stats.operations > 0 ?
-        (this.stats.totalTime / this.stats.operations).toFixed(0) + 'ms' : '0ms'
-    };
-  }
-
-  /**
-   * 关闭连接
-   */
-  close() {
-    this.connection.close();
-  }
-}
-
-/**
- * 创建生产级流式渲染器
- */
-export function createProductionRenderer(options = {}) {
-  return new ProductionStreamingRenderer(options);
-}