qidao-openclaw-plugin 1.3.4 → 2.0.0-beta.2

package/src/index.js

@@ -1,458 +0,0 @@
-/**
- * 栖岛聊天 OpenClaw Channel 插件
- */
-
-import { QidaoChannel } from './qidao-channel.js';
-import { registerAuthCommand } from './auth-cli.js';
-
-let connection = null;
-let pluginApi = null;
-let qidaoRuntime = null;
-
-function setQidaoRuntime(r) {
-  qidaoRuntime = r;
-}
-
-function getQidaoRuntime() {
-  if (!qidaoRuntime) {
-    throw new Error('Qidao runtime not initialized - plugin not registered');
-  }
-  return qidaoRuntime;
-}
-
-const qidaoChannel = {
-  id: 'qidao',
-  
-  meta: {
-    id: 'qidao',
-    label: '栖岛聊天',
-    selectionLabel: '栖岛聊天 (Qidao Chat)',
-    blurb: '连接到栖岛聊天服务',
-  },
-  
-  capabilities: {
-    chatTypes: ['direct', 'group'],
-    hasGateway: true,
-  },
-  
-  config: {
-    listAccountIds: () => ['default'],
-    
-    resolveAccount: (cfg) => {
-      const qidaoConfig = cfg.channels?.qidao ?? {};
-      
-      return {
-        accountId: 'default',
-        enabled: qidaoConfig.enabled !== false,
-        chatId: qidaoConfig.chatId,
-        userId: qidaoConfig.userId,
-        serverUrl: 'wss://oc.qidao.chat/ws', // 固定的服务器地址
-      };
-    },
-  },
-  
-  onboarding: {
-    getStatus: async ({ cfg }) => {
-      const qidaoConfig = cfg.channels?.qidao ?? {};
-      const configured = Boolean(qidaoConfig.chatId);
-      
-      return {
-        channel: 'qidao',
-        configured,
-        statusLines: [`栖岛聊天: ${configured ? `已配置 (chatId: ${qidaoConfig.chatId})` : '未配置'}`],
-        selectionHint: configured ? '已配置' : '需要配置',
-      };
-    },
-    
-    configure: async ({ cfg, prompter }) => {
-      const qidaoConfig = cfg.channels?.qidao ?? {};
-      
-      // 如果已经有 chatId，询问是否重新认证
-      if (qidaoConfig.chatId) {
-        const reauth = await prompter.confirm({
-          message: `已配置 chatId: ${qidaoConfig.chatId}，是否重新配置？`,
-          default: false,
-        });
-        
-        if (!reauth) {
-          return { cfg, accountId: 'default' };
-        }
-      }
-      
-      // 提示用户
-      console.log('');
-      console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-      console.log('');
-      console.log('  📱 栖岛聊天配置');
-      console.log('');
-      console.log('  推荐使用二维码认证（自动获取 chatId）：');
-      console.log('');
-      console.log('    请退出此向导（按 Ctrl+C），然后运行：');
-      console.log('');
-      console.log('      openclaw qidao-auth');
-      console.log('');
-      console.log('  或者继续手动输入 chatId');
-      console.log('');
-      console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-      console.log('');
-      
-      const chatIdInput = await prompter.text({
-        message: '请输入栖岛 Chat ID (或按 Ctrl+C 退出后使用 openclaw qidao-auth):',
-        default: qidaoConfig.chatId?.toString() || '',
-      });
-      
-      // 检查输入是否为空或只有空格
-      if (!chatIdInput || chatIdInput.trim() === '') {
-        console.log('');
-        console.log('未输入 chatId，取消配置');
-        console.log('');
-        console.log('提示：运行 openclaw qidao-auth 使用二维码认证');
-        console.log('');
-        return { cfg };
-      }
-      
-      const chatId = parseInt(chatIdInput.trim());
-      
-      // 构建新配置
-      const newCfg = {
-        ...cfg,
-        channels: {
-          ...cfg.channels,
-          qidao: {
-            enabled: true,
-            chatId,
-          },
-        },
-      };
-      
-      console.log('');
-      console.log('✅ 配置已保存:', newCfg.channels.qidao);
-      console.log('');
-      console.log('请重启 Gateway 以应用配置：');
-      console.log('  openclaw gateway restart');
-      console.log('');
-      
-      return { cfg: newCfg, accountId: 'default' };
-    },
-  },
-  
-  outbound: {
-    deliveryMode: 'direct',
-    
-    sendText: async ({ text, chatId }) => {
-      if (!connection || !connection.isConnected()) {
-        return { ok: false, error: '未连接到栖岛服务' };
-      }
-      
-      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 };
-      }
-    },
-  },
-  
-  gateway: {
-    startAccount: async (ctx) => {
-      const { account, cfg, runtime, abortSignal } = ctx;
-      
-      runtime.log?.('🚀 栖岛聊天 gateway.startAccount 被调用！');
-      runtime.log?.(`账户信息: ${JSON.stringify(account)}`);
-      
-      if (!account.enabled) {
-        runtime.log?.('栖岛聊天未启用');
-        return;
-      }
-      
-      if (!account.chatId) {
-        runtime.log?.('');
-        runtime.log?.('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        runtime.log?.('');
-        runtime.log?.('  📱 栖岛聊天需要配置');
-        runtime.log?.('');
-        runtime.log?.('  正在启动二维码认证...');
-        runtime.log?.('');
-        runtime.log?.('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        runtime.log?.('');
-        
-        try {
-          // 动态导入认证模块
-          const ws = (await import('ws')).default;
-          const { spawn } = await import('child_process');
-          
-          // 创建临时连接到 Server 进行认证
-          const tempWs = new ws('wss://oc.qidao.chat/ws');
-          
-          const chatId = await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-              tempWs.close();
-              reject(new Error('连接超时'));
-            }, 10000);
-            
-            tempWs.on('open', () => {
-              clearTimeout(timeout);
-              runtime.log?.('✅ 已连接到认证服务器');
-              runtime.log?.('');
-              
-              // 请求生成二维码
-              tempWs.send(JSON.stringify({ action: 'startAuth' }));
-            });
-            
-            tempWs.on('message', async (data) => {
-              try {
-                const message = JSON.parse(data.toString());
-                
-                // 兼容Server的响应格式
-                if ((message.code === 1 && message.data && message.data.qrUrl) || 
-                    (message.action === 'authStarted')) {
-                  const code = message.data?.code || message.code;
-                  const qrUrl = message.data?.qrUrl || message.qrUrl;
-                  
-                  runtime.log?.('📱 请使用栖岛 APP 扫描二维码：');
-                  runtime.log?.('');
-                  runtime.log?.(`   ${qrUrl}`);
-                  runtime.log?.('');
-                  runtime.log?.('正在打开浏览器...');
-                  runtime.log?.('');
-                  
-                  // 打开浏览器显示二维码
-                  const openCommand = process.platform === 'win32' ? 'start' : 
-                                     process.platform === 'darwin' ? 'open' : 'xdg-open';
-                  spawn(openCommand, [qrUrl], { shell: true, detached: true });
-                  
-                  runtime.log?.('⏳ 等待扫码...');
-                  runtime.log?.('');
-                  
-                  // 开始轮询扫码状态
-                  const pollInterval = setInterval(() => {
-                    tempWs.send(JSON.stringify({ action: 'checkAuthStatus', code }));
-                  }, 2000);
-                  
-                  // 保存轮询定时器以便后续清理
-                  tempWs._pollInterval = pollInterval;
-                  tempWs._code = code;
-                  
-                } else if ((message.code === 1 && message.data && message.data.status) ||
-                           (message.action === 'authStatus')) {
-                  const status = message.data?.status || message.status;
-                  const uid = message.data?.uid || message.uid;
-                  
-                  if (status === 'success') {
-                    runtime.log?.('✅ 扫码成功！');
-                    runtime.log?.('');
-                    
-                    // 请求完成认证获取 chatId
-                    tempWs.send(JSON.stringify({ 
-                      action: 'completeAuth', 
-                      uid, 
-                      code: tempWs._code 
-                    }));
-                    
-                  } else if (status === 'waiting') {
-                    // 继续等待
-                  }
-                  
-                } else if ((message.code === 1 && message.data && message.data.chatId) ||
-                           (message.action === 'authCompleted')) {
-                  // 清理轮询定时器
-                  if (tempWs._pollInterval) {
-                    clearInterval(tempWs._pollInterval);
-                  }
-                  
-                  const receivedChatId = message.data?.chatId || message.chatId;
-                  runtime.log?.(`🎉 认证完成！您的 chatId: ${receivedChatId}`);
-                  runtime.log?.('');
-                  
-                  tempWs.close();
-                  resolve(receivedChatId);
-                  
-                } else if (message.code === 0 || message.action === 'error') {
-                  if (tempWs._pollInterval) {
-                    clearInterval(tempWs._pollInterval);
-                  }
-                  tempWs.close();
-                  const errorMsg = message.msg || message.message || '认证失败';
-                  reject(new Error(errorMsg));
-                }
-              } catch (err) {
-                runtime.error?.('处理消息失败:', err);
-                reject(err);
-              }
-            });
-            
-            tempWs.on('error', (error) => {
-              clearTimeout(timeout);
-              if (tempWs._pollInterval) {
-                clearInterval(tempWs._pollInterval);
-              }
-              reject(error);
-            });
-          });
-          
-          // 自动保存配置
-          runtime.log?.('正在保存配置...');
-          runtime.log?.('');
-          
-          const { execSync } = await import('child_process');
-          execSync(`openclaw config set channels.qidao.chatId ${chatId}`, { stdio: 'inherit' });
-          
-          runtime.log?.('');
-          runtime.log?.('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-          runtime.log?.('');
-          runtime.log?.('  ✅ 配置完成！Gateway 将自动重新连接...');
-          runtime.log?.('');
-          runtime.log?.('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-          runtime.log?.('');
-          
-          // 更新 account 对象
-          account.chatId = chatId;
-          
-        } catch (error) {
-          runtime.error?.('');
-          runtime.error?.('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-          runtime.error?.('');
-          runtime.error?.(`  ❌ 认证失败: ${error.message}`);
-          runtime.error?.('');
-          runtime.error?.('  请运行以下命令重新认证：');
-          runtime.error?.('');
-          runtime.error?.('    openclaw qidao-auth');
-          runtime.error?.('');
-          runtime.error?.('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-          runtime.error?.('');
-          
-          // 抛出错误以停止自动重试
-          throw new Error('栖岛聊天缺少chatId配置，请运行 openclaw qidao-auth 完成认证');
-        }
-      }
-      
-      runtime.log?.(`连接栖岛聊天 (chatId: ${account.chatId})`);
-      
-      connection = new QidaoChannel({
-        serverUrl: account.serverUrl,
-        chatId: account.chatId,
-        userId: account.userId,
-      });
-      
-      connection.on('connect', () => {
-        runtime.log?.('栖岛聊天已连接');
-      });
-      
-      connection.on('disconnect', () => {
-        runtime.log?.('栖岛聊天已断开');
-      });
-      
-      connection.on('error', (error) => {
-        runtime.error?.(`栖岛聊天错误: ${error.message}`);
-      });
-      
-      connection.on('message', async (message) => {
-        if (message.type === 'new_message') {
-          try {
-            // 过滤掉机器人自己发送的消息，避免循环
-            if (message.senderId === 175 || message.otherUserId === 1) {
-              runtime.log?.(`跳过机器人自己的消息`);
-              return;
-            }
-            
-            runtime.log?.(`收到栖岛消息: ${message.messageText}`);
-            
-            const core = getQidaoRuntime();
-            
-            const chatId = message.chatId.toString();
-            const chatType = message.chatType === 0 ? 'direct' : 'group';
-            
-            const route = core.channel.routing.resolveAgentRoute({
-              cfg,
-              channel: 'qidao',
-              accountId: account.accountId,
-              peer: {
-                kind: chatType,
-                id: chatId,
-              },
-            });
-            
-            const ctxPayload = core.channel.reply.finalizeInboundContext({
-              Body: message.messageText,
-              RawBody: message.messageText,
-              CommandBody: message.messageText,
-              MessageSid: message.messageId?.toString() || `${Date.now()}`,
-              From: chatType === 'group' ? `qidao:group:${chatId}` : `qidao:${message.senderId}`,
-              To: `qidao:${chatId}`,
-              SenderId: message.senderId.toString(),
-              SessionKey: route.sessionKey,
-              AccountId: account.accountId,
-              ChatType: chatType,
-              ConversationLabel: chatType === 'group' ? `group:${chatId}` : `user:${message.senderId}`,
-              Timestamp: message.timestamp || Date.now(),
-              Provider: 'qidao',
-              Surface: 'qidao',
-              OriginatingChannel: 'qidao',
-              OriginatingTo: `qidao:${chatId}`,
-              CommandAuthorized: true,
-            });
-            
-            await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-              ctx: ctxPayload,
-              cfg,
-              dispatcherOptions: {
-                deliver: async (payload, info) => {
-                  runtime.log?.(`发送回复: ${payload.text.substring(0, 50)}...`);
-                  
-                  if (info.kind === 'final') {
-                    await connection.sendMessage(message.chatId, payload.text);
-                  }
-                },
-                onError: (err, info) => {
-                  runtime.error?.(`回复失败 (${info.kind}): ${err.message}`);
-                },
-              },
-            });
-            
-            runtime.log?.('✅ 消息处理完成');
-          } catch (error) {
-            runtime.error?.(`处理消息失败: ${error.message}`);
-          }
-        }
-      });
-      
-      if (abortSignal) {
-        abortSignal.addEventListener('abort', () => {
-          runtime.log?.('栖岛聊天连接被中止');
-          if (connection) {
-            connection.disconnect();
-            connection = null;
-          }
-        });
-      }
-      
-      await connection.connect();
-      
-      return new Promise((resolve) => {
-        if (abortSignal) {
-          abortSignal.addEventListener('abort', resolve);
-        }
-      });
-    },
-  },
-};
-
-export default function register(api) {
-  pluginApi = api;
-  
-  // 设置 runtime（参考企业微信插件）
-  setQidaoRuntime(api.runtime);
-  
-  api.logger.info('栖岛聊天插件加载中...');
-  
-  api.registerChannel({ plugin: qidaoChannel });
-  
-  // 注册认证命令
-  registerAuthCommand(api);
-  
-  api.logger.info('栖岛聊天插件加载完成');
-}

package/src/plugin.js

@@ -1,205 +0,0 @@
-/**
- * 栖岛聊天 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('栖岛聊天插件加载完成');
-}