@eyeclaw/eyeclaw 2.3.12 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eyeclaw/eyeclaw",
-  "version": "2.3.12",
+  "version": "2.4.0",
   "description": "EyeClaw plugin for OpenClaw - HTTP SSE streaming + WebSocket client",
   "type": "module",
   "main": "./index.ts",

package/src/websocket-client.ts

@@ -22,12 +22,19 @@ export class EyeClawWebSocketClient {
   private config: EyeClawConfig
   private getState: () => any
   private reconnectAttempts = 0
-  private maxReconnectAttempts = 5
-  private reconnectDelay = 3000
+  private maxReconnectAttempts = 10
+  private baseReconnectDelay = 1000 // 1 second
+  private maxReconnectDelay = 30000 // 30 seconds
+  private currentReconnectDelay = 1000
+  private reconnecting = false
   private subscribed = false
   private pingInterval: any = null
   private chunkSequence = 0 // 每个会话的 chunk 序号
   private accumulatedContent = '' // 累积完整内容用于兜底
+  
+  // 🔥 ACK 机制：追踪已发送和已确认的 chunks
+  private sentChunks = 0 // 已发送的 chunks 数量
+  private ackedChunks = new Set<number>() // 已确认的 chunk 序号集合
 
   constructor(api: OpenClawPluginApi, config: EyeClawConfig, getState: () => any) {
     this.api = api
@@ -84,6 +91,8 @@ export class EyeClawWebSocketClient {
    */
   stop() {
     this.stopPing()
+    this.reconnecting = false
+    this.resetReconnectDelay()
     if (this.ws) {
       this.ws.close()
       this.ws = null
@@ -91,6 +100,30 @@ export class EyeClawWebSocketClient {
     this.subscribed = false
   }
 
+  /**
+   * 重置重连延迟
+   */
+  private resetReconnectDelay() {
+    this.currentReconnectDelay = this.baseReconnectDelay
+    this.reconnectAttempts = 0
+  }
+
+  /**
+   * 计算下一次重连延迟（指数退避 + 随机抖动）
+   */
+  private calculateReconnectDelay(): number {
+    // 指数增长: 1s, 2s, 4s, 8s, 16s, 30s (cap)
+    const delay = Math.min(
+      this.currentReconnectDelay * 2,
+      this.maxReconnectDelay
+    )
+    this.currentReconnectDelay = delay
+    
+    // 添加随机抖动 (±25%)
+    const jitter = delay * 0.25 * (Math.random() * 2 - 1)
+    return Math.floor(delay + jitter)
+  }
+
   /**
    * 处理 WebSocket 消息
    */
@@ -134,6 +167,15 @@ export class EyeClawWebSocketClient {
       // 实际消息 - 从 Rails 发送的消息
       if (message.identifier && message.message) {
         const payload = message.message
+        
+        // 🔥 ACK 机制：处理 chunk_received 确认
+        if (payload.type === 'chunk_received') {
+          const sequence = payload.sequence
+          this.ackedChunks.add(sequence)
+          this.api.logger.debug(`[EyeClaw] ✅ Received ACK for chunk #${sequence}, total acked: ${this.ackedChunks.size}/${this.sentChunks}`)
+          return
+        }
+        
         this.handleCommand(payload)
       }
 
@@ -197,8 +239,10 @@ export class EyeClawWebSocketClient {
    * 调用自己的 HTTP 端点 /eyeclaw/chat
    */
   private async processWithOpenClaw(message: string, sessionId?: string, openclawSessionId?: string) {
-    // 重置 chunk 序号（每个新会话）
+    // 重置 chunk 序号和 ACK 计数器（每个新会话）
     this.chunkSequence = 0
+    this.sentChunks = 0
+    this.ackedChunks.clear()
     
     const state = this.getState()
     const gatewayPort = state.gatewayPort
@@ -240,14 +284,12 @@ export class EyeClawWebSocketClient {
       let currentEvent = ''
 
       // 解析 SSE 流式响应
+      let streamEnded = false
+      
       while (true) {
         const { done, value } = await reader.read()
         if (done) {
-          // 流结束，通知 Rails
-          this.sendMessage('stream_end', { session_id: sessionId })
-          
-          // 发送 stream_summary 用于兜底机制
-          this.sendStreamSummary(sessionId)
+          this.api.logger.info(`[EyeClaw] Reader done, stream ended flag: ${streamEnded}`)
           break
         }
 
@@ -287,14 +329,25 @@ export class EyeClawWebSocketClient {
               
               // stream_end 事件：流结束（由 HTTP handler 发送）
               if (currentEvent === 'stream_end') {
-                this.api.logger.info(`[EyeClaw] Stream ended: ${eventData.stream_id}`)
-                // 通知 Rails 流已结束
+                this.api.logger.info(`[EyeClaw] Received stream_end event: ${eventData.stream_id}`)
+                streamEnded = true
+                
+                // 🔥 等待所有 chunks 被确认后再发送 stream_end
+                await this.waitForAllAcks(sessionId)
+                
+                // 发送 stream_end 和 stream_summary
                 this.sendMessage('stream_end', { session_id: sessionId })
+                this.sendStreamSummary(sessionId)
+                
+                // 退出循环
+                return
               }
               
               // stream_error 事件：错误
               if (currentEvent === 'stream_error') {
                 this.api.logger.error(`[EyeClaw] Stream error: ${eventData.error}`)
+                this.sendMessage('stream_error', { error: eventData.error, session_id: sessionId })
+                return
               }
             } catch (e) {
               this.api.logger.warn(`[EyeClaw] Failed to parse SSE data: ${data}`)
@@ -302,6 +355,14 @@ export class EyeClawWebSocketClient {
           }
         }
       }
+      
+      // 如果循环正常结束（没有收到 stream_end 事件），也要等待 ACK
+      if (!streamEnded) {
+        this.api.logger.info(`[EyeClaw] Stream ended without stream_end event, waiting for ACKs`)
+        await this.waitForAllAcks(sessionId)
+        this.sendMessage('stream_end', { session_id: sessionId })
+        this.sendStreamSummary(sessionId)
+      }
 
       this.api.logger.info(`[EyeClaw] Stream processing completed for session: ${sessionId}`)
 
@@ -326,6 +387,7 @@ export class EyeClawWebSocketClient {
   private sendChunk(content: string, sessionId?: string) {
     const timestamp = new Date().toISOString();
     const sequence = this.chunkSequence++;
+    this.sentChunks++; // 🔥 记录已发送数量
     
     // 累积完整内容用于兜底
     this.accumulatedContent += content;
@@ -338,6 +400,51 @@ export class EyeClawWebSocketClient {
     })
   }
   
+  /**
+   * 🔥 等待所有 chunks 被 Rails 确认
+   * 实现 TCP 三次握手的应用层版本
+   * 超时 2 秒后强制返回，依赖 stream_summary 兜底机制
+   */
+  private async waitForAllAcks(sessionId?: string): Promise<void> {
+    const startTime = Date.now()
+    const timeout = 2000 // 2秒超时
+    const checkInterval = 50 // 每 50ms 检查一次
+    
+    this.api.logger.info(`[EyeClaw] 🕒 Waiting for all ACKs: sent=${this.sentChunks}, acked=${this.ackedChunks.size}`)
+    
+    while (this.ackedChunks.size < this.sentChunks) {
+      const elapsed = Date.now() - startTime
+      
+      if (elapsed >= timeout) {
+        const missing = this.sentChunks - this.ackedChunks.size
+        const missingSequences: number[] = []
+        for (let i = 0; i < this.sentChunks; i++) {
+          if (!this.ackedChunks.has(i)) {
+            missingSequences.push(i)
+          }
+        }
+        
+        this.api.logger.warn(
+          `[EyeClaw] ⚠️ ACK timeout after ${elapsed}ms: ` +
+          `sent=${this.sentChunks}, acked=${this.ackedChunks.size}, ` +
+          `missing=${missing}, missing_sequences=[${missingSequences.join(', ')}]`
+        )
+        this.api.logger.info(`[EyeClaw] Relying on stream_summary fallback mechanism`)
+        break
+      }
+      
+      // 等待 50ms 后再检查
+      await new Promise(resolve => setTimeout(resolve, checkInterval))
+    }
+    
+    if (this.ackedChunks.size === this.sentChunks) {
+      const elapsed = Date.now() - startTime
+      this.api.logger.info(
+        `[EyeClaw] ✅ All chunks ACKed: ${this.ackedChunks.size}/${this.sentChunks} in ${elapsed}ms`
+      )
+    }
+  }
+  
   /**
    * 发送 stream_summary 用于兜底机制
    * 告诉 Rails 完整内容是什么，以便检测丢包并补偿
@@ -422,19 +529,33 @@ export class EyeClawWebSocketClient {
   }
 
   /**
-   * 计划重连
+   * 计划重连（带指数退避）
    */
   private scheduleReconnect() {
+    // 防止重复调度
+    if (this.reconnecting) {
+      return
+    }
+    this.reconnecting = true
+    
     if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      this.api.logger.error('[EyeClaw] Max reconnect attempts reached')
+      this.api.logger.error('[EyeClaw] Max reconnect attempts reached, will retry later...')
+      // 不放弃，继续重试（每 60 秒检查一次）
+      setTimeout(() => {
+        this.reconnecting = false
+        this.resetReconnectDelay()
+        this.scheduleReconnect()
+      }, 60000)
       return
     }
 
+    const delay = this.calculateReconnectDelay()
     this.reconnectAttempts++
-    this.api.logger.info(`[EyeClaw] Reconnecting in ${this.reconnectDelay}ms (attempt ${this.reconnectAttempts})`)
+    this.api.logger.info(`[EyeClaw] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`)
 
     setTimeout(() => {
+      this.reconnecting = false
       this.start()
-    }, this.reconnectDelay)
+    }, delay)
   }
 }