qidao-openclaw-plugin 1.0.0

package/openclaw.plugin.json

@@ -0,0 +1,8 @@
+{
+  "id": "qidao-openclaw-plugin",
+  "name": "栖岛聊天插件",
+  "version": "1.0.0",
+  "description": "OpenClaw 栖岛聊天 Channel 插件，连接到栖岛聊天服务",
+  "author": "Qidao Team",
+  "license": "MIT"
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "qidao-openclaw-plugin",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./src/index.js",
+  "description": "OpenClaw 栖岛聊天 Channel 插件 - 连接到栖岛聊天服务",
+  "keywords": [
+    "openclaw",
+    "openclaw-plugin",
+    "channel",
+    "qidao",
+    "chat",
+    "messaging"
+  ],
+  "author": "Qidao Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/qidao/openclaw-plugin.git"
+  },
+  "bugs": {
+    "url": "https://github.com/qidao/openclaw-plugin/issues"
+  },
+  "homepage": "https://github.com/qidao/openclaw-plugin#readme",
+  "files": [
+    "src",
+    "openclaw.plugin.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "openclaw": {
+    "extensions": [
+      "./src/index.js"
+    ]
+  },
+  "scripts": {
+    "test": "node test.js",
+    "auth": "node test.js",
+    "prepublishOnly": "echo 'Preparing to publish...'",
+    "build": "echo 'No build step required'",
+    "publish:npm": "npm publish --access public",
+    "version:patch": "npm version patch",
+    "version:minor": "npm version minor",
+    "version:major": "npm version major"
+  },
+  "dependencies": {
+    "ws": "^8.16.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/config.js

@@ -0,0 +1,116 @@
+/**
+ * 栖岛插件配置文件
+ * 统一管理所有API地址和配置项
+ */
+
+export const QIDAO_CONFIG = {
+  // 服务器地址配置
+  SERVER: {
+    // 生产环境
+    PRODUCTION: {
+      WS_URL: 'wss://oc.qidao.chat/ws',
+      HTTP_URL: 'https://oc.qidao.chat',
+      HEALTH_CHECK: 'https://oc.qidao.chat/health'
+    },
+    
+    // 开发环境
+    DEVELOPMENT: {
+      WS_URL: 'wss://oc.qidao.chat/ws',
+      HTTP_URL: 'https://oc.qidao.chat',
+      HEALTH_CHECK: 'https://oc.qidao.chat/health'
+    }
+  },
+
+  // 栖岛官方API
+  QIDAO_API: {
+    BASE_URL: 'https://api.qidao.tvcloud.top',
+    WS_CONNECT: 'wss://api.qidao.tvcloud.top/ws/connect',
+    ENDPOINTS: {
+      SEND_MESSAGE: '/websocket/im/sendMessage',
+      ONLINE_USERS: '/websocket/im/chatRoomOnlineUsers',
+      USER_STATUS: '/websocket/im/userOnlineStatus',
+      CREATE_CHAT: '/websocket/im/createChat',
+      IM_STATS: '/websocket/im/stats'
+    }
+  },
+
+  // 默认配置
+  DEFAULTS: {
+    RECONNECT_INTERVAL: 5000,
+    REQUEST_TIMEOUT: 30000,
+    MAX_RECONNECT_ATTEMPTS: 10,
+    DEBUG: false,
+    AUTO_CONNECT: true
+  },
+
+  // 消息类型
+  MESSAGE_TYPES: {
+    TEXT: 0,
+    IMAGE: 1,
+    FILE: 2,
+    SYSTEM: 99
+  },
+
+  // 聊天类型
+  CHAT_TYPES: {
+    PRIVATE: 0,
+    GROUP: 1
+  },
+
+  // 事件类型
+  EVENTS: {
+    CONNECTED: 'connected',
+    DISCONNECTED: 'disconnected',
+    MESSAGE: 'message',
+    MESSAGE_SENT: 'messageSent',
+    MESSAGE_FAILED: 'messageFailed',
+    CHAT_CREATED: 'chatCreated',
+    ERROR: 'error',
+    RECONNECTING: 'reconnecting',
+    RECONNECTED: 'reconnected'
+  }
+};
+
+/**
+ * 获取当前环境配置
+ */
+export function getCurrentConfig(env = 'production') {
+  const environment = env.toLowerCase();
+  
+  if (environment === 'development' || environment === 'dev') {
+    return QIDAO_CONFIG.SERVER.DEVELOPMENT;
+  }
+  
+  return QIDAO_CONFIG.SERVER.PRODUCTION;
+}
+
+/**
+ * 获取完整的WebSocket URL
+ */
+export function getWebSocketUrl(env = 'production') {
+  return getCurrentConfig(env).WS_URL;
+}
+
+/**
+ * 获取HTTP API基础URL
+ */
+export function getHttpUrl(env = 'production') {
+  return getCurrentConfig(env).HTTP_URL;
+}
+
+/**
+ * 获取健康检查URL
+ */
+export function getHealthCheckUrl(env = 'production') {
+  return getCurrentConfig(env).HEALTH_CHECK;
+}
+
+/**
+ * 构建API端点URL
+ */
+export function buildApiUrl(endpoint, env = 'production') {
+  const baseUrl = getHttpUrl(env);
+  return `${baseUrl}/api${endpoint}`;
+}
+
+export default QIDAO_CONFIG;

package/src/index.js

@@ -0,0 +1,202 @@
+/**
+ * 栖岛聊天 OpenClaw Channel 插件
+ * 
+ * 这是OpenClaw插件的主入口文件
+ */
+
+import { QidaoChannel } from './qidao-channel.js';
+
+// 存储所有账户的连接实例
+const accountConnections = new Map();
+
+/**
+ * OpenClaw插件注册函数
+ * @param {Object} api - OpenClaw Plugin API
+ */
+export default function register(api) {
+  api.logger.info('栖岛聊天插件加载中...');
+  
+  // 注册Channel
+  api.registerChannel({
+    id: 'qidao',
+    
+    meta: {
+      id: 'qidao',
+      label: '栖岛聊天',
+      selectionLabel: '栖岛聊天 (Qidao Chat)',
+      blurb: '连接到栖岛聊天服务，支持实时消息收发',
+    },
+    
+    capabilities: {
+      chatTypes: ['direct', 'group'],
+      supportsMedia: true,
+      supportsReactions: false,
+      supportsThreads: false,
+    },
+    
+    config: {
+      // 列出所有配置的账户ID
+      listAccountIds: (cfg) => {
+        const accounts = cfg.channels?.qidao?.accounts ?? {};
+        return Object.keys(accounts);
+      },
+      
+      // 解析指定账户的配置
+      resolveAccount: (cfg, accountId) => {
+        const accounts = cfg.channels?.qidao?.accounts ?? {};
+        const account = accounts[accountId ?? 'default'];
+        
+        if (!account) {
+          return { accountId };
+        }
+        
+        return {
+          accountId: accountId ?? 'default',
+          enabled: account.enabled ?? true,
+          chatId: account.chatId,
+          userId: account.userId,
+          serverUrl: account.serverUrl ?? 'wss://oc.qidao.chat/ws',
+        };
+      },
+    },
+    
+    outbound: {
+      deliveryMode: 'direct',
+      
+      // 发送文本消息
+      sendText: async ({ text, accountId, chatId }) => {
+        const connection = accountConnections.get(accountId ?? 'default');
+        
+        if (!connection || !connection.isConnected()) {
+          return { 
+            ok: false, 
+            error: '未连接到栖岛服务' 
+          };
+        }
+        
+        // chatId必须由调用方传入
+        if (!chatId) {
+          return {
+            ok: false,
+            error: '未指定chatId'
+          };
+        }
+        
+        try {
+          // 发送消息到栖岛
+          await connection.sendMessage(parseInt(chatId), text);
+          
+          return { ok: true };
+        } catch (error) {
+          return { 
+            ok: false, 
+            error: error.message 
+          };
+        }
+      },
+      
+      // 发送媒体消息
+      sendMedia: async ({ url, accountId, chatId }) => {
+        const connection = accountConnections.get(accountId ?? 'default');
+        
+        if (!connection || !connection.isConnected()) {
+          return { 
+            ok: false, 
+            error: '未连接到栖岛服务' 
+          };
+        }
+        
+        // chatId必须由调用方传入
+        if (!chatId) {
+          return {
+            ok: false,
+            error: '未指定chatId'
+          };
+        }
+        
+        try {
+          // 发送图片消息到栖岛
+          await connection.sendImageMessage(parseInt(chatId), url);
+          
+          return { ok: true };
+        } catch (error) {
+          return { 
+            ok: false, 
+            error: error.message 
+          };
+        }
+      },
+    },
+  });
+  
+  // 获取配置
+  const config = api.getConfig();
+  const accounts = config.channels?.qidao?.accounts ?? {};
+  
+  // 为每个启用的账户创建连接
+  Object.entries(accounts).forEach(([accountId, accountConfig]) => {
+    if (accountConfig.enabled === false) {
+      api.logger.info(`栖岛账户 ${accountId} 已禁用`);
+      return;
+    }
+    
+    if (!accountConfig.chatId) {
+      api.logger.warn(`栖岛账户 ${accountId} 缺少chatId配置`);
+      api.logger.warn(`请运行 'cd qidao-channel && node test.js' 获取chatId`);
+      return;
+    }
+    
+    const serverUrl = accountConfig.serverUrl ?? 'wss://oc.qidao.chat/ws';
+    
+    api.logger.info(`连接栖岛账户: ${accountId} (chatId: ${accountConfig.chatId})`);
+    
+    // 创建连接
+    const connection = new QidaoChannel({
+      serverUrl,
+      chatId: accountConfig.chatId,
+      userId: accountConfig.userId,
+    });
+    
+    // 监听连接事件
+    connection.on('connect', () => {
+      api.logger.info(`栖岛账户 ${accountId} 已连接`);
+    });
+    
+    connection.on('disconnect', () => {
+      api.logger.warn(`栖岛账户 ${accountId} 已断开`);
+    });
+    
+    connection.on('error', (error) => {
+      api.logger.error(`栖岛账户 ${accountId} 错误: ${error.message}`);
+    });
+    
+    // 监听栖岛消息，转发给OpenClaw
+    connection.on('message', (message) => {
+      api.logger.debug(`栖岛账户 ${accountId} 收到消息:`, message);
+      
+      // 将栖岛消息转换为OpenClaw消息格式
+      if (message.type === 'new_message') {
+        api.ingestMessage({
+          channelId: 'qidao',
+          accountId: accountId,
+          senderId: message.senderId.toString(),
+          senderName: message.senderName,
+          text: message.messageText,
+          timestamp: message.timestamp,
+          chatType: message.chatType === 0 ? 'direct' : 'group',
+          chatId: message.chatId.toString(),
+        });
+      }
+    });
+    
+    // 连接到服务器
+    connection.connect().catch((error) => {
+      api.logger.error(`栖岛账户 ${accountId} 连接失败: ${error.message}`);
+    });
+    
+    // 保存连接实例
+    accountConnections.set(accountId, connection);
+  });
+  
+  api.logger.info('栖岛聊天插件加载完成');
+}

package/src/plugin.js

@@ -0,0 +1,205 @@
+/**
+ * 栖岛聊天 OpenClaw Channel 插件
+ * 
+ * 这是OpenClaw的入口文件，导出register函数供OpenClaw加载
+ */
+
+import { QidaoChannel } from './qidao-channel.js';
+
+// 存储所有账户的连接实例
+const accountConnections = new Map();
+
+const qidaoChannel = {
+  id: 'qidao',
+  
+  meta: {
+    id: 'qidao',
+    label: '栖岛聊天',
+    selectionLabel: '栖岛聊天 (Qidao Chat)',
+    docsPath: '/channels/qidao',
+    blurb: '连接到栖岛聊天服务，支持实时消息收发',
+    aliases: ['qidao', 'qidao-chat'],
+  },
+  
+  capabilities: {
+    chatTypes: ['direct', 'group'],
+    supportsMedia: true,
+    supportsReactions: false,
+    supportsThreads: false,
+  },
+  
+  config: {
+    // 列出所有配置的账户ID
+    listAccountIds: (cfg) => {
+      const accounts = cfg.channels?.qidao?.accounts ?? {};
+      return Object.keys(accounts);
+    },
+    
+    // 解析指定账户的配置
+    resolveAccount: (cfg, accountId) => {
+      const accounts = cfg.channels?.qidao?.accounts ?? {};
+      const account = accounts[accountId ?? 'default'];
+      
+      if (!account) {
+        return { accountId };
+      }
+      
+      return {
+        accountId: accountId ?? 'default',
+        enabled: account.enabled ?? true,
+        chatId: account.chatId,
+        userId: account.userId,
+        serverUrl: account.serverUrl ?? 'wss://oc.qidao.chat/ws',
+      };
+    },
+  },
+  
+  outbound: {
+    deliveryMode: 'direct',
+    
+    // 发送文本消息
+    sendText: async ({ text, accountId, chatId }) => {
+      const connection = accountConnections.get(accountId ?? 'default');
+      
+      if (!connection || !connection.isConnected()) {
+        return { 
+          ok: false, 
+          error: '未连接到栖岛服务' 
+        };
+      }
+      
+      // chatId必须由调用方传入
+      if (!chatId) {
+        return {
+          ok: false,
+          error: '未指定chatId'
+        };
+      }
+      
+      try {
+        // 发送消息到栖岛
+        await connection.sendMessage(chatId, text);
+        
+        return { ok: true };
+      } catch (error) {
+        return { 
+          ok: false, 
+          error: error.message 
+        };
+      }
+    },
+    
+    // 发送媒体消息
+    sendMedia: async ({ url, accountId, chatId }) => {
+      const connection = accountConnections.get(accountId ?? 'default');
+      
+      if (!connection || !connection.isConnected()) {
+        return { 
+          ok: false, 
+          error: '未连接到栖岛服务' 
+        };
+      }
+      
+      // chatId必须由调用方传入
+      if (!chatId) {
+        return {
+          ok: false,
+          error: '未指定chatId'
+        };
+      }
+      
+      try {
+        // 发送图片消息到栖岛
+        await connection.sendImageMessage(chatId, url);
+        
+        return { ok: true };
+      } catch (error) {
+        return { 
+          ok: false, 
+          error: error.message 
+        };
+      }
+    },
+  },
+};
+
+/**
+ * OpenClaw插件注册函数
+ * @param {Object} api - OpenClaw Plugin API
+ */
+export default function register(api) {
+  api.logger.info('栖岛聊天插件加载中...');
+  
+  // 注册Channel
+  api.registerChannel({ plugin: qidaoChannel });
+  
+  // 获取配置
+  const config = api.getConfig();
+  const accounts = config.channels?.qidao?.accounts ?? {};
+  
+  // 为每个启用的账户创建连接
+  Object.entries(accounts).forEach(([accountId, accountConfig]) => {
+    if (accountConfig.enabled === false) {
+      api.logger.info(`栖岛账户 ${accountId} 已禁用`);
+      return;
+    }
+    
+    if (!accountConfig.chatId) {
+      api.logger.warn(`栖岛账户 ${accountId} 缺少chatId配置`);
+      return;
+    }
+    
+    const serverUrl = accountConfig.serverUrl ?? 'wss://oc.qidao.chat/ws';
+    
+    api.logger.info(`连接栖岛账户: ${accountId} (chatId: ${accountConfig.chatId})`);
+    
+    // 创建连接
+    const connection = new QidaoChannel({
+      serverUrl,
+      chatId: accountConfig.chatId,
+      userId: accountConfig.userId,
+    });
+    
+    // 监听连接事件
+    connection.on('connect', () => {
+      api.logger.info(`栖岛账户 ${accountId} 已连接`);
+    });
+    
+    connection.on('disconnect', () => {
+      api.logger.warn(`栖岛账户 ${accountId} 已断开`);
+    });
+    
+    connection.on('error', (error) => {
+      api.logger.error(`栖岛账户 ${accountId} 错误: ${error.message}`);
+    });
+    
+    // 监听栖岛消息，转发给OpenClaw
+    connection.on('message', (message) => {
+      api.logger.debug(`栖岛账户 ${accountId} 收到消息:`, message);
+      
+      // 将栖岛消息转换为OpenClaw消息格式
+      if (message.type === 'new_message') {
+        api.ingestMessage({
+          channelId: 'qidao',
+          accountId: accountId,
+          senderId: message.senderId.toString(),
+          senderName: message.senderName,
+          text: message.messageText,
+          timestamp: message.timestamp,
+          chatType: message.chatType === 0 ? 'direct' : 'group',
+          chatId: message.chatId.toString(),
+        });
+      }
+    });
+    
+    // 连接到服务器
+    connection.connect().catch((error) => {
+      api.logger.error(`栖岛账户 ${accountId} 连接失败: ${error.message}`);
+    });
+    
+    // 保存连接实例
+    accountConnections.set(accountId, connection);
+  });
+  
+  api.logger.info('栖岛聊天插件加载完成');
+}

package/src/qidao-channel.js

@@ -0,0 +1,446 @@
+import WebSocket from 'ws';
+import { getWebSocketUrl, QIDAO_CONFIG } from './config.js';
+import { exec } from 'child_process';
+import os from 'os';
+
+export class QidaoChannel {
+  constructor(config = {}) {
+    this.serverUrl = config.serverUrl || getWebSocketUrl(config.env);
+    this.chatId = config.chatId || null;
+    this.userId = config.userId || null;
+    this.ws = null;
+    this.connected = false;
+    this.chatIdSet = false;
+    this.reconnectInterval = config.reconnectInterval || QIDAO_CONFIG.DEFAULTS.RECONNECT_INTERVAL;
+    this.reconnectTimer = null;
+    this.messageHandlers = new Map();
+    this.eventHandlers = {
+      onConnect: null,
+      onDisconnect: null,
+      onMessage: null,
+      onError: null
+    };
+    
+    // 心跳机制
+    this.heartbeatInterval = null;
+    this.heartbeatIntervalMs = 30000; // 30秒发送一次心跳
+    this.heartbeatTimeoutMs = 10000; // 10秒心跳超时
+    this.lastPongTime = 0;
+  }
+
+  connect() {
+    return new Promise((resolve, reject) => {
+      try {
+        console.log('🔗 正在连接栖岛中转服务器...');
+        
+        this.ws = new WebSocket(this.serverUrl);
+
+        this.ws.on('open', async () => {
+          console.log('✅ 已连接到栖岛服务');
+          this.connected = true;
+          this.lastPongTime = Date.now();
+          
+          // 启动心跳
+          this.startHeartbeat();
+          
+          if (this.eventHandlers.onConnect) {
+            this.eventHandlers.onConnect();
+          }
+          
+          resolve();
+          
+          // 延迟自动设置chatId，确保连接稳定后再设置
+          if (this.chatId && !this.chatIdSet) {
+            setTimeout(async () => {
+              if (this.isConnected()) {
+                try {
+                  console.log('🔄 延迟设置chatId:', this.chatId);
+                  await this.setChatId(this.chatId, this.userId);
+                  this.chatIdSet = true;
+                  console.log('✅ 延迟设置chatId成功');
+                } catch (error) {
+                  console.error('❌ 延迟设置chatId失败:', error.message);
+                  // 设置失败不影响连接，可以稍后重试
+                }
+              }
+            }, 2000); // 延迟2秒，确保连接完全稳定
+          }
+        });
+
+        this.ws.on('message', (data) => {
+          this.handleMessage(data);
+        });
+
+        this.ws.on('close', () => {
+          console.log('🔌 栖岛服务连接已断开');
+          this.connected = false;
+          this.chatIdSet = false;
+          
+          // 停止心跳
+          this.stopHeartbeat();
+          
+          if (this.eventHandlers.onDisconnect) {
+            this.eventHandlers.onDisconnect();
+          }
+          
+          this.reconnect();
+        });
+
+        this.ws.on('error', (error) => {
+          console.error('❌ WebSocket错误:', error.message);
+          console.error('❌ 错误类型:', error.code);
+          console.error('❌ 错误详情:', error);
+          this.connected = false;
+          
+          if (this.eventHandlers.onError) {
+            this.eventHandlers.onError(error);
+          }
+          
+          reject(error);
+        });
+
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  reconnect() {
+    if (this.reconnectTimer) return;
+    
+    console.log(`⏳ ${this.reconnectInterval / 1000}秒后重连...`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect().catch(err => {
+        console.error('❌ 重连失败:', err.message);
+      });
+    }, this.reconnectInterval);
+  }
+
+  disconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    
+    // 停止心跳
+    this.stopHeartbeat();
+    
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    
+    this.connected = false;
+  }
+
+  isConnected() {
+    return this.connected && this.ws && this.ws.readyState === WebSocket.OPEN;
+  }
+
+  on(event, handler) {
+    if (this.eventHandlers.hasOwnProperty(`on${event.charAt(0).toUpperCase()}${event.slice(1)}`)) {
+      this.eventHandlers[`on${event.charAt(0).toUpperCase()}${event.slice(1)}`] = handler;
+    }
+  }
+
+  handleMessage(data) {
+    try {
+      const message = JSON.parse(data.toString());
+      
+      // 处理心跳响应
+      if (message.type === 'pong') {
+        this.lastPongTime = Date.now();
+        console.log('💓 收到Server心跳响应');
+        return;
+      }
+      
+      // 先触发通用消息事件
+      if (this.eventHandlers.onMessage) {
+        this.eventHandlers.onMessage(message);
+      }
+      
+      // 处理有ID的响应消息
+      if (message.id && this.messageHandlers.has(message.id)) {
+        const handler = this.messageHandlers.get(message.id);
+        handler(message);
+        this.messageHandlers.delete(message.id);
+        return;
+      }
+      
+    } catch (error) {
+      console.error('❌ 处理消息失败:', error.message);
+    }
+  }
+
+  // 启动心跳
+  startHeartbeat() {
+    this.stopHeartbeat();
+    
+    console.log('💓 启动插件心跳检测');
+    
+    this.heartbeatInterval = setInterval(() => {
+      if (this.isConnected()) {
+        this.sendHeartbeat();
+        
+        // 检查心跳超时
+        const now = Date.now();
+        if (now - this.lastPongTime > this.heartbeatIntervalMs + this.heartbeatTimeoutMs) {
+          console.error('❌ 心跳超时，主动断开连接');
+          this.ws.close();
+        }
+      }
+    }, this.heartbeatIntervalMs);
+  }
+
+  // 停止心跳
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+      console.log('💓 停止插件心跳检测');
+    }
+  }
+
+  // 发送心跳
+  sendHeartbeat() {
+    if (!this.isConnected()) {
+      return;
+    }
+
+    try {
+      const heartbeatMessage = {
+        type: 'ping',
+        timestamp: Date.now()
+      };
+      
+      this.ws.send(JSON.stringify(heartbeatMessage));
+      console.log('💓 发送插件心跳');
+    } catch (error) {
+      console.error('❌ 发送心跳失败:', error.message);
+    }
+  }
+
+  sendRequest(request) {
+    return new Promise((resolve, reject) => {
+      if (!this.isConnected()) {
+        reject(new Error('未连接到服务器'));
+        return;
+      }
+
+      const messageId = Date.now() + Math.random();
+      const message = {
+        id: messageId,
+        timestamp: Date.now(),
+        ...request
+      };
+
+      const timeout = setTimeout(() => {
+        this.messageHandlers.delete(messageId);
+        reject(new Error('请求超时'));
+      }, QIDAO_CONFIG.DEFAULTS.REQUEST_TIMEOUT);
+
+      this.messageHandlers.set(messageId, (response) => {
+        clearTimeout(timeout);
+        
+        if (response.code === 1) {
+          resolve(response.data);
+        } else {
+          reject(new Error(response.msg || '请求失败'));
+        }
+      });
+
+      this.ws.send(JSON.stringify(message));
+    });
+  }
+
+  async sendMessage(chatId, message, messageType = QIDAO_CONFIG.MESSAGE_TYPES.TEXT, url = null) {
+    return this.sendRequest({
+      action: 'sendMessage',
+      chatId,
+      message,
+      messageType,
+      url
+    });
+  }
+
+  async sendImageMessage(chatId, url) {
+    return this.sendMessage(chatId, '', QIDAO_CONFIG.MESSAGE_TYPES.IMAGE, url);
+  }
+
+  async getChatRoomOnlineUsers(chatId) {
+    return this.sendRequest({
+      action: 'chatRoomOnlineUsers',
+      chatId
+    });
+  }
+
+  async getUserOnlineStatus(targetUserId) {
+    return this.sendRequest({
+      action: 'userOnlineStatus',
+      targetUserId
+    });
+  }
+
+  /**
+   * 二维码认证流程 - 三步走
+   * 1. 请求生成二维码
+   * 2. 轮询扫码状态
+   * 3. 完成认证获取chatId
+   * @returns {Promise<{chatId: number, uid: number}>}
+   */
+  async qrAuth() {
+    if (!this.isConnected()) {
+      throw new Error('未连接到服务器');
+    }
+
+    console.log('🔐 开始二维码认证流程...');
+
+    // 步骤1: 请求生成二维码
+    console.log('📝 步骤1: 生成二维码...');
+    
+    // 使用sendRequest获取二维码数据
+    const qrData = await this.sendRequest({
+      action: 'startAuth'
+    });
+
+    console.log('✅ 二维码已生成:', qrData.qrUrl);
+    console.log('📱 请使用栖岛APP扫描二维码');
+
+    // 立即打开浏览器显示二维码
+    console.log('🌐 正在打开浏览器...');
+    this.openBrowser(qrData.qrUrl);
+
+    // 步骤2: 轮询扫码状态
+    console.log('⏳ 步骤2: 等待扫码...');
+    let scanResult;
+    let attempts = 0;
+    const maxAttempts = 60; // 最多等待5分钟
+
+    while (attempts < maxAttempts) {
+      await new Promise(resolve => setTimeout(resolve, 5000)); // 等待5秒
+      attempts++;
+
+      try {
+        const status = await this.sendRequest({
+          action: 'checkAuthStatus',
+          code: qrData.code
+        });
+
+        console.log(`🔍 检查状态 (${attempts}/${maxAttempts}):`, status.status);
+
+        if (status.status === 'success') {
+          console.log('✅ 扫码成功!');
+          scanResult = status;
+          break;
+        } else if (status.status === 'expired') {
+          throw new Error('二维码已过期，请重新生成');
+        }
+        // status === 'waiting' 继续等待
+      } catch (error) {
+        console.error('❌ 检查状态失败:', error.message);
+        throw error;
+      }
+    }
+
+    if (!scanResult || scanResult.status !== 'success') {
+      throw new Error('扫码超时，请重试');
+    }
+
+    // 步骤3: 完成认证（添加好友+获取chatId）
+    console.log('🔄 步骤3: 完成认证...');
+    const authResult = await this.sendRequest({
+      action: 'completeAuth',
+      uid: scanResult.uid
+    });
+
+    console.log('✅ 认证完成!');
+    console.log(`💬 ChatID: ${authResult.chatId}`);
+    console.log(`👤 UID: ${authResult.uid}`);
+
+    // 自动设置chatId
+    this.chatId = authResult.chatId;
+    this.userId = authResult.uid;
+    this.chatIdSet = true;
+
+    return {
+      chatId: authResult.chatId,
+      uid: authResult.uid
+    };
+  }
+
+  // 打开浏览器
+  openBrowser(url) {
+    let command;
+    const platform = os.platform();
+    
+    console.log('🌐 当前系统:', platform);
+    console.log('🌐 打开URL:', url);
+    
+    if (platform === 'win32') {
+      // Windows系统使用start命令
+      // 注意：需要使用cmd /c来执行start命令
+      command = `cmd /c start "" "${url}"`;
+    } else if (platform === 'darwin') {
+      // macOS系统使用open命令
+      command = `open "${url}"`;
+    } else {
+      // Linux系统使用xdg-open命令
+      command = `xdg-open "${url}"`;
+    }
+    
+    console.log('🌐 执行命令:', command);
+    
+    exec(command, (error, stdout, stderr) => {
+      if (error) {
+        console.error('❌ 打开浏览器失败:', error.message);
+        if (stderr) {
+          console.error('❌ 错误详情:', stderr);
+        }
+        console.log('📱 请手动复制以下链接到浏览器中打开:');
+        console.log(url);
+      } else {
+        console.log('✅ 浏览器已打开，请扫描二维码');
+      }
+    });
+  }
+
+  // 设置插件的chatId
+  async setChatId(chatId, userId = null) {
+    if (!this.isConnected()) {
+      throw new Error('未连接到服务器');
+    }
+
+    const setChatIdMessage = {
+      action: 'setChatId',
+      chatId: chatId,
+      userId: userId,
+      timestamp: Date.now()
+    };
+
+    return new Promise((resolve, reject) => {
+      const messageId = Date.now() + Math.random();
+      setChatIdMessage.id = messageId;
+
+      const timeout = setTimeout(() => {
+        this.messageHandlers.delete(messageId);
+        reject(new Error('设置chatId超时'));
+      }, QIDAO_CONFIG.DEFAULTS.REQUEST_TIMEOUT);
+
+      this.messageHandlers.set(messageId, (response) => {
+        clearTimeout(timeout);
+        
+        if (response.code === 1) {
+          console.log(`✅ 设置chatId成功: ${chatId}`);
+          resolve(response.data);
+        } else {
+          reject(new Error(response.msg || '设置chatId失败'));
+        }
+      });
+
+      this.ws.send(JSON.stringify(setChatIdMessage));
+    });
+  }
+}
+
+export default QidaoChannel;