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

package/src/services/connection/status-tracker/tracker.ts

@@ -0,0 +1,370 @@
+/**
+ * 状态跟踪器
+ * 核心状态跟踪逻辑，处理所有状态事件并维护状态数据
+ */
+
+import type {
+  ConnectionStatusData,
+  GatewayConnectionInfo,
+} from './types.js';
+import { createEmptyStatusData } from './types.js';
+import { StatusStorage } from './storage.js';
+import {
+  StatusEventType,
+  type StatusEvent,
+  type CloudSocketConnectedData,
+  type CloudSocketDisconnectedData,
+  type CloudSocketErrorData,
+  type CloudSocketRetryData,
+  type GatewayClientConnectedData,
+  type GatewayClientDisconnectedData,
+  type DevicePairingData,
+  type DeviceUnpairingData,
+  type ConnectionStatusChangedData,
+} from './events.js';
+
+/**
+ * 状态跟踪器类
+ */
+export class StatusTracker {
+  private currentStatus: ConnectionStatusData;
+  private storage: StatusStorage;
+  private autoSave: boolean;
+  private saveTimer: NodeJS.Timeout | null;
+
+  constructor(autoSave = true) {
+    this.currentStatus = createEmptyStatusData();
+    this.storage = new StatusStorage();
+    this.autoSave = autoSave;
+    this.saveTimer = null;
+  }
+
+  /**
+   * 处理状态事件
+   */
+  async handleEvent(event: StatusEvent): Promise<void> {
+    const { type, timestamp, data } = event;
+
+    switch (type) {
+      case StatusEventType.CLOUD_SOCKET_CONNECTING:
+        this.handleCloudSocketConnecting(data, timestamp);
+        break;
+
+      case StatusEventType.CLOUD_SOCKET_CONNECTED:
+        this.handleCloudSocketConnected(data, timestamp);
+        break;
+
+      case StatusEventType.CLOUD_SOCKET_DISCONNECTED:
+        this.handleCloudSocketDisconnected(data, timestamp);
+        break;
+
+      case StatusEventType.CLOUD_SOCKET_ERROR:
+        this.handleCloudSocketError(data, timestamp);
+        break;
+
+      case StatusEventType.CLOUD_SOCKET_RETRY:
+        this.handleCloudSocketRetry(data, timestamp);
+        break;
+
+      case StatusEventType.GATEWAY_CLIENT_CONNECTED:
+        this.handleGatewayClientConnected(data, timestamp);
+        break;
+
+      case StatusEventType.GATEWAY_CLIENT_DISCONNECTED:
+        this.handleGatewayClientDisconnected(data, timestamp);
+        break;
+
+      case StatusEventType.DEVICE_PAIRING:
+        this.handleDevicePairing(data, timestamp);
+        break;
+
+      case StatusEventType.DEVICE_UNPAIRING:
+        this.handleDeviceUnpairing(data, timestamp);
+        break;
+
+      case StatusEventType.CONNECTION_STATUS_CHANGED:
+        this.handleConnectionStatusChanged(data, timestamp);
+        break;
+
+      default:
+        console.warn(`[StatusTracker] Unknown event type: ${type}`);
+    }
+
+    // 更新时间戳
+    this.currentStatus.updatedAt = new Date(timestamp).toISOString();
+
+    // 自动保存
+    if (this.autoSave) {
+      this.scheduleSave();
+    }
+  }
+
+  /**
+   * 获取当前状态
+   */
+  getStatus(): ConnectionStatusData {
+    return { ...this.currentStatus };
+  }
+
+  /**
+   * 加载已保存的状态
+   */
+  async loadStatus(): Promise<ConnectionStatusData> {
+    const savedStatus = await this.storage.load();
+    if (savedStatus) {
+      this.currentStatus = savedStatus;
+    }
+    return this.getStatus();
+  }
+
+  /**
+   * 加载并清理状态
+   * 在服务启动时调用，清除临时的连接状态（gateway连接和物理设备）
+   * 保留持久化的状态（云socket状态和连接历史）
+   */
+  async loadAndCleanStatus(): Promise<ConnectionStatusData> {
+    const savedStatus = await this.storage.load();
+    if (savedStatus) {
+      // 保留云socket状态和连接历史
+      const cloudSocketStatus = savedStatus.cloudSocket;
+      const connectionHistory = savedStatus.history;
+
+      // 创建新的空状态
+      this.currentStatus = createEmptyStatusData();
+
+      // 恢复云socket状态
+      this.currentStatus.cloudSocket = cloudSocketStatus;
+
+      // 恢复连接历史
+      this.currentStatus.history = connectionHistory;
+
+      // 重置云socket的连接状态（因为重启后连接会断开）
+      this.currentStatus.cloudSocket.connected = false;
+      this.currentStatus.cloudSocket.readyState = 3; // WebSocket.CLOSED
+
+      // 保存清理后的状态
+      await this.saveStatus();
+    }
+    return this.getStatus();
+  }
+
+  /**
+   * 保存当前状态
+   */
+  async saveStatus(): Promise<void> {
+    await this.storage.save(this.currentStatus);
+  }
+
+  /**
+   * 清除状态
+   */
+  async clearStatus(): Promise<void> {
+    this.currentStatus = createEmptyStatusData();
+    await this.storage.clear();
+  }
+
+  // ==================== 事件处理方法 ====================
+
+  private handleCloudSocketConnecting(data: any, timestamp: number): void {
+    this.currentStatus.cloudSocket.url = data.url || '';
+    this.currentStatus.cloudSocket.connected = false;
+  }
+
+  private handleCloudSocketConnected(
+    data: CloudSocketConnectedData,
+    timestamp: number
+  ): void {
+    this.currentStatus.cloudSocket.connected = true;
+    this.currentStatus.cloudSocket.connectedAt = data.connectedAt;
+    this.currentStatus.cloudSocket.readyState = 1; // WebSocket.OPEN
+    this.currentStatus.cloudSocket.url = data.url;
+    this.currentStatus.cloudSocket.retryCount = 0;
+    this.currentStatus.cloudSocket.lastError = null;
+
+    // 更新连接历史
+    this.currentStatus.history.connectionCount++;
+    this.currentStatus.history.lastConnectionAt = data.connectedAt;
+  }
+
+  private handleCloudSocketDisconnected(
+    data: CloudSocketDisconnectedData,
+    timestamp: number
+  ): void {
+    this.currentStatus.cloudSocket.connected = false;
+    this.currentStatus.cloudSocket.lastDisconnectedAt = data.disconnectedAt;
+    this.currentStatus.cloudSocket.readyState = 3; // WebSocket.CLOSED
+
+    // 更新连接历史
+    this.currentStatus.history.disconnectionCount++;
+    this.currentStatus.history.lastDisconnectionAt = data.disconnectedAt;
+  }
+
+  private handleCloudSocketError(
+    data: CloudSocketErrorData,
+    timestamp: number
+  ): void {
+    this.currentStatus.cloudSocket.lastError = data.error;
+  }
+
+  private handleCloudSocketRetry(
+    data: CloudSocketRetryData,
+    timestamp: number
+  ): void {
+    this.currentStatus.cloudSocket.retryCount = data.retryCount;
+    if (data.lastError) {
+      this.currentStatus.cloudSocket.lastError = data.lastError;
+    }
+  }
+
+  private handleGatewayClientConnected(
+    data: GatewayClientConnectedData,
+    timestamp: number
+  ): void {
+    const connectionInfo: GatewayConnectionInfo = {
+      sessionId: data.sessionId,
+      hardwareDeviceId: data.hardwareDeviceId,
+      connectedAt: data.connectedAt,
+      deviceInfo: data.deviceInfo,
+    };
+
+    // 添加到连接列表
+    this.currentStatus.gateway.connections.push(connectionInfo);
+    this.currentStatus.gateway.totalConnections++;
+    this.currentStatus.gateway.activeConnections++;
+
+    // 更新设备信息
+    this.updateDeviceInfo(data.hardwareDeviceId, data.deviceInfo, timestamp);
+  }
+
+  private handleGatewayClientDisconnected(
+    data: GatewayClientDisconnectedData,
+    timestamp: number
+  ): void {
+    // 从连接列表中移除
+    const index = this.currentStatus.gateway.connections.findIndex(
+      (c) => c.sessionId === data.sessionId
+    );
+
+    if (index !== -1) {
+      this.currentStatus.gateway.connections.splice(index, 1);
+      this.currentStatus.gateway.activeConnections--;
+    }
+
+    // 更新设备信息
+    this.updateDeviceInfo(data.hardwareDeviceId, null, timestamp);
+  }
+
+  private handleDevicePairing(data: DevicePairingData, timestamp: number): void {
+    // 设备配对时更新设备信息
+    this.updateDeviceInfo(data.hardwareDeviceId, data.deviceInfo, timestamp);
+  }
+
+  private handleDeviceUnpairing(
+    data: DeviceUnpairingData,
+    timestamp: number
+  ): void {
+    // 设备取消配对时从设备列表中移除
+    const index = this.currentStatus.devices.devices.findIndex(
+      (d) => d.hardwareDeviceId === data.hardwareDeviceId
+    );
+
+    if (index !== -1) {
+      this.currentStatus.devices.devices.splice(index, 1);
+      this.recalculateDeviceStats();
+    }
+  }
+
+  private handleConnectionStatusChanged(
+    data: ConnectionStatusChangedData,
+    timestamp: number
+  ): void {
+    this.currentStatus.status = data.status;
+  }
+
+  // ==================== 辅助方法 ====================
+
+  /**
+   * 更新设备信息
+   */
+  private updateDeviceInfo(
+    hardwareDeviceId: string,
+    deviceInfo: any,
+    timestamp: number
+  ): void {
+    let device = this.currentStatus.devices.devices.find(
+      (d) => d.hardwareDeviceId === hardwareDeviceId
+    );
+
+    if (!device) {
+      // 创建新设备记录
+      device = {
+        hardwareDeviceId,
+        sessions: 0,
+        lastActiveAt: new Date(timestamp).toISOString(),
+        deviceInfo,
+      };
+      this.currentStatus.devices.devices.push(device);
+    } else {
+      // 更新现有设备记录
+      device.lastActiveAt = new Date(timestamp).toISOString();
+      if (deviceInfo) {
+        device.deviceInfo = deviceInfo;
+      }
+    }
+
+    // 重新计算设备统计
+    this.recalculateDeviceStats();
+  }
+
+  /**
+   * 重新计算设备统计信息
+   */
+  private recalculateDeviceStats(): void {
+    this.currentStatus.devices.totalDevices =
+      this.currentStatus.devices.devices.length;
+    this.currentStatus.devices.uniqueHardwareDevices =
+      this.currentStatus.devices.devices.length;
+
+    // 更新每个设备的会话数
+    for (const device of this.currentStatus.devices.devices) {
+      const sessionCount = this.currentStatus.gateway.connections.filter(
+        (c) => c.hardwareDeviceId === device.hardwareDeviceId
+      ).length;
+      device.sessions = sessionCount;
+    }
+  }
+
+  /**
+   * 调度保存（防抖）
+   */
+  private scheduleSave(): void {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+    }
+
+    this.saveTimer = setTimeout(async () => {
+      try {
+        await this.saveStatus();
+      } catch (error) {
+        console.error(
+          `[StatusTracker] Failed to save status: ${
+            error instanceof Error ? error.message : String(error)
+          }`
+        );
+      }
+    }, 100); // 100ms 防抖
+  }
+
+  /**
+   * 销毁跟踪器
+   */
+  async destroy(): Promise<void> {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+      this.saveTimer = null;
+    }
+
+    // 最后保存一次
+    await this.saveStatus();
+  }
+}

package/src/services/connection/status-tracker/types.ts

@@ -0,0 +1,131 @@
+/**
+ * 状态跟踪类型定义
+ * 定义连接状态的完整数据结构
+ */
+
+/**
+ * 连接状态类型
+ */
+export type ConnectionStatus = 'idle' | 'connecting' | 'connected';
+
+/**
+ * Gateway连接信息
+ */
+export interface GatewayConnectionInfo {
+  sessionId: string;
+  hardwareDeviceId: string;
+  connectedAt: string;
+  deviceInfo: any;
+}
+
+/**
+ * 物理设备信息
+ */
+export interface PhysicalDeviceInfo {
+  hardwareDeviceId: string;
+  sessions: number;
+  lastActiveAt: string;
+  deviceInfo?: any;
+}
+
+/**
+ * 云侧Socket状态信息
+ */
+export interface CloudSocketStatus {
+  connected: boolean;
+  connectedAt: string | null;
+  lastDisconnectedAt: string | null;
+  retryCount: number;
+  lastError: string | null;
+  url: string;
+  readyState: number;
+}
+
+/**
+ * Gateway连接统计
+ */
+export interface GatewayStatus {
+  totalConnections: number;
+  activeConnections: number;
+  connections: GatewayConnectionInfo[];
+}
+
+/**
+ * 物理设备统计
+ */
+export interface DevicesStatus {
+  totalDevices: number;
+  uniqueHardwareDevices: number;
+  devices: PhysicalDeviceInfo[];
+}
+
+/**
+ * 连接历史统计
+ */
+export interface ConnectionHistory {
+  connectionCount: number;
+  disconnectionCount: number;
+  lastConnectionAt: string | null;
+  lastDisconnectionAt: string | null;
+}
+
+/**
+ * 完整的连接状态数据
+ */
+export interface ConnectionStatusData {
+  // 基础状态
+  status: ConnectionStatus;
+  updatedAt: string;
+
+  // 云侧Socket
+  cloudSocket: CloudSocketStatus;
+
+  // Gateway连接
+  gateway: GatewayStatus;
+
+  // 物理设备
+  devices: DevicesStatus;
+
+  // 连接历史
+  history: ConnectionHistory;
+}
+
+/**
+ * 空的连接状态数据（初始化用）
+ */
+export function createEmptyStatusData(): ConnectionStatusData {
+  const now = new Date().toISOString();
+  return {
+    status: 'idle',
+    updatedAt: now,
+
+    cloudSocket: {
+      connected: false,
+      connectedAt: null,
+      lastDisconnectedAt: null,
+      retryCount: 0,
+      lastError: null,
+      url: '',
+      readyState: 3, // WebSocket.CLOSED
+    },
+
+    gateway: {
+      totalConnections: 0,
+      activeConnections: 0,
+      connections: [],
+    },
+
+    devices: {
+      totalDevices: 0,
+      uniqueHardwareDevices: 0,
+      devices: [],
+    },
+
+    history: {
+      connectionCount: 0,
+      disconnectionCount: 0,
+      lastConnectionAt: null,
+      lastDisconnectionAt: null,
+    },
+  };
+}

package/src/types.ts

@@ -45,10 +45,6 @@ export type YoyoPluginConfig = z.infer<typeof YoyoPluginConfigSchema>;
  * 设备信息
  */
 export interface ClawDeviceInfo extends DeviceInfo {
-  /**
-   * claw需要用户信息~
-   */
-  userId: string;
   /**
    * 当前设备的连接状态
    */