@eyeclaw/eyeclaw 2.3.12 → 2.4.1

package/package.json

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

package/src/websocket-client.ts

@@ -22,12 +22,25 @@ 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 = '' // 累积完整内容用于兜底
+  private lastConnectedAt = 0 // 上次连接成功时间戳
+  private deploymentDetected = false // 是否检测到部署重启
+  private wasConnected = false // 之前是否连接成功过
+  private reconnectTimer: any = null // 重连定时器引用
+  private healthCheckInterval: any = null // 健康检查定时器
+  private serverVersion = '' // 服务器版本（用于检测部署）
+  
+  // 🔥 ACK 机制：追踪已发送和已确认的 chunks
+  private sentChunks = 0 // 已发送的 chunks 数量
+  private ackedChunks = new Set<number>() // 已确认的 chunk 序号集合
 
   constructor(api: OpenClawPluginApi, config: EyeClawConfig, getState: () => any) {
     this.api = api
@@ -56,6 +69,16 @@ export class EyeClawWebSocketClient {
       this.ws.onopen = () => {
         this.api.logger.info('[EyeClaw] WebSocket connected')
         this.reconnectAttempts = 0
+        this.lastConnectedAt = Date.now()
+        this.wasConnected = true
+        
+        // 如果检测到部署重启（之前已连接过），立即触发一次快速心跳
+        if (this.deploymentDetected) {
+          this.api.logger.info('[EyeClaw] 🚀 Deployment recovery detected, sending immediate ping')
+          this.deploymentDetected = false
+          // 延迟 500ms 确保订阅完成后再发心跳
+          setTimeout(() => this.sendPing(), 500)
+        }
       }
 
       this.ws.onmessage = (event) => {
@@ -70,6 +93,13 @@ export class EyeClawWebSocketClient {
         this.api.logger.warn('[EyeClaw] WebSocket disconnected')
         this.subscribed = false
         this.stopPing()
+        
+        // 检测是否是部署导致的断连（之前已成功连接过）
+        if (this.wasConnected && Date.now() - this.lastConnectedAt > 5000) {
+          this.deploymentDetected = true
+          this.api.logger.info('[EyeClaw] 🔄 Deployment detected, will reconnect immediately')
+        }
+        
         this.scheduleReconnect()
       }
 
@@ -84,11 +114,49 @@ export class EyeClawWebSocketClient {
    */
   stop() {
     this.stopPing()
+    this.reconnecting = false
+    this.resetReconnectDelay()
+    
+    // 清理所有定时器
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer)
+      this.reconnectTimer = null
+    }
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval)
+      this.healthCheckInterval = null
+    }
+    
     if (this.ws) {
       this.ws.close()
       this.ws = null
     }
     this.subscribed = false
+    this.wasConnected = 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)
   }
 
   /**
@@ -107,13 +175,13 @@ export class EyeClawWebSocketClient {
 
       // Ping/pong (WebSocket 协议级别的 ping 由浏览器自动响应，无需手动处理)
       if (message.type === 'ping') {
-        this.api.logger.debug('[EyeClaw] Received protocol-level ping (auto-handled by WebSocket)')
+        this.api.logger?.debug?.('[EyeClaw] Received protocol-level ping (auto-handled by WebSocket)')
         return
       }
       
       // 处理 Rails BotChannel 的 pong 响应
       if (message.type === 'pong') {
-        this.api.logger.debug('[EyeClaw] Received pong from server')
+        this.api.logger?.debug?.('[EyeClaw] Received pong from server')
         return
       }
 
@@ -134,6 +202,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 +274,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 +319,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 +364,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 +390,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 +422,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 +435,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 +564,106 @@ export class EyeClawWebSocketClient {
   }
 
   /**
-   * 计划重连
+   * 计划重连（带指数退避、部署感知加速和健康检查）
    */
   private scheduleReconnect() {
+    // 防止重复调度 - 先清理旧定时器
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer)
+      this.reconnectTimer = null
+    }
+    
+    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...')
+      // 不放弃，继续重试（每 30 秒检查一次）
+      this.reconnectTimer = setTimeout(() => {
+        this.reconnecting = false
+        this.resetReconnectDelay()
+        this.scheduleReconnect()
+      }, 30000)
+      return
+    }
+
+    // 🚀 部署恢复场景：立即重连（无延迟）
+    if (this.deploymentDetected) {
+      this.api.logger.info('[EyeClaw] ⚡ Deployment recovery mode: immediate reconnect')
+      this.reconnectTimer = setTimeout(() => {
+        this.reconnecting = false
+        this.start()
+      }, 100) // 100ms 延迟（给服务器一点启动时间）
+      this.deploymentDetected = false // 重置标志
       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.reconnectTimer = setTimeout(() => {
+      this.reconnecting = false
+      this.performHealthCheckAndReconnect()
+    }, delay)
+  }
+  
+  /**
+   * 健康检查后重连
+   */
+  private async performHealthCheckAndReconnect() {
+    try {
+      // 尝试 HTTP 健康检查
+      const serverUrl = this.config.serverUrl.replace(/^http/, 'http') // 使用 http 而非 ws
+      const healthUrl = `${serverUrl}/api/v1/health`
+      
+      const controller = new AbortController()
+      const timeoutId = setTimeout(() => controller.abort(), 3000)
+      
+      const response = await fetch(healthUrl, {
+        method: 'GET',
+        signal: controller.signal,
+      })
+      
+      clearTimeout(timeoutId)
+      
+      if (response.ok) {
+        this.api.logger.info('[EyeClaw] ✅ Health check passed, proceeding with reconnect')
+        this.start()
+      } else {
+        this.api.logger.warn(`[EyeClaw] ⚠️ Health check failed (${response.status}), retrying soon...`)
+        // 健康检查失败，稍后重试
+        this.reconnectTimer = setTimeout(() => {
+          this.reconnecting = false
+          this.scheduleReconnect()
+        }, 2000)
+      }
+    } catch (error) {
+      this.api.logger.warn(`[EyeClaw] ⚠️ Health check error: ${error}, proceeding with reconnect anyway`)
+      // 即使健康检查失败也尝试重连
       this.start()
-    }, this.reconnectDelay)
+    }
+  }
+  
+  /**
+   * 主动发送 ping（用于部署恢复后的快速状态同步）
+   */
+  private sendPing() {
+    const channelIdentifier = JSON.stringify({
+      channel: 'BotChannel',
+      bot_id: this.config.botId,
+    })
+    
+    this.send({
+      command: 'message',
+      identifier: channelIdentifier,
+      data: JSON.stringify({
+        action: 'ping',
+        timestamp: new Date().toISOString(),
+      }),
+    })
   }
 }