@honor-claw/yoyo 0.0.1-beta.2 → 0.0.1-beta.21

package/src/cloud-channel/channel.ts

@@ -1,10 +1,12 @@
-import type { ClawChannelConfig, YoyoClawMessage, ClawSocketSourceInfo } from './types.js';
-import { ClawCloudSocketClient } from './client.js';
-import { GatewayClient } from '../gateway-client/client.js';
-import { useClawLogger } from '../utils/logger.js';
-
-const DEFAULT_WS_SERVER_URL =
-  'ws://omni-pre-drcn.hiboard.hihonorcloud.com/aicloud/yoyo-claw-service/v1/yoyoclaw/fullduplex';
+import type {
+  ClawChannelConfig,
+  YoyoClawMessage,
+  DeviceSessionInfo,
+} from "./types.js";
+import { ClawCloudSocketClient } from "./client.js";
+import { GatewayClient } from "../gateway-client/client.js";
+import { useClawLogger } from "../utils/logger.js";
+import { takeApiHost } from "../modules/claw-configs/hosts.js";
 
 /**
  * 新的Channel实现
@@ -15,14 +17,22 @@ const DEFAULT_WS_SERVER_URL =
 export class ClawChannel {
   private cloudClient: ClawCloudSocketClient;
   private gatewayClientsMap = new Map<string, GatewayClient>();
-  private deviceIdToSourceInfoMap = new Map<string, ClawSocketSourceInfo>();
+  private deviceSessionsMap = new Map<string, DeviceSessionInfo[]>();
+  private sessionIdToHardwareDeviceMap = new Map<string, string>();
   private config: ClawChannelConfig;
 
   constructor(config: ClawChannelConfig) {
     this.config = config;
 
+    const hosts = takeApiHost();
+
+    // 如果有灰度标签，设置额外的请求头
+    const extraHeaders = hosts.grayTag ? {
+      'x-gray': hosts.grayTag
+    } : undefined;
+
     this.cloudClient = new ClawCloudSocketClient({
-      serverUrl: DEFAULT_WS_SERVER_URL,
+      serverUrl: `wss://${hosts.clawCloud}/aicloud/yoyo-claw-service/v1/yoyoclaw/fullduplex`,
       deviceInfo: config.deviceInfo,
       userInfo: config.userInfo,
       onMessage: this.handleCloudMessage,
@@ -30,6 +40,8 @@ export class ClawChannel {
       onClose: this.handleCloudClose,
       onRemoteDeviceOffline: this.handleRemoteDeviceOffline,
       onDeviceNotRegistered: this.handleDeviceNotRegistered,
+      extraHeaders,
+      onStatusEvent: this.handleStatusEvent,
     });
   }
 
@@ -37,7 +49,7 @@ export class ClawChannel {
    * 启动连接
    */
   start(): void {
-    useClawLogger().info('[yoyoclaw-channel] starting connection');
+    useClawLogger().info("[yoyoclaw-channel] starting connection");
     this.cloudClient.connect();
   }
 
@@ -45,7 +57,7 @@ export class ClawChannel {
    * 关闭连接
    */
   destroy(): void {
-    useClawLogger().info('[yoyoclaw-channel] closing connection');
+    useClawLogger().info("[yoyoclaw-channel] closing connection");
     this.closeAllGatewayClients();
     this.cloudClient.close();
   }
@@ -54,7 +66,7 @@ export class ClawChannel {
    * 处理云侧连接打开
    */
   private handleCloudOpen = () => {
-    useClawLogger().info('[yoyoclaw-channel] cloud connection established');
+    useClawLogger().info("[yoyoclaw-channel] cloud connection established");
     this.config.onOpen?.();
   };
 
@@ -62,7 +74,7 @@ export class ClawChannel {
    * 处理云侧连接关闭
    */
   private handleCloudClose = () => {
-    useClawLogger().info('[yoyoclaw-channel] cloud connection closed');
+    useClawLogger().info("[yoyoclaw-channel] cloud connection closed");
     this.config.onClose?.();
   };
 
@@ -70,38 +82,38 @@ export class ClawChannel {
    * 处理对向设备离线
    */
   private handleRemoteDeviceOffline = (sourceDeviceId: string) => {
-    // 关闭对应的 GatewayClient 连接
-    const gatewayClient = this.gatewayClientsMap.get(sourceDeviceId);
-    if (gatewayClient) {
-      gatewayClient.stop();
-      this.gatewayClientsMap.delete(sourceDeviceId);
-      this.deviceIdToSourceInfoMap.delete(sourceDeviceId);
-      useClawLogger().info(`[yoyoclaw-channel] closed gateway client for offline device: ${sourceDeviceId}`);
-    } else {
-      useClawLogger().warn(`[yoyoclaw-channel] no gateway client found for offline device: ${sourceDeviceId}`);
-    }
+    this.closeGatewayClient(sourceDeviceId);
   };
 
   /**
    * 处理当前设备未注册
    */
   private handleDeviceNotRegistered = () => {
-    useClawLogger().info('[yoyoclaw-channel] device not registered, notifying connection layer');
+    useClawLogger().info(
+      "[yoyoclaw-channel] device not registered, notifying connection layer"
+    );
     this.config.onDeviceNotRegistered?.();
   };
 
+  /**
+   * 处理状态事件（转发到上层）
+   */
+  private handleStatusEvent = (event: any) => {
+    this.config.onStatusEvent?.(event);
+  };
+
   /**
    * 处理来自云侧的消息
    */
   private handleCloudMessage = (message: YoyoClawMessage) => {
     // 处理配对消息
-    if (message.msgType === 'devicePairMessage') {
+    if (message.msgType === "devicePairMessage") {
       this.handlePairMessage(message);
       return;
     }
 
     // 处理用户消息，转发到对应的GatewayClient
-    if (message.msgType === 'userMessage') {
+    if (message.msgType === "userMessage") {
       this.handleUserMessage(message);
     }
   };
@@ -110,35 +122,109 @@ export class ClawChannel {
    * 处理配对消息，创建GatewayClient连接
    */
   private handlePairMessage(message: YoyoClawMessage): void {
-    if (message.msgType !== 'devicePairMessage') {
+    if (message.msgType !== "devicePairMessage") {
       return;
     }
 
     try {
-      const { sourceDeviceId, sourceDeviceInfo, targetDeviceId, port } = message;
+      const {
+        sourceDeviceId,
+        sourceDeviceInfo,
+        targetDeviceId,
+        port,
+        sessionInfo,
+      } = message;
+
+      if (
+        sourceDeviceId &&
+        targetDeviceId &&
+        port &&
+        sourceDeviceInfo?.deviceId
+      ) {
+        const hardwareDeviceId = sourceDeviceInfo.deviceId;
+        const newTimestamp = sessionInfo?.nodeConnectTimestamp;
+
+        if (!newTimestamp) {
+          // 兜底旧版本，异常场景，暂时不移除旧连接
+          useClawLogger().warn(
+            `[yoyoclaw-channel] pair message missing timestamp for device: ${sourceDeviceId}`
+          );
+        } else {
+          // 关闭该硬件设备ID对应的所有前序 GatewayClient（timestamp 小于新 timestamp）
+          this.closePreviousGatewayClients(hardwareDeviceId, newTimestamp);
+        }
 
-      if (sourceDeviceId && targetDeviceId && port) {
         useClawLogger().info(
-          `[yoyoclaw-channel] received pair message, creating gateway client for device: ${sourceDeviceId}`
+          `[yoyoclaw-channel] received pair message, creating gateway client for device: ${sourceDeviceId}, hardware device: ${hardwareDeviceId}, timestamp: ${newTimestamp}`
         );
 
-        // 保存设备ID对应的源信息
-        this.deviceIdToSourceInfoMap.set(sourceDeviceId, {
-          sourceRole: sourceDeviceInfo?.role ?? 'node',
-          sourceDeviceId: sourceDeviceId,
-          sourceDeviceInfo: sourceDeviceInfo,
+        // 创建会话信息
+        const sessionInfoData: DeviceSessionInfo = {
+          sessionId: sourceDeviceId,
+          timestamp: newTimestamp,
+          sourceInfo: {
+            sourceRole: sourceDeviceInfo?.role ?? "node",
+            sourceDeviceId: sourceDeviceId,
+            sourceDeviceInfo: sourceDeviceInfo,
+          },
+        };
+
+        // 保存会话信息
+        const sessions = this.deviceSessionsMap.get(hardwareDeviceId) || [];
+        sessions.push(sessionInfoData);
+        this.deviceSessionsMap.set(hardwareDeviceId, sessions);
+        this.sessionIdToHardwareDeviceMap.set(sourceDeviceId, hardwareDeviceId);
+
+        // 通知状态跟踪器：设备配对
+        this.config.onStatusEvent?.({
+          type: "device_pairing",
+          timestamp: Date.now(),
+          data: {
+            sessionId: sourceDeviceId,
+            hardwareDeviceId: hardwareDeviceId,
+            deviceInfo: sourceDeviceInfo,
+            pairedAt: new Date().toISOString(),
+          },
         });
 
         // 创建GatewayClient
         const gatewayClient = new GatewayClient({
           onOpen: () => {
-            useClawLogger().info(`[yoyoclaw-channel] gateway client connected for device: ${sourceDeviceId}`);
+            useClawLogger().info(
+              `[yoyoclaw-channel] gateway client connected for device: ${sourceDeviceId}`
+            );
+
+            // 通知状态跟踪器：Gateway连接成功
+            this.config.onStatusEvent?.({
+              type: "gateway_client_connected",
+              timestamp: Date.now(),
+              data: {
+                sessionId: sourceDeviceId,
+                hardwareDeviceId: hardwareDeviceId,
+                deviceInfo: sourceDeviceInfo,
+                connectedAt: new Date().toISOString(),
+              },
+            });
           },
-          onMessage: data => {
+          onMessage: (data) => {
             this.handleGatewayMessage(sourceDeviceId, data);
           },
-          onClose: () => {
-            useClawLogger().info(`[yoyoclaw-channel] gateway client closed for device: ${sourceDeviceId}`);
+          onClose: (reason) => {
+            useClawLogger().info(
+              `[yoyoclaw-channel] gateway client closed for device: ${sourceDeviceId}, with ${reason}`
+            );
+
+            // 通知状态跟踪器：Gateway连接断开
+            this.config.onStatusEvent?.({
+              type: "gateway_client_disconnected",
+              timestamp: Date.now(),
+              data: {
+                sessionId: sourceDeviceId,
+                hardwareDeviceId: hardwareDeviceId,
+                reason: reason,
+                disconnectedAt: new Date().toISOString(),
+              },
+            });
           },
         });
 
@@ -146,7 +232,9 @@ export class ClawChannel {
         gatewayClient.start();
       }
     } catch (error) {
-      useClawLogger().error(`[yoyoclaw-channel] failed to handle pair message: ${String(error)}`);
+      useClawLogger().error(
+        `[yoyoclaw-channel] failed to handle pair message: ${String(error)}`
+      );
     }
   }
 
@@ -155,24 +243,38 @@ export class ClawChannel {
    */
   private handleUserMessage(message: YoyoClawMessage): void {
     if (!message.sourceDeviceId) {
-      useClawLogger().warn('[yoyoclaw-channel] user message missing sourceDeviceId');
+      useClawLogger().warn(
+        "[yoyoclaw-channel] user message missing sourceDeviceId"
+      );
       return;
     }
 
+    const hardwareDeviceId = this.sessionIdToHardwareDeviceMap.get(
+      message.sourceDeviceId
+    );
+
     try {
       const gatewayClient = this.gatewayClientsMap.get(message.sourceDeviceId);
       if (!gatewayClient) {
-        useClawLogger().warn(`[yoyoclaw-channel] no gateway client found for source device: ${message.sourceDeviceId}`);
+        useClawLogger().warn(
+          `[yoyoclaw-channel] no gateway client found for source device: ${hardwareDeviceId}, session: ${message.sourceDeviceId}`
+        );
         return;
       }
 
       // 只发送data部分
       if (message.data) {
-        useClawLogger().info(`[yoyoclaw-channel] forwarding user message to gateway from ${message.sourceDeviceId}`);
+        useClawLogger().info(
+          `[yoyoclaw-channel] forwarding user message to gateway from ${hardwareDeviceId}, session: ${message.sourceDeviceId}`
+        );
         gatewayClient.send(message.data);
       }
     } catch (error) {
-      useClawLogger().error(`[yoyoclaw-channel] failed to handle user message: ${String(error)}`);
+      useClawLogger().error(
+        `[yoyoclaw-channel] failed to send gateway message to ${hardwareDeviceId}: ${String(
+          error
+        )}, session: ${message.sourceDeviceId}`
+      );
     }
   }
 
@@ -180,39 +282,62 @@ export class ClawChannel {
    * 处理来自Gateway的消息，转发到云侧
    */
   private handleGatewayMessage(sourceDeviceId: string, data: string): void {
-    const sourceInfo = this.deviceIdToSourceInfoMap.get(sourceDeviceId);
+    const hardwareDeviceId =
+      this.sessionIdToHardwareDeviceMap.get(sourceDeviceId);
+    if (!hardwareDeviceId) {
+      useClawLogger().warn(
+        `[yoyoclaw-channel] gateway source node offline, session: ${sourceDeviceId}`
+      );
+      return;
+    }
 
-    if (!sourceInfo) {
-      useClawLogger().warn('[yoyoclaw-channel] gateway source node offline');
+    const sessions = this.deviceSessionsMap.get(hardwareDeviceId);
+    const sessionInfo = sessions?.find((s) => s.sessionId === sourceDeviceId);
+
+    if (!sessionInfo) {
+      useClawLogger().warn(
+        `[yoyoclaw-channel] gateway source node offline, session: ${sourceDeviceId}`
+      );
       return;
     }
 
+    useClawLogger().debug?.(
+      `[yoyoclaw-channel] received gateway message from ${
+        sessionInfo.sourceInfo.sourceDeviceInfo?.deviceId
+      } to cloud:, ${data.slice(0, 1000)}`
+    );
+
     try {
       // 将Gateway的消息封装成YoyoClawMessage发送到云侧
       // 使用当前接收到的socket对应deviceId的来源信息
       const cloudMessage: YoyoClawMessage = {
-        msgType: 'userMessage',
-        sourceRole: 'yoyoclaw',
+        msgType: "userMessage",
+        sourceRole: "yoyoclaw",
         sourceDeviceId: this.config.deviceInfo.deviceId,
-        targetRole: 'node',
-        targetDeviceId: sourceInfo.sourceDeviceId,
+        targetRole: "node",
+        targetDeviceId: sessionInfo.sourceInfo.sourceDeviceId,
         port: this.config.deviceInfo.port,
         data,
       };
 
-      const result = this.cloudClient.send(cloudMessage);
+      const result = this.cloudClient.send(
+        cloudMessage,
+        sessionInfo.sourceInfo.sourceDeviceInfo?.deviceId
+      );
 
       if (!result) {
         // 云socket挂了，这个gateway连接就需要取消掉
         // 最好不要一次性把所有的gateway连接都干掉，让惰性关闭
         useClawLogger().error(
-          `[yoyoclaw-channel] failed to send message, cloud socket closed, from: ${sourceInfo.sourceDeviceId}`
+          `[yoyoclaw-channel] failed to send message, cloud socket closed, from: ${sessionInfo.sourceInfo.sourceDeviceId}`
         );
 
-        this.handleRemoteDeviceOffline(sourceInfo.sourceDeviceId);
+        this.handleRemoteDeviceOffline(sessionInfo.sourceInfo.sourceDeviceId);
       }
     } catch (error) {
-      useClawLogger().error(`[yoyoclaw-channel] failed to handle gateway message: ${String(error)}`);
+      useClawLogger().error(
+        `[yoyoclaw-channel] failed to handle gateway message: ${String(error)}`
+      );
     }
   }
 
@@ -220,11 +345,73 @@ export class ClawChannel {
    * 关闭所有GatewayClient连接
    */
   private closeAllGatewayClients(): void {
-    for (const [deviceId, client] of this.gatewayClientsMap.entries()) {
+    for (const [sessionId, client] of this.gatewayClientsMap.entries()) {
       client.stop();
-      useClawLogger().info(`[yoyoclaw-channel] closed gateway client for device: ${deviceId}`);
+      useClawLogger().info(
+        `[yoyoclaw-channel] closed gateway client for session: ${sessionId}`
+      );
     }
     this.gatewayClientsMap.clear();
-    this.deviceIdToSourceInfoMap.clear();
+    this.deviceSessionsMap.clear();
+    this.sessionIdToHardwareDeviceMap.clear();
+  }
+
+  /**
+   * 关闭硬件设备的所有前序 GatewayClient（timestamp 小于指定值）
+   */
+  private closePreviousGatewayClients(
+    hardwareDeviceId: string,
+    newTimestamp: number
+  ): void {
+    const sessions = this.deviceSessionsMap.get(hardwareDeviceId);
+    if (!sessions || sessions.length === 0) {
+      return;
+    }
+
+    // 找出所有 timestamp 小于新 timestamp 的会话
+    const previousSessions = sessions.filter((s) => s.timestamp < newTimestamp);
+
+    if (previousSessions.length > 0) {
+      useClawLogger().info(
+        `[yoyoclaw-channel] closing ${previousSessions.length} previous gateway client(s) for hardware device: ${hardwareDeviceId}, new timestamp: ${newTimestamp}`
+      );
+
+      for (const session of previousSessions) {
+        this.closeGatewayClient(session.sessionId);
+      }
+    }
+  }
+
+  /**
+   * 关闭单个 GatewayClient
+   */
+  private closeGatewayClient(sessionId: string): void {
+    const gatewayClient = this.gatewayClientsMap.get(sessionId);
+    if (gatewayClient) {
+      gatewayClient.stop();
+      this.gatewayClientsMap.delete(sessionId);
+
+      // 从会话映射中移除
+      const hardwareDeviceId = this.sessionIdToHardwareDeviceMap.get(sessionId);
+      if (hardwareDeviceId) {
+        const sessions = this.deviceSessionsMap.get(hardwareDeviceId);
+        if (sessions) {
+          const index = sessions.findIndex((s) => s.sessionId === sessionId);
+          if (index !== -1) {
+            sessions.splice(index, 1);
+          }
+
+          // 如果没有会话了，清理该硬件设备的记录
+          if (sessions.length === 0) {
+            this.deviceSessionsMap.delete(hardwareDeviceId);
+          }
+        }
+        this.sessionIdToHardwareDeviceMap.delete(sessionId);
+      }
+
+      useClawLogger().info(
+        `[yoyoclaw-channel] closed gateway client for session: ${sessionId}`
+      );
+    }
   }
 }

package/src/cloud-channel/client.ts

@@ -2,7 +2,6 @@
  * WebSocket Client 实现
  * 使用轻量级的 ws 库连接到远程服务器
  */
-
 import WebSocket from "ws";
 import type {
   ClawSocketClientOptions,
@@ -11,8 +10,8 @@ import type {
 } from "./types.js";
 import { createWebSocketProxyAgent } from "../utils/proxy.js";
 import { generateAuthorization } from "../utils/jwt.js";
-import { rawDataToString } from "openclaw/plugin-sdk";
 import { useClawLogger } from "../utils/logger.js";
+import { rawDataToString } from "../utils/ws.js";
 
 const PING_INTERVAL = 30000;
 const MAX_RETRIES = 5;
@@ -44,12 +43,21 @@ export class ClawCloudSocketClient {
     // 清除可能存在的重试定时器
     this.clearRetryTimer();
 
-    const { serverUrl, port, deviceInfo, userInfo } = this.options;
+    const { serverUrl, port, deviceInfo, userInfo, extraHeaders } = this.options;
 
     // 确保 URL 包含路由
     let url = serverUrl.replace(/\/$/, "");
     url = port ? `${url}:${port}` : url;
 
+    // 通知状态跟踪器：开始连接
+    this.options.onStatusEvent?.({
+      type: "cloud_socket_connecting",
+      timestamp: Date.now(),
+      data: {
+        url: url,
+      },
+    });
+
     // 构建请求头
     const headers: Record<string, string> = {
       ["x-role"]: "yoyoclaw",
@@ -68,6 +76,11 @@ export class ClawCloudSocketClient {
       headers["x-port"] = String(deviceInfo.port);
     }
 
+    // 添加额外的请求头（如灰度标签）
+    if (extraHeaders) {
+      Object.assign(headers, extraHeaders);
+    }
+
     // 配置代理，优先使用配置的 proxy，否则使用环境变量
     const agent = createWebSocketProxyAgent(url);
     const options: WebSocket.ClientOptions = { headers };
@@ -80,7 +93,9 @@ export class ClawCloudSocketClient {
 
     this.ws.on("open", () => {
       const connectionType = isRetry ? "reconnected" : "connected";
-      useClawLogger().info(`[claw-cloud-socket] ${connectionType} to ${url}`);
+      useClawLogger().info(
+        `[claw-cloud-socket] ${connectionType} to ${url.slice(0, 15)}`
+      );
 
       // 清除重试定时器
       this.clearRetryTimer();
@@ -90,6 +105,16 @@ export class ClawCloudSocketClient {
       // 启动 ping 定时器
       this.startPingTimer();
 
+      // 通知状态跟踪器
+      this.options.onStatusEvent?.({
+        type: "cloud_socket_connected",
+        timestamp: Date.now(),
+        data: {
+          url: url,
+          connectedAt: new Date().toISOString(),
+        },
+      });
+
       this.options.onOpen?.();
     });
 
@@ -106,10 +131,22 @@ export class ClawCloudSocketClient {
     });
 
     this.ws.on("close", (code: number, reason: Buffer) => {
+      const reasonText = reason.toString();
       useClawLogger().info(
-        `[claw-cloud-socket] connection closed: ${code} - ${reason.toString()}`
+        `[claw-cloud-socket] connection closed: ${code} - ${reasonText}`
       );
 
+      // 通知状态跟踪器
+      this.options.onStatusEvent?.({
+        type: "cloud_socket_disconnected",
+        timestamp: Date.now(),
+        data: {
+          reason: reasonText,
+          code: code,
+          disconnectedAt: new Date().toISOString(),
+        },
+      });
+
       // 如果不是手动关闭，尝试重连
       if (!this.isManualClose) {
         this.scheduleReconnect();
@@ -123,13 +160,23 @@ export class ClawCloudSocketClient {
       useClawLogger().error(
         `[claw-cloud-socket] connect errorred: ${error.message}`
       );
+
+      // 通知状态跟踪器
+      this.options.onStatusEvent?.({
+        type: "cloud_socket_error",
+        timestamp: Date.now(),
+        data: {
+          error: error.message,
+          timestamp: new Date().toISOString(),
+        },
+      });
     });
   }
 
   /**
    * 发送消息
    */
-  send(message: YoyoClawMessage): boolean {
+  send(message: YoyoClawMessage, toDeviceId?: string): boolean {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       useClawLogger().error(
         "[claw-cloud-socket] cannot send message: connection not open"
@@ -138,11 +185,21 @@ export class ClawCloudSocketClient {
     }
 
     try {
-      this.ws.send(JSON.stringify(message));
+      const msgText = JSON.stringify(message);
+
+      useClawLogger().debug?.(
+        `[yoyoclaw-cloud] send message to cloud session ${
+          message.targetDeviceId
+        }, device: ${toDeviceId}:, ${msgText.slice(0, 1000)}`
+      );
+
+      this.ws.send(msgText);
       return true;
     } catch (error) {
       useClawLogger().error(
-        `[claw-cloud-socket] failed to send message: ${
+        `[claw-cloud-socket] failed to send message to cloud session ${
+          message.targetDeviceId
+        }, device: ${toDeviceId}: ${
           error instanceof Error ? error.message : String(error)
         }`
       );
@@ -182,11 +239,19 @@ export class ClawCloudSocketClient {
       const message: YoyoClawSocketMessage = JSON.parse(dataText);
 
       useClawLogger().debug?.(
-        `[yoyoclaw-channel] received cloud message: ${dataText.slice(0, 500)}`
+        `[yoyoclaw-channel] received cloud message from session ${
+          message.wsOutputEvent?.sourceDeviceId
+        }, deviceId ${
+          message.wsOutputEvent?.sourceDeviceInfo?.deviceId
+        }: ${dataText.slice(0, 1000)}`
       );
 
       if (message.code === "YOYO_CLAW_100000") {
         if (message.wsOutputEvent) {
+          // 将 sessionInfo 从 wrapper 复制到 message 中
+          if (message.sessionInfo) {
+            message.wsOutputEvent.sessionInfo = message.sessionInfo;
+          }
           this.options.onMessage?.(message.wsOutputEvent);
           return;
         }
@@ -194,7 +259,7 @@ export class ClawCloudSocketClient {
         // 对向设备离线，当前设备对应的gateway连接都可以销毁掉
         if (message.extData?.offlineSocketId) {
           useClawLogger().info(
-            `[claw-cloud-socket] remote device offline: ${message.extData.offlineSocketId}`
+            `[claw-cloud-socket] remote device offline, session: ${message.extData.offlineSocketId}`
           );
           this.options.onRemoteDeviceOffline?.(message.extData.offlineSocketId);
 
@@ -259,6 +324,17 @@ export class ClawCloudSocketClient {
       `[claw-cloud-socket] scheduling reconnect attempt ${this.retryCount}/${MAX_RETRIES} in ${delay}ms`
     );
 
+    // 通知状态跟踪器：重试
+    this.options.onStatusEvent?.({
+      type: "cloud_socket_retry",
+      timestamp: Date.now(),
+      data: {
+        retryCount: this.retryCount,
+        maxRetries: MAX_RETRIES,
+        delay: delay,
+      },
+    });
+
     this.retryTimer = setTimeout(() => {
       this.connect(true);
     }, delay);
@@ -279,8 +355,7 @@ export class ClawCloudSocketClient {
    */
   private calculateRetryDelay(): number {
     const delay =
-      START_RETRY_DELAY *
-      Math.pow(RETRY_BACKOFF_FACTOR, this.retryCount - 1);
+      START_RETRY_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, this.retryCount - 1);
     return Math.min(delay, MAX_RETRY_DELAY);
   }