@eyeclaw/eyeclaw 2.4.1 → 2.4.3

package/package.json

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

package/src/websocket-client.ts

@@ -29,14 +29,18 @@ export class EyeClawWebSocketClient {
   private reconnecting = false
   private subscribed = false
   private pingInterval: any = null
+  private connectionHealthCheckTimer: 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 = '' // 服务器版本（用于检测部署）
+  private consecutiveFailures = 0 // 连续失败次数
+  private lastCloseCode = 0 // 上次关闭码
+  private networkOnline = true // 网络在线状态
+  private networkCheckTimer: any = null // 网络检测定时器
   
   // 🔥 ACK 机制：追踪已发送和已确认的 chunks
   private sentChunks = 0 // 已发送的 chunks 数量
@@ -59,6 +63,9 @@ export class EyeClawWebSocketClient {
       return
     }
 
+    // 启动网络状态监控
+    this.startNetworkMonitoring()
+
     const wsUrl = serverUrl.replace(/^http/, 'ws') + `/cable?sdk_token=${sdkToken}&bot_id=${botId}`
     this.api.logger.info(`[EyeClaw] WebSocket connecting to: ${wsUrl}`)
 
@@ -69,6 +76,7 @@ export class EyeClawWebSocketClient {
       this.ws.onopen = () => {
         this.api.logger.info('[EyeClaw] WebSocket connected')
         this.reconnectAttempts = 0
+        this.consecutiveFailures = 0 // 重置连续失败计数
         this.lastConnectedAt = Date.now()
         this.wasConnected = true
         
@@ -85,19 +93,60 @@ export class EyeClawWebSocketClient {
         this.handleMessage(event.data)
       }
 
-      this.ws.onerror = (error) => {
-        this.api.logger.error(`[EyeClaw] WebSocket error: ${error}`)
+      this.ws.onerror = (error: any) => {
+        // 尝试提取更详细的错误信息
+        let errorMsg = 'Unknown WebSocket error'
+        
+        // 浏览器环境
+        if (error && typeof error === 'object' && 'message' in error) {
+          errorMsg = (error as any).message || 'ErrorEvent without message'
+          if ((error as any).error) {
+            errorMsg += ` | Error: ${(error as any).error}`
+          }
+        } else if (error) {
+          // Node.js 环境或其他错误
+          errorMsg = String(error)
+        }
+        
+        this.api.logger.error(`[EyeClaw] WebSocket error: ${errorMsg}`)
+        // 网络错误也应该触发重连，而不是等待 onclose
+        // 这样可以更快地从网络中断中恢复
       }
 
       this.ws.onclose = () => {
-        this.api.logger.warn('[EyeClaw] WebSocket disconnected')
+        const closeCode = this.ws?.closeCode || 0
+        const wasClean = closeCode === 1000 || closeCode === 1001
+        
+        this.api.logger.warn(`[EyeClaw] WebSocket closed (code: ${closeCode}, clean: ${wasClean})`)
+        
         this.subscribed = false
         this.stopPing()
+        this.lastCloseCode = closeCode
+        
+        // 统计连续失败
+        this.consecutiveFailures++
         
-        // 检测是否是部署导致的断连（之前已成功连接过）
+        // 检测是否是部署导致的断连（之前已成功连接过，且断开时间 > 5 秒）
+        // 或者关闭码为 1000/1001（正常关闭）但之前已连接
         if (this.wasConnected && Date.now() - this.lastConnectedAt > 5000) {
-          this.deploymentDetected = true
-          this.api.logger.info('[EyeClaw] 🔄 Deployment detected, will reconnect immediately')
+          // 正常关闭或部署重启
+          if (wasClean) {
+            this.deploymentDetected = true
+            this.api.logger.info('[EyeClaw] 🔄 Deployment or clean close detected, will reconnect immediately')
+          } else {
+            // 非正常关闭但之前已连接，很可能是服务器重启
+            this.deploymentDetected = true
+            this.api.logger.info('[EyeClaw] 🔄 Server restart detected (unclean close), will reconnect immediately')
+          }
+        } else if (!this.wasConnected && !wasClean) {
+          // 首次连接失败，增加重试延迟
+          this.api.logger.warn('[EyeClaw] Initial connection failed, increasing delay...')
+        }
+        
+        // 网络断开也会导致 onclose 被调用（code 0）
+        // 检测是否是网络断开（code 0 且非部署场景）
+        if (closeCode === 0 && !this.deploymentDetected) {
+          this.api.logger.info('[EyeClaw] 🌐 Network disconnection detected, will retry with backoff')
         }
         
         this.scheduleReconnect()
@@ -105,15 +154,93 @@ export class EyeClawWebSocketClient {
 
     } catch (error) {
       this.api.logger.error(`[EyeClaw] WebSocket connection failed: ${error}`)
+      // 连接失败也应该触发重连
       this.scheduleReconnect()
     }
   }
 
+  /**
+   * 启动网络状态监控
+   * 定期检测网络是否恢复，以便在网络中断后自动重连
+   */
+  private startNetworkMonitoring() {
+    // 防止重复启动
+    if (this.networkCheckTimer) {
+      return
+    }
+    
+    // 每 5 秒检测一次网络状态
+    this.networkCheckTimer = setInterval(() => {
+      this.checkNetworkAndReconnectIfNeeded()
+    }, 5000)
+    
+    // 尝试立即检测一次
+    this.checkNetworkAndReconnectIfNeeded()
+  }
+
+  /**
+   * 检测网络状态并在需要时触发重连
+   */
+  private async checkNetworkAndReconnectIfNeeded() {
+    // 如果已经在重连中或者 WebSocket 已经连接，跳过
+    if (this.reconnecting || (this.ws && this.ws.readyState === WebSocket.OPEN)) {
+      return
+    }
+    
+    try {
+      // 尝试一个简单的 HTTP 请求来检测网络是否可用
+      const serverUrl = this.config.serverUrl.replace(/^ws/, 'http').replace(/^wss/, 'https')
+      const controller = new AbortController()
+      const timeoutId = setTimeout(() => controller.abort(), 3000)
+      
+      const response = await fetch(`${serverUrl}/api/v1/health`, {
+        method: 'GET',
+        signal: controller.signal,
+      })
+      
+      clearTimeout(timeoutId)
+      
+      const wasOnline = this.networkOnline
+      this.networkOnline = response.ok
+      
+      if (!wasOnline && this.networkOnline) {
+        // 网络从离线变为在线，触发重连
+        this.api.logger.info('[EyeClaw] 🌐 Network restored, triggering immediate reconnect')
+        this.deploymentDetected = true // 使用快速重连模式
+        this.scheduleReconnect()
+      } else if (this.networkOnline && !this.wasConnected) {
+        // 网络在线但未连接过，触发连接
+        this.api.logger.info('[EyeClaw] 🌐 Network available, connecting...')
+        this.scheduleReconnect()
+      }
+    } catch (error) {
+      // 网络请求失败，说明网络不可用
+      const wasOnline = this.networkOnline
+      this.networkOnline = false
+      
+      if (wasOnline) {
+        this.api.logger.warn('[EyeClaw] 🌐 Network became unavailable')
+      }
+      // 网络不可用时，不触发重连，等待下次检测
+    }
+  }
+
+  /**
+   * 停止网络状态监控
+   */
+  private stopNetworkMonitoring() {
+    if (this.networkCheckTimer) {
+      clearInterval(this.networkCheckTimer)
+      this.networkCheckTimer = null
+    }
+  }
+
   /**
    * 停止 WebSocket 连接
    */
   stop() {
     this.stopPing()
+    this.stopNetworkMonitoring() // 停止网络监控
     this.reconnecting = false
     this.resetReconnectDelay()
     
@@ -122,10 +249,7 @@ export class EyeClawWebSocketClient {
       clearTimeout(this.reconnectTimer)
       this.reconnectTimer = null
     }
-    if (this.healthCheckInterval) {
-      clearInterval(this.healthCheckInterval)
-      this.healthCheckInterval = null
-    }
+    // 注意：不再需要清理 healthCheckInterval，因为已合并到 connectionHealthCheckTimer
     
     if (this.ws) {
       this.ws.close()
@@ -141,19 +265,30 @@ export class EyeClawWebSocketClient {
   private resetReconnectDelay() {
     this.currentReconnectDelay = this.baseReconnectDelay
     this.reconnectAttempts = 0
+    // 注意：不重置 consecutiveFailures，因为这是跨会话的统计
   }
 
   /**
-   * 计算下一次重连延迟（指数退避 + 随机抖动）
+   * 计算下一次重连延迟（指数退避 + 随机抖动 + 智能调整）
    */
   private calculateReconnectDelay(): number {
-    // 指数增长: 1s, 2s, 4s, 8s, 16s, 30s (cap)
-    const delay = Math.min(
+    // 基础延迟：1s, 2s, 4s, 8s, 16s, 30s (cap)
+    let delay = Math.min(
       this.currentReconnectDelay * 2,
       this.maxReconnectDelay
     )
     this.currentReconnectDelay = delay
     
+    // 如果连续失败多次，增加额外延迟
+    if (this.consecutiveFailures > 3) {
+      delay = Math.min(delay * 1.5, this.maxReconnectDelay)
+    }
+    
+    // 如果上次关闭码不是正常关闭（1000/1001），增加延迟
+    if (this.lastCloseCode !== 0 && this.lastCloseCode !== 1000 && this.lastCloseCode !== 1001) {
+      delay = Math.min(delay * 1.5, this.maxReconnectDelay)
+    }
+    
     // 添加随机抖动 (±25%)
     const jitter = delay * 0.25 * (Math.random() * 2 - 1)
     return Math.floor(delay + jitter)
@@ -533,8 +668,12 @@ export class EyeClawWebSocketClient {
 
   /**
    * 启动心跳
+   * 心跳间隔设置为 30 秒，比负载均衡器的超时时间短
    */
   private startPing() {
+    this.stopPing() // 先清理旧的心跳定时器
+    
+    // 主心跳：每 30 秒发送一次（比负载均衡器超时短）
     this.pingInterval = setInterval(() => {
       // 调用 Rails BotChannel 的 ping 方法（使用 ActionCable 标准协议）
       const channelIdentifier = JSON.stringify({
@@ -550,7 +689,58 @@ export class EyeClawWebSocketClient {
           timestamp: new Date().toISOString(),
         }),
       })
-    }, 60000) // 60秒心跳一次
+      
+      this.api.logger?.debug?.('[EyeClaw] 🔔 Heartbeat sent')
+    }, 30000) // 30 秒心跳 - 适合负载均衡器
+    
+    // 连接健康检查：每 10 秒检查一次 WebSocket 状态
+    this.connectionHealthCheckTimer = setInterval(() => {
+      this.checkConnectionHealth()
+    }, 10000)
+  }
+
+  /**
+   * 检查 WebSocket 连接健康状态
+   * 如果连接异常，自动触发重连
+   */
+  private checkConnectionHealth() {
+    if (!this.ws) {
+      this.api.logger?.warn?.('[EyeClaw] ⚠️ No WebSocket instance')
+      this.scheduleReconnect()
+      return
+    }
+    
+    const state = this.ws.readyState
+    
+    if (state === WebSocket.CLOSED || state === WebSocket.CLOSING) {
+      this.api.logger?.warn?.(`[EyeClaw] ⚠️ WebSocket state: ${state} (${this.getStateName(state)}), scheduling reconnect`)
+      this.scheduleReconnect()
+      return
+    }
+    
+    // WebSocket.CONNECTING 状态可能持续太久，也需要处理
+    if (state === WebSocket.CONNECTING) {
+      this.api.logger?.warn?.('[EyeClaw] ⚠️ WebSocket stuck in CONNECTING state for too long')
+      // 不立即重连，等待 onclose 触发
+    }
+    
+    // CONNECTED 状态正常
+    if (state === WebSocket.OPEN) {
+      this.api.logger?.debug?.('[EyeClaw] ✅ WebSocket connection healthy')
+    }
+  }
+
+  /**
+   * 获取 WebSocket 状态名称
+   */
+  private getStateName(state: number): string {
+    switch (state) {
+      case WebSocket.CONNECTING: return 'CONNECTING'
+      case WebSocket.OPEN: return 'OPEN'
+      case WebSocket.CLOSING: return 'CLOSING'
+      case WebSocket.CLOSED: return 'CLOSED'
+      default: return 'UNKNOWN'
+    }
   }
 
   /**
@@ -561,6 +751,10 @@ export class EyeClawWebSocketClient {
       clearInterval(this.pingInterval)
       this.pingInterval = null
     }
+    if (this.connectionHealthCheckTimer) {
+      clearInterval(this.connectionHealthCheckTimer)
+      this.connectionHealthCheckTimer = null
+    }
   }
 
   /**
@@ -590,9 +784,9 @@ export class EyeClawWebSocketClient {
       return
     }
 
-    // 🚀 部署恢复场景：立即重连（无延迟）
+    // 🚀 部署恢复场景或网络恢复：立即重连（无延迟）
     if (this.deploymentDetected) {
-      this.api.logger.info('[EyeClaw] ⚡ Deployment recovery mode: immediate reconnect')
+      this.api.logger.info('[EyeClaw] ⚡ Deployment recovery or network restored: immediate reconnect')
       this.reconnectTimer = setTimeout(() => {
         this.reconnecting = false
         this.start()
@@ -601,6 +795,21 @@ export class EyeClawWebSocketClient {
       return
     }
 
+    // 检测是否是网络断开导致的失败（code 0）
+    // 如果是网络断开，不要使用指数退避，而是使用固定间隔重试
+    if (this.lastCloseCode === 0) {
+      // 网络断开场景：每 3 秒尝试一次（有网络后能快速恢复）
+      const networkRetryDelay = 3000
+      this.reconnectAttempts++
+      this.api.logger.info(`[EyeClaw] 🌐 Network disconnection scenario: retrying in ${networkRetryDelay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`)
+      
+      this.reconnectTimer = setTimeout(() => {
+        this.reconnecting = false
+        this.performHealthCheckAndReconnect()
+      }, networkRetryDelay)
+      return
+    }
+
     const delay = this.calculateReconnectDelay()
     this.reconnectAttempts++
     this.api.logger.info(`[EyeClaw] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`)