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

package/src/modules/device/providers/pad.ts

@@ -67,22 +67,6 @@ export class PadDevice implements DeviceInfoProvider {
     return this.getAndroidDeviceModel();
   }
 
-  /**
-   * 获取 Android 品牌
-   */
-  private getAndroidBrand(): string {
-    const brand = this.getAndroidProp('ro.product.brand');
-    return brand || 'Android';
-  }
-
-  /**
-   * 获取 Android 系统版本
-   */
-  private getAndroidSysVersion(): string {
-    const version = this.getAndroidProp('ro.honor.build.display.id');
-    return version || 'Android';
-  }
-
   /**
    * 获取设备唯一ID
    */

package/src/modules/device/registry.ts

@@ -1,7 +1,7 @@
 import { createClawCloudClient } from '../../apis/claw-cloud.js';
 import { isOKResponse } from '../../apis/index.js';
 import type { DeviceInfo, HonorUserInfo } from '../../types.js';
-import { getConfigManager } from '../claw-configs/index.js';
+import { getConfigManager, takeApiHost } from '../claw-configs/index.js';
 
 /**
  * 注册设备到 Claw Cloud
@@ -17,8 +17,17 @@ export async function registerDevice(deviceInfo: DeviceInfo, userInfo: HonorUser
     const gatewayAuthConfig = configManager.getGatewayAuthConfig();
 
     // 创建 Claw Cloud 客户端
-    const baseUrl = 'http://omni-pre-drcn.hiboard.hihonorcloud.com/aicloud/yoyo-claw-service';
-    const client = createClawCloudClient(baseUrl);
+    const hosts = takeApiHost();
+    const baseUrl = `https://${hosts.clawCloud}/aicloud/yoyo-claw-service`;
+    
+    // 如果有灰度标签，设置默认headers
+    const options = hosts.grayTag ? {
+      defaultHeaders: {
+        'x-gray': hosts.grayTag
+      }
+    } : undefined;
+    
+    const client = createClawCloudClient(baseUrl, options);
 
     // 调用注册接口，传入认证信息
     const response = await client.registerDevice(deviceInfo, userInfo, gatewayAuthConfig);

package/src/modules/login/impl.ts

@@ -5,6 +5,7 @@ import { performOAuth2AuthWithBrowser } from "../../honor-auth/index.js";
 import { getDeviceInfo, registerDevice } from "../device/index.js";
 import type { HonorUserInfo } from "../../types.js";
 import { saveToken } from "../../honor-auth/token-manager.js";
+import { useClawLogger } from "../../utils/logger.js";
 
 /**
  * 登录选项
@@ -12,6 +13,10 @@ import { saveToken } from "../../honor-auth/token-manager.js";
 export interface LoginOptions {
   /** 是否跳过认证流程，默认为 false */
   noAuth?: boolean;
+  /** 用户ID，如果提供则直接使用此ID登录 */
+  userId?: string;
+  /** Token，如果提供则直接使用此Token登录 */
+  token?: string;
 }
 
 /**
@@ -23,16 +28,33 @@ export interface LoginOptions {
  * @param options 登录选项
  */
 export async function performLogin(options: LoginOptions = {}) {
-  const { noAuth = false } = options;
+  const { noAuth = false, userId, token } = options;
+  const logger = useClawLogger();
   try {
-    console.log("🚀 开始登录流程...");
+    logger.debug("Starting login process...");
 
     // 步骤1: 调用 honor-auth 进行 OAuth2 认证
     const deviceInfo = getDeviceInfo();
-    
+
     let userInfo: HonorUserInfo;
-    if (noAuth) {
-      console.log("🔓 跳过 OAuth2 认证，使用测试用户信息...");
+    // 检查是否提供了 userId 和 token 参数
+    if (userId && token) {
+      logger.debug("Using provided userId and token for direct login...");
+      userInfo = {
+        userId,
+        token,
+      };
+
+      // 保存Token，displayName 使用空字符串
+      await saveToken({
+        token,
+        userInfo: { userId, displayName: "" },
+      });
+      logger.debug("Using provided user info");
+      logger.debug(`User: ${userInfo.userId}`);
+      logger.debug(`Device ID: ${deviceInfo?.deviceId}`);
+    } else if (noAuth) {
+      logger.debug("Skipping OAuth2 auth, using test user info...");
       userInfo = {
         userId: "test",
         token: "",
@@ -43,28 +65,28 @@ export async function performLogin(options: LoginOptions = {}) {
         token: "test",
         userInfo: { userId: "test", displayName: "Test User" },
       });
-      console.log("✅ 使用测试用户信息");
-      console.log(`👤 用户: ${userInfo.userId}`);
-      console.log(`📱 设备ID: ${deviceInfo?.deviceId}`);
+      logger.debug("Using test user info");
+      logger.debug(`User: ${userInfo.userId}`);
+      logger.debug(`Device ID: ${deviceInfo?.deviceId}`);
     } else {
-      console.log("📱 正在启动 OAuth2 认证...");
+      logger.debug("Starting OAuth2 authentication...");
       userInfo = await performOAuth2AuthWithBrowser(deviceInfo);
 
-      console.log("✅ OAuth2 认证成功");
-      console.log(`👤 用户: ${userInfo?.userId || "Unknown"}`);
-      console.log(`📱 设备ID: ${deviceInfo?.deviceId}`);
+      logger.debug("OAuth2 authentication successful");
+      logger.debug(`User: ${userInfo?.userId || "Unknown"}`);
+      logger.debug(`Device ID: ${deviceInfo?.deviceId}`);
     }
 
     // 步骤2: 调用 claw-cloud 注册接口
-    console.log("📡 正在注册设备到 Claw Cloud...");
+    console.log("📡 Registering device to Claw Cloud...");
     await registerDevice(deviceInfo, userInfo);
 
-    console.log("✅ 设备注册成功");
+    console.log("✅ Device registered successfully");
 
     // 步骤3: 这里就不再处理建联了，等待主进程轮询到配置后进行建联
-    console.log("🔗 Channel 建立中，可通过 openclaw honor status 查看设备状态");
+    console.log("🔗 Channel connection in progress, use 'openclaw honor status' to check device status");
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error("❌ 登录流程失败:", errorMessage);
+    console.error("❌ Login process failed:", errorMessage);
   }
 }

package/src/runtime.ts

@@ -1,4 +1,5 @@
 import type { PluginRuntime } from "openclaw/plugin-sdk";
+import { getConfigManager } from "./modules/claw-configs/config-manager.js";
 
 let runtime: PluginRuntime | null = null;
 
@@ -12,3 +13,46 @@ export function getYoyoRuntime(): PluginRuntime {
   }
   return runtime;
 }
+
+/**
+ * Yoyo 环境类型
+ */
+export type YoyoEnv = "test" | "production" | "dev";
+
+/**
+ * 获取当前运行环境
+ * 从配置文件动态读取环境信息
+ */
+export function getYoyoEnv(): YoyoEnv {
+  try {
+    const configManager = getConfigManager();
+    return configManager.getEnv();
+  } catch (error) {
+    console.error(`[runtime] Failed to get env from config: ${error}`);
+    return "production"; // 默认返回生产环境
+  }
+}
+
+/**
+ * 获取环境信息（包括环境和平灰度标签）
+ */
+export interface YoyoEnvInfo {
+  env: YoyoEnv;
+  grayTag?: string;
+}
+
+/**
+ * 获取完整的运行环境信息
+ */
+export function getYoyoEnvInfo(): YoyoEnvInfo {
+  try {
+    const configManager = getConfigManager();
+    return {
+      env: configManager.getEnv(),
+      grayTag: configManager.getGrayTag(),
+    };
+  } catch (error) {
+    console.error(`[runtime] Failed to get env info from config: ${error}`);
+    return { env: "production" };
+  }
+}

package/src/schemas.ts

@@ -16,5 +16,8 @@ const UserInfoSchema = z.object({
  */
 export const YoyoPluginConfigSchema = z.object({
   user: UserInfoSchema.optional(),
+  /** 运行环境：test 或 production */
+  env: z.enum(['dev', 'test', 'production']).optional(),
+  // 灰度标签
+  gray: z.string().optional(),
 });
-

package/src/services/connection/impl.ts

@@ -1,10 +1,13 @@
-import { OpenClawPluginService } from "openclaw/plugin-sdk";
+import { OpenClawPluginApi, OpenClawPluginService } from "openclaw/plugin-sdk";
 import { ClawChannel } from "../../cloud-channel/channel.js";
 import { useClawLogger } from "../../utils/logger.js";
 import { ClawConnection, type ConnectionStatus } from "./types.js";
 import { loadToken, clearToken } from "../../honor-auth/token-manager.js";
 import { getDeviceInfo, registerDevice } from "../../modules/device/index.js";
 import { DeviceInfo, HonorUserInfo } from "../../types.js";
+import { getConfigManager } from "../../modules/claw-configs/config-manager.js";
+import { copyTemplateToWorkspace } from "../../agent/copy-templates.js";
+import { StatusTracker, StatusEventType } from "./status-tracker/index.js";
 
 const clawConnection: ClawConnection = {
   channel: null,
@@ -14,20 +17,50 @@ const clawConnection: ClawConnection = {
 let pollTimer: NodeJS.Timeout | null = null;
 let pollInterval = 5000; // 初始轮询间隔 5 秒
 
+// 状态跟踪器实例
+let statusTracker: StatusTracker | null = null;
+
 /**
  * claw connection的连接管理服务入口
  *
  * 维护一个全局的channel，配合各个命令行、服务时机调用
  */
-export const ClawConnectionService: OpenClawPluginService = {
+export const createClawConnectionService = (api: OpenClawPluginApi) => ({
   id: "yoyoclaw-connection",
   async start() {
     useClawLogger().info("[yoyoclaw] plugin service enabled");
 
+    // 初始化状态跟踪器
+    statusTracker = new StatusTracker(true);
+    try {
+      // 加载并清理状态：清除临时的gateway连接和物理设备数据
+      await statusTracker.loadAndCleanStatus();
+      useClawLogger().info("[yoyoclaw-conn] status tracker initialized and cleaned");
+    } catch (error) {
+      useClawLogger().warn(
+        `[yoyoclaw-conn] failed to load saved status: ${String(error)}`
+      );
+    }
+
     // 启动轮询机制
     startPolling();
+
+    // 复制智能体模板到工作目录
+    copyTemplateToWorkspace(api);
+    useClawLogger().debug?.(`[yoyoclaw] agents: ${JSON.stringify(api.config.agents?.defaults)}`);
+
+    // 修改配置文件，配置`plugins.allow`和`gateway.nodes.allowCommands`
+    try {
+      const configManager = getConfigManager();
+      await configManager.initializePluginConfig("yoyo");
+      useClawLogger().info("[yoyoclaw] plugin config initialized");
+    } catch (error) {
+      useClawLogger().error(
+        `[yoyoclaw] failed to initialize plugin config: ${String(error)}`
+      );
+    }
   },
-  stop(_ctx) {
+  async stop(_ctx) {
     useClawLogger().info("[yoyoclaw-conn] stopping connection service");
 
     // 停止轮询
@@ -35,8 +68,14 @@ export const ClawConnectionService: OpenClawPluginService = {
 
     // 停止时销毁channel
     destroyConnection();
+
+    // 销毁状态跟踪器
+    if (statusTracker) {
+      await statusTracker.destroy();
+      statusTracker = null;
+    }
   },
-};
+} as OpenClawPluginService);
 
 /**
  * 启动轮询机制
@@ -79,8 +118,7 @@ async function pollConnection(): Promise<void> {
     const hasToken = !!userInfo?.token;
 
     useClawLogger().debug?.(
-      `[yoyoclaw-conn] polling - hasToken: ${hasToken}, hasChannel: ${!!clawConnection.channel}, status: ${
-        clawConnection.status
+      `[yoyoclaw-conn] polling - hasToken: ${hasToken}, hasChannel: ${!!clawConnection.channel}, status: ${clawConnection.status
       }`
     );
 
@@ -122,6 +160,18 @@ async function createChannel(
     `[yoyoclaw-conn] creating new channel for device: ${deviceInfo.deviceId}`
   );
 
+  // 通知状态跟踪器：连接状态变更
+  if (statusTracker) {
+    await statusTracker.handleEvent({
+      type: StatusEventType.CONNECTION_STATUS_CHANGED,
+      timestamp: Date.now(),
+      data: {
+        status: "connecting",
+        previousStatus: clawConnection.status,
+      },
+    });
+  }
+
   return new Promise((resolve, reject) => {
     clawConnection.channel = new ClawChannel({
       deviceInfo,
@@ -130,6 +180,18 @@ async function createChannel(
         clawConnection.status = "connected";
         useClawLogger().info("[yoyoclaw-conn] channel connected successfully");
 
+        // 通知状态跟踪器：连接状态变更
+        if (statusTracker) {
+          statusTracker.handleEvent({
+            type: StatusEventType.CONNECTION_STATUS_CHANGED,
+            timestamp: Date.now(),
+            data: {
+              status: "connected",
+              previousStatus: "connecting",
+            },
+          });
+        }
+
         // 连接成功后，将轮询间隔延长到 10 秒
         if (pollInterval !== 10000) {
           pollInterval = 10000;
@@ -151,6 +213,18 @@ async function createChannel(
         clawConnection.channel = null;
         useClawLogger().info("[yoyoclaw-conn] channel closed");
 
+        // 通知状态跟踪器：连接状态变更
+        if (statusTracker) {
+          statusTracker.handleEvent({
+            type: StatusEventType.CONNECTION_STATUS_CHANGED,
+            timestamp: Date.now(),
+            data: {
+              status: "idle",
+              previousStatus: "connected",
+            },
+          });
+        }
+
         // 连接断开后，恢复轮询间隔为 5 秒
         if (pollInterval !== 5000) {
           pollInterval = 5000;
@@ -212,6 +286,12 @@ async function createChannel(
           destroyConnection();
         }
       },
+      onStatusEvent: async (event) => {
+        // 桥接所有状态事件到跟踪器
+        if (statusTracker) {
+          await statusTracker.handleEvent(event);
+        }
+      },
     });
 
     try {
@@ -252,8 +332,8 @@ export function destroyConnection(): void {
 }
 
 /**
- * 获取当前连接状态
+ * 获取状态跟踪器实例
  */
-export function getConnectionStatus(): ConnectionStatus {
-  return clawConnection.status;
+export function getStatusTracker(): StatusTracker | null {
+  return statusTracker;
 }

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

@@ -0,0 +1,127 @@
+/**
+ * 状态跟踪事件定义
+ * 定义所有状态跟踪相关的事件类型
+ */
+
+/**
+ * 事件类型枚举
+ */
+export enum StatusEventType {
+  // 云侧Socket事件
+  CLOUD_SOCKET_CONNECTING = 'cloud_socket_connecting',
+  CLOUD_SOCKET_CONNECTED = 'cloud_socket_connected',
+  CLOUD_SOCKET_DISCONNECTED = 'cloud_socket_disconnected',
+  CLOUD_SOCKET_ERROR = 'cloud_socket_error',
+  CLOUD_SOCKET_RETRY = 'cloud_socket_retry',
+
+  // Gateway连接事件
+  GATEWAY_CLIENT_CONNECTED = 'gateway_client_connected',
+  GATEWAY_CLIENT_DISCONNECTED = 'gateway_client_disconnected',
+
+  // 设备配对事件
+  DEVICE_PAIRING = 'device_pairing',
+  DEVICE_UNPAIRING = 'device_unpairing',
+
+  // 整体连接状态事件
+  CONNECTION_STATUS_CHANGED = 'connection_status_changed',
+}
+
+/**
+ * 状态事件基础接口
+ */
+export interface StatusEvent {
+  type: StatusEventType;
+  timestamp: number;
+  data: any;
+}
+
+/**
+ * 云侧Socket连接事件数据
+ */
+export interface CloudSocketConnectingData {
+  url: string;
+}
+
+/**
+ * 云侧Socket已连接事件数据
+ */
+export interface CloudSocketConnectedData {
+  url: string;
+  connectedAt: string;
+}
+
+/**
+ * 云侧Socket断连事件数据
+ */
+export interface CloudSocketDisconnectedData {
+  reason: string;
+  code?: number;
+  disconnectedAt: string;
+}
+
+/**
+ * 云侧Socket错误事件数据
+ */
+export interface CloudSocketErrorData {
+  error: string;
+  timestamp: string;
+}
+
+/**
+ * 云侧Socket重试事件数据
+ */
+export interface CloudSocketRetryData {
+  retryCount: number;
+  maxRetries: number;
+  delay: number;
+  lastError?: string;
+}
+
+/**
+ * Gateway客户端连接事件数据
+ */
+export interface GatewayClientConnectedData {
+  sessionId: string;
+  hardwareDeviceId: string;
+  deviceInfo: any;
+  connectedAt: string;
+}
+
+/**
+ * Gateway客户端断连事件数据
+ */
+export interface GatewayClientDisconnectedData {
+  sessionId: string;
+  hardwareDeviceId: string;
+  reason: string;
+  disconnectedAt: string;
+}
+
+/**
+ * 设备配对事件数据
+ */
+export interface DevicePairingData {
+  sessionId: string;
+  hardwareDeviceId: string;
+  deviceInfo: any;
+  pairedAt: string;
+}
+
+/**
+ * 设备取消配对事件数据
+ */
+export interface DeviceUnpairingData {
+  sessionId: string;
+  hardwareDeviceId: string;
+  reason: string;
+  unpairedAt: string;
+}
+
+/**
+ * 连接状态变更事件数据
+ */
+export interface ConnectionStatusChangedData {
+  status: 'idle' | 'connecting' | 'connected';
+  previousStatus?: 'idle' | 'connecting' | 'connected';
+  reason?: string;
+}

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

@@ -0,0 +1,31 @@
+/**
+ * 状态跟踪模块入口
+ */
+
+export { StatusTracker } from './tracker.js';
+export { StatusStorage } from './storage.js';
+export {
+  StatusEventType,
+  type StatusEvent,
+  type CloudSocketConnectingData,
+  type CloudSocketConnectedData,
+  type CloudSocketDisconnectedData,
+  type CloudSocketErrorData,
+  type CloudSocketRetryData,
+  type GatewayClientConnectedData,
+  type GatewayClientDisconnectedData,
+  type DevicePairingData,
+  type DeviceUnpairingData,
+  type ConnectionStatusChangedData,
+} from './events.js';
+export {
+  type ConnectionStatusData,
+  type ConnectionStatus,
+  type GatewayConnectionInfo,
+  type PhysicalDeviceInfo,
+  type CloudSocketStatus,
+  type GatewayStatus,
+  type DevicesStatus,
+  type ConnectionHistory,
+  createEmptyStatusData,
+} from './types.js';

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

@@ -0,0 +1,133 @@
+/**
+ * 状态文件存储
+ * 负责将状态数据持久化到文件系统
+ */
+
+import { promises as fs, existsSync } from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { fileURLToPath } from 'url';
+import type { ConnectionStatusData } from './types.js';
+import { createEmptyStatusData } from './types.js';
+
+/**
+ * 获取项目根目录
+ * 通过当前模块的路径向上查找，直到找到 package.json
+ */
+function getProjectRoot(): string {
+  const currentFile = fileURLToPath(import.meta.url);
+  let currentDir = path.dirname(currentFile);
+
+  // 向上查找，直到找到 package.json
+  while (currentDir !== path.dirname(currentDir)) {
+    const packageJsonPath = path.join(currentDir, 'package.json');
+    if (existsSync(packageJsonPath)) {
+      return currentDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+
+  // 如果找不到，使用当前目录
+  return currentDir;
+}
+
+/**
+ * 状态存储类
+ */
+export class StatusStorage {
+  private statusFilePath: string;
+  private statusDir: string;
+
+  constructor() {
+    // 状态文件放在项目根目录下的 .local-tmps 文件夹
+    const projectRoot = getProjectRoot();
+    this.statusDir = path.join(projectRoot, '.local-tmps');
+    this.statusFilePath = path.join(this.statusDir, 'yoyo-status.json');
+  }
+
+  /**
+   * 保存状态到文件
+   */
+  async save(status: ConnectionStatusData): Promise<void> {
+    try {
+      // 确保目录存在
+      await fs.mkdir(this.statusDir, { recursive: true });
+
+      // 写入状态文件
+      const content = JSON.stringify(status, null, 2);
+      await fs.writeFile(this.statusFilePath, content, 'utf-8');
+    } catch (error) {
+      console.error(
+        `[StatusStorage] Failed to save status: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * 从文件加载状态
+   */
+  async load(): Promise<ConnectionStatusData | null> {
+    try {
+      // 检查文件是否存在
+      await fs.access(this.statusFilePath);
+
+      // 读取文件内容
+      const content = await fs.readFile(this.statusFilePath, 'utf-8');
+      const status = JSON.parse(content) as ConnectionStatusData;
+
+      return status;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        // 文件不存在，返回null
+        return null;
+      }
+
+      console.error(
+        `[StatusStorage] Failed to load status: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+      return null;
+    }
+  }
+
+  /**
+   * 清除状态文件
+   */
+  async clear(): Promise<void> {
+    try {
+      await fs.unlink(this.statusFilePath);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        console.error(
+          `[StatusStorage] Failed to clear status: ${
+            error instanceof Error ? error.message : String(error)
+          }`
+        );
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * 获取状态文件路径
+   */
+  getFilePath(): string {
+    return this.statusFilePath;
+  }
+
+  /**
+   * 检查状态文件是否存在
+   */
+  async exists(): Promise<boolean> {
+    try {
+      await fs.access(this.statusFilePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}