@honor-claw/yoyo 0.0.1-alpha.0

package/src/commands/logout/index.ts

@@ -0,0 +1,53 @@
+import { type OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { getConnectionManager } from "../../services/connection-manager.js";
+import { type Command } from "commander";
+
+export function registerLogoutCommand(api: OpenClawPluginApi, command: Command) {
+  const nextCommand = command
+    .command("logout")
+    .description("Logout and disconnect from YOYOClaw")
+    .option("--force", "Force logout without confirmation")
+    .action(async (options) => {
+      api.logger.info("honor logout CLI command called");
+
+      const { force } = options;
+      const connectionManager = getConnectionManager();
+      const isConnected = connectionManager.isConnected();
+      const connectedDevices = connectionManager.getConnectedDevices();
+
+      if (!isConnected) {
+        console.log("⚠️  当前未连接到 YOYOClaw");
+        return;
+      }
+
+      // 如果有活跃的设备连接且不是强制模式，提示确认
+      if (connectedDevices.length > 0 && !force) {
+        console.log(`⚠️  当前有 ${connectedDevices.length} 个活跃的设备连接:`);
+        for (const device of connectedDevices) {
+          console.log(`  - ${device}`);
+        }
+        console.log("\n⚠️  断开连接将停止所有设备间的通信");
+        console.log('💡 使用 --force 选项可以跳过此确认');
+        
+        // 注意：在命令行工具中，我们无法直接等待用户输入
+        // 这里我们给出提示，然后继续执行
+        console.log("\n🔌 正在断开连接...");
+      } else {
+        console.log("🔌 正在断开连接...");
+      }
+
+      try {
+        await connectionManager.cleanup();
+        console.log("✅ WebSocket 连接已关闭");
+        console.log("✅ 所有设备连接已清理");
+        console.log("✅ 资源已释放");
+        console.log("👋 已登出");
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error("❌ 登出失败:", errorMessage);
+        throw error;
+      }
+    });
+
+  return nextCommand;
+}

package/src/commands/status/index.ts

@@ -0,0 +1,64 @@
+import { type OpenClawPluginApi } from 'openclaw/plugin-sdk';
+import { type Command } from 'commander';
+import { getConnectionStatus } from '../../services/connection/impl.js';
+
+export function registerStatusCommand(api: OpenClawPluginApi, command: Command) {
+  const nextCommand = command
+    .command('status')
+    .description('Show YOYOClaw connection status')
+    .action(async () => {
+      api.logger.info('YOYOClaw status CLI command called');
+
+      // 获取连接状态
+      const status = getConnectionStatus();
+
+      // 连接状态
+      const stateEmoji = getStateEmoji(status);
+      const stateText = getStateText(status);
+
+      api.logger.info(`连接状态: ${stateEmoji} ${stateText}`);
+
+      if (status === 'connected') {
+        // 已连接状态
+        api.logger.info('\n✅ YOYOClaw 连接正常');
+      } else if (status === 'connecting') {
+        // 连接中状态
+        api.logger.info('\n⏳ 正在建立连接...');
+      } else {
+        // 未连接状态
+        api.logger.info("\n💡 请先执行 'yoyoclaw login' 建立连接");
+      }
+    });
+
+  return nextCommand;
+}
+
+/**
+ * 获取状态对应的 emoji
+ */
+function getStateEmoji(status: 'idle' | 'connecting' | 'connected'): string {
+  switch (status) {
+    case 'connected':
+      return '✅';
+    case 'connecting':
+      return '⏳';
+    case 'idle':
+    default:
+      return '⚪';
+  }
+}
+
+/**
+ * 获取状态对应的文本
+ */
+function getStateText(status: 'idle' | 'connecting' | 'connected'): string {
+  switch (status) {
+    case 'connected':
+      return '已连接';
+    case 'connecting':
+      return '连接中';
+    case 'idle':
+    default:
+      return '未连接';
+  }
+}

package/src/gateway-client/client.deprecated.ts

@@ -0,0 +1,376 @@
+import { randomUUID } from "node:crypto";
+import { WebSocket } from "ws";
+import type {
+  EventFrame,
+  HelloOk,
+  ConnectParams,
+  RequestFrame,
+  ResponseFrame,
+  GatewayClientId,
+  GatewayClientMode,
+} from "./types.deprecated.js";
+import {
+  loadOrCreateDeviceIdentity,
+  signDevicePayload,
+  publicKeyRawBase64UrlFromPem,
+} from "./device/identity.js";
+import { buildDeviceAuthPayloadV3 } from "./device/auth.js";
+import type { DeviceIdentity } from "./device/types.js";
+import { rawDataToString } from "openclaw/plugin-sdk";
+
+/**
+ * 插件 Gateway Client 配置选项（简化版）
+ */
+export interface GatewayClientOptions {
+  url: string; // ws://127.0.0.1:18789
+  clientId?: GatewayClientId;
+  clientDisplayName?: string;
+  clientVersion: string;
+  platform?: string;
+  mode?: GatewayClientMode;
+  instanceId?: string;
+  role?: string;
+  scopes?: string[];
+  token?: string;
+  password?: string;
+  locale?: string;
+  deviceFamily?: string;
+  deviceIdentity?: DeviceIdentity;
+  modelIdentifier?: string;
+  connectTimeout?: number; // 连接挑战超时时间（毫秒），默认 2000
+  logDebug?: (...args: unknown[]) => void;
+  logError?: (...args: unknown[]) => void;
+  onEvent?: (evt: EventFrame) => void;
+  onHelloOk?: (hello: HelloOk) => void;
+  onConnectError?: (err: Error) => void;
+  onClose?: (code: number, reason: string) => void;
+}
+
+// ==================== GatewayClient 类 ====================
+
+type Pending = {
+  resolve: (value: unknown) => void;
+  reject: (err: unknown) => void;
+};
+
+/**
+ * 精简版 Gateway Client，用于插件场景
+ * - 保留 WebSocket 连接
+ * - 简化认证流程
+ * - 支持直接消息传递
+ */
+export class GatewayClient {
+  private ws: WebSocket | null = null;
+  private opts: GatewayClientOptions;
+  private pending = new Map<string, Pending>();
+  private closed = false;
+  private connectNonce: string | null = null;
+  private connectSent = false;
+  private connectTimer: NodeJS.Timeout | null = null;
+  private paired = false;
+  private deviceIdentity: DeviceIdentity;
+
+  constructor(opts: GatewayClientOptions) {
+    this.deviceIdentity = opts.deviceIdentity ?? loadOrCreateDeviceIdentity();
+    
+    this.opts = {
+      ...opts,
+      deviceIdentity: this.deviceIdentity,
+      clientId: opts.clientId,
+      clientVersion: opts.clientVersion,
+      platform: opts.platform,
+      mode: opts.mode,
+      role: opts.role,
+      scopes: opts.scopes ?? [],
+      locale: opts.locale ?? "zh-Hans-CN",
+      deviceFamily: opts.deviceFamily,
+      logDebug: opts.logDebug ?? (() => {}),
+      logError: opts.logError ?? console.error,
+    };
+  }
+
+  /**
+   * 启动连接
+   */
+  start() {
+    if (this.closed) {
+      return;
+    }
+    const url = this.opts.url;
+    this.ws = new WebSocket(url, { maxPayload: 25 * 1024 * 1024 });
+
+    this.ws.on("open", () => {
+      this.queueConnect();
+    });
+
+    this.ws.on("message", (data) => this.handleMessage(rawDataToString(data)));
+
+    this.ws.on("close", (code, reason) => {
+      const reasonText = rawDataToString(reason);
+      this.ws = null;
+      this.flushPendingErrors(
+        new Error(`gateway closed (${code}): ${reasonText}`)
+      );
+      this.opts.onClose?.(code, reasonText);
+    });
+
+    this.ws.on("error", (err) => {
+      this.opts.logDebug(`gateway client error: ${String(err)}`);
+      if (!this.connectSent) {
+        this.opts.onConnectError?.(
+          err instanceof Error ? err : new Error(String(err))
+        );
+      }
+    });
+  }
+
+  /**
+   * 停止连接
+   */
+  stop() {
+    this.closed = true;
+    if (this.connectTimer) {
+      clearTimeout(this.connectTimer);
+      this.connectTimer = null;
+    }
+    this.ws?.close();
+    this.ws = null;
+    this.flushPendingErrors(new Error("gateway client stopped"));
+  }
+
+  /**
+   * 完成配对（插件维度的 node-gateway 配对）
+   */
+  async pair(): Promise<HelloOk> {
+    return new Promise((resolve, reject) => {
+      const originalOnHelloOk = this.opts.onHelloOk;
+      const originalOnConnectError = this.opts.onConnectError;
+
+      this.opts.onHelloOk = (hello) => {
+        this.paired = true;
+        originalOnHelloOk?.(hello);
+        this.opts.onHelloOk = originalOnHelloOk;
+        this.opts.onConnectError = originalOnConnectError;
+        resolve(hello);
+      };
+
+      this.opts.onConnectError = (err) => {
+        originalOnConnectError?.(err);
+        this.opts.onHelloOk = originalOnHelloOk;
+        this.opts.onConnectError = originalOnConnectError;
+        reject(err);
+      };
+
+      // 如果已经连接成功，直接返回
+      if (this.paired) {
+        this.opts.onHelloOk = originalOnHelloOk;
+        this.opts.onConnectError = originalOnConnectError;
+        resolve({
+          type: "hello-ok",
+          protocol: 3,
+          gateway: { id: "unknown", version: "unknown" },
+        });
+      }
+    });
+  }
+
+  /**
+   * 直接发送消息（配对后使用）
+   */
+  send(data: string | Buffer): void {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("gateway not connected");
+    }
+    this.ws.send(data);
+  }
+
+  /**
+   * 发送请求并等待响应
+   */
+  async request<T = unknown>(method: string, params?: unknown): Promise<T> {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("gateway not connected");
+    }
+    const id = randomUUID();
+    const frame: RequestFrame = { type: "req", id, method, params };
+
+    const p = new Promise<T>((resolve, reject) => {
+      this.pending.set(id, {
+        resolve: (value) => resolve(value as T),
+        reject,
+      });
+    });
+
+    this.ws.send(JSON.stringify(frame));
+    return p;
+  }
+
+  /**
+   * 发送连接请求
+   */
+  private sendConnect() {
+    if (this.connectSent) {
+      return;
+    }
+    const nonce = this.connectNonce?.trim() ?? "";
+    if (!nonce) {
+      this.opts.onConnectError?.(
+        new Error("gateway connect challenge missing nonce")
+      );
+      this.ws?.close(1008, "connect challenge missing nonce");
+      return;
+    }
+    this.connectSent = true;
+    if (this.connectTimer) {
+      clearTimeout(this.connectTimer);
+      this.connectTimer = null;
+    }
+
+    const signedAtMs = Date.now();
+
+    // Build device authentication payload and signature
+    const device = (() => {
+      const payload = buildDeviceAuthPayloadV3({
+        deviceId: this.deviceIdentity.deviceId,
+        clientId: this.opts.clientId,
+        clientMode: this.opts.mode,
+        role: this.opts.role,
+        scopes: this.opts.scopes,
+        signedAtMs,
+        token: this.opts.token,
+        nonce,
+        platform: this.opts.platform,
+        deviceFamily: this.opts.deviceFamily,
+      });
+      const signature = signDevicePayload(
+        this.deviceIdentity.privateKeyPem,
+        payload
+      );
+      return {
+        id: this.deviceIdentity.deviceId,
+        publicKey: publicKeyRawBase64UrlFromPem(
+          this.deviceIdentity.publicKeyPem
+        ),
+        signature,
+        signedAt: signedAtMs,
+        nonce,
+      };
+    })();
+
+    const params: ConnectParams = {
+      minProtocol: 1,
+      maxProtocol: 3,
+      client: {
+        id: this.opts.clientId!,
+        displayName: this.opts.clientDisplayName,
+        version: this.opts.clientVersion,
+        platform: this.opts.platform,
+        mode: this.opts.mode,
+        deviceFamily: this.opts.deviceFamily,
+        instanceId: this.opts.instanceId,
+      },
+      role: this.opts.role,
+      scopes: this.opts.scopes,
+      auth:
+        this.opts.token || this.opts.password
+          ? {
+              token: this.opts.token,
+              password: this.opts.password,
+            }
+          : undefined,
+      locale: this.opts.locale,
+      device,
+    };
+
+    void this.request<HelloOk>("connect", params)
+      .then((helloOk) => {
+        this.opts.onHelloOk?.(helloOk);
+      })
+      .catch((err) => {
+        this.opts.onConnectError?.(
+          err instanceof Error ? err : new Error(String(err))
+        );
+        this.opts.logError(`gateway connect failed: ${String(err)}`);
+        this.ws?.close(1008, "connect failed");
+      });
+  }
+
+  /**
+   * 处理接收到的消息
+   */
+  private handleMessage(raw: string) {
+    try {
+      const parsed = JSON.parse(raw);
+
+      // 处理事件帧（兼容 "evt" 和 "event" 两种格式）
+      if (parsed.type === "evt" || parsed.type === "event") {
+        const evt = parsed as EventFrame;
+        if (evt.event === "connect.challenge") {
+          const payload = evt.payload as { nonce?: unknown } | undefined;
+          const nonce =
+            payload && typeof payload.nonce === "string" ? payload.nonce : null;
+          if (!nonce || nonce.trim().length === 0) {
+            this.opts.onConnectError?.(
+              new Error("gateway connect challenge missing nonce")
+            );
+            this.ws?.close(1008, "connect challenge missing nonce");
+            return;
+          }
+          this.connectNonce = nonce.trim();
+          this.sendConnect();
+          return;
+        }
+        this.opts.onEvent?.(evt);
+        return;
+      }
+
+      // 处理响应帧
+      if (parsed.type === "res") {
+        const res = parsed as ResponseFrame;
+        const pending = this.pending.get(res.id);
+        if (!pending) {
+          return;
+        }
+        this.pending.delete(res.id);
+        if (res.ok) {
+          pending.resolve(res.payload);
+        } else {
+          pending.reject(new Error(res.error?.message ?? "unknown error"));
+        }
+      }
+    } catch (err) {
+      this.opts.logDebug(`gateway client parse error: ${String(err)}`);
+    }
+  }
+
+  /**
+   * 队列连接请求
+   */
+  private queueConnect() {
+    this.connectNonce = null;
+    this.connectSent = false;
+    if (this.connectTimer) {
+      clearTimeout(this.connectTimer);
+    }
+    const timeout = this.opts.connectTimeout ?? 2000;
+    this.connectTimer = setTimeout(() => {
+      if (this.connectSent || this.ws?.readyState !== WebSocket.OPEN) {
+        return;
+      }
+      this.opts.onConnectError?.(
+        new Error("gateway connect challenge timeout")
+      );
+      this.ws?.close(1008, "connect challenge timeout");
+    }, timeout);
+  }
+
+  /**
+   * 清理所有待处理的请求
+   */
+  private flushPendingErrors(err: Error) {
+    for (const [, p] of this.pending) {
+      p.reject(err);
+    }
+    this.pending.clear();
+  }
+}

package/src/gateway-client/client.ts

@@ -0,0 +1,76 @@
+import { rawDataToString } from "openclaw/plugin-sdk";
+import { WebSocket } from "ws";
+import { GatewayClientOptions } from "./types.js";
+import { useClawLogger } from "../utils/logger.js";
+
+const GATEWAY_SERVER_URL = "ws://127.0.0.1:18789";
+
+/**
+ * 纯透传 Gateway Client
+ * - 建立 WebSocket 连接
+ * - 所有消息直接透传，不做任何协议处理
+ */
+export class GatewayClient {
+  private ws: WebSocket | null = null;
+  private opts: GatewayClientOptions;
+  private closed = false;
+
+  constructor(opts: GatewayClientOptions) {
+    this.opts = opts;
+  }
+
+  /**
+   * 启动连接
+   */
+  start() {
+    if (this.closed) {
+      return;
+    }
+    const url = GATEWAY_SERVER_URL;
+    this.ws = new WebSocket(url, { maxPayload: 25 * 1024 * 1024 });
+
+    this.ws.on("open", () => {
+      this.opts.onOpen?.();
+    });
+
+    this.ws.on("message", (data) => {
+      const dataText = rawDataToString(data);
+      useClawLogger().debug?.(`[yoyoclaw-gateway] received message:, ${dataText.slice(0, 500)}`);
+      this.opts.onMessage?.(dataText);
+    });
+
+    this.ws.on("close", (code, reason) => {
+      const reasonText = rawDataToString(reason);
+      this.ws = null;
+      useClawLogger().info(`[yoyoclaw-gateway] closed (${code}): ${reasonText}`);
+      this.opts.onClose?.();
+    });
+
+    this.ws.on("error", (err) => {
+      useClawLogger().error(`[yoyoclaw-gateway] error: ${String(err)}`);
+      this.opts.onClose?.();
+    });
+  }
+
+  /**
+   * 停止连接
+   */
+  stop() {
+    this.closed = true;
+    this.ws?.close();
+    this.ws = null;
+  }
+
+  /**
+   * 发送消息（透传）
+   */
+  send(data: Buffer | string): void {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      useClawLogger().error(
+        "[yoyoclaw-gateway] send failed: gateway not connected"
+      );
+      return;
+    }
+    this.ws.send(data);
+  }
+}

package/src/gateway-client/device/auth.ts

@@ -0,0 +1,57 @@
+import { normalizeDeviceMetadataForAuth } from "./helpers.js";
+import type {
+  DeviceAuthPayloadParams,
+  DeviceAuthPayloadV3Params,
+} from "./types.js";
+
+export { normalizeDeviceMetadataForAuth };
+
+/**
+ * Build device authentication payload (v2)
+ * @param params - Authentication parameters
+ * @returns Pipe-delimited payload string
+ */
+export function buildDeviceAuthPayload(
+  params: DeviceAuthPayloadParams
+): string {
+  const scopes = params.scopes.join(",");
+  const token = params.token ?? "";
+  return [
+    "v2",
+    params.deviceId,
+    params.clientId,
+    params.clientMode,
+    params.role,
+    scopes,
+    String(params.signedAtMs),
+    token,
+    params.nonce,
+  ].join("|");
+}
+
+/**
+ * Build device authentication payload (v3) with platform and device family
+ * @param params - Authentication parameters including platform and device family
+ * @returns Pipe-delimited payload string
+ */
+export function buildDeviceAuthPayloadV3(
+  params: DeviceAuthPayloadV3Params
+): string {
+  const scopes = params.scopes.join(",");
+  const token = params.token ?? "";
+  const platform = normalizeDeviceMetadataForAuth(params.platform);
+  const deviceFamily = normalizeDeviceMetadataForAuth(params.deviceFamily);
+  return [
+    "v3",
+    params.deviceId,
+    params.clientId,
+    params.clientMode,
+    params.role,
+    scopes,
+    String(params.signedAtMs),
+    token,
+    params.nonce,
+    platform,
+    deviceFamily,
+  ].join("|");
+}