qidao-openclaw-plugin 2.0.0-beta.1 → 2.0.2

package/src/index.js

@@ -1,512 +0,0 @@
-/**
- * 栖岛聊天 OpenClaw Channel 插件
- */
-
-import { QidaoChannel } from './qidao-channel.js';
-import { registerAuthCommand } from './auth-cli.js';
-import { DeviceFingerprint } from './device-fingerprint.js';
-
-let connection = null;
-let pluginApi = null;
-let qidaoRuntime = null;
-let recentSentMessages = new Set(); // 跟踪最近发送的消息，避免处理自己的回复
-
-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,
-        bindingToken: qidaoConfig.bindingToken,  // 设备绑定Token
-        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('配置已保存');
-      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 {
-        // 记录发送的消息，用于去重（包含chatId确保精确匹配）
-        const messageKey = `${chatId}_${text.trim()}_${Date.now()}`;
-        recentSentMessages.add(messageKey);
-        
-        // 清理5秒前的记录，避免内存泄漏
-        setTimeout(() => {
-          recentSentMessages.delete(messageKey);
-        }, 5000);
-        
-        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 || !account.bindingToken) {
-        if (!account.chatId) {
-          runtime.log?.('栖岛聊天需要配置，正在启动认证...');
-        } else {
-          runtime.log?.('需要重新认证，正在启动认证...');
-        }
-        
-        try {
-          // 动态导入认证模块
-          const ws = (await import('ws')).default;
-          const { spawn, execSync } = await import('child_process');
-          
-          // 创建临时连接到 Server 进行认证
-          const tempWs = new ws('wss://oc.qidao.chat/ws');
-          
-          // 🔐 初始化设备指纹
-          const deviceFP = new DeviceFingerprint();
-          // runtime.log?.('🔍 设备信息:', deviceFP.getDeviceInfo());
-          
-          const chatId = await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-              tempWs.close();
-              reject(new Error('连接超时'));
-            }, 10000);
-            
-            tempWs.on('open', () => {
-              clearTimeout(timeout);
-              // 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?.('正在启动本地二维码服务...');
-                  
-                  // 启动本地HTTP服务显示二维码
-                  try {
-                    const { createQRServer } = await import('./qr-server.js');
-                    const qrServerUrl = await createQRServer(qrUrl);
-                    
-                    runtime.log?.(`认证页面: ${qrServerUrl}`);
-                    
-                    // 打开浏览器显示二维码页面
-                    const openCommand = process.platform === 'win32' ? 'start' : 
-                                       process.platform === 'darwin' ? 'open' : 'xdg-open';
-                    spawn(openCommand, [qrServerUrl], { shell: true, detached: true });
-                    
-                  } catch (error) {
-                    runtime.error?.(`启动认证服务失败: ${error.message}`);
-                  }
-                  
-                  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?.('🔍 生成设备指纹...');
-                    const deviceFingerprint = deviceFP.generate();
-                    
-                    // 请求完成认证获取 chatId（包含设备指纹）
-                    tempWs.send(JSON.stringify({ 
-                      action: 'completeAuth', 
-                      uid, 
-                      code: tempWs._code,
-                      deviceFingerprint: deviceFingerprint  // 发送设备指纹
-                    }));
-                    
-                  } 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;
-                  const receivedBindingToken = message.data?.bindingToken || message.bindingToken;
-                  const receivedUid = message.data?.uid || message.uid;
-                  
-                  runtime.log?.(`认证完成！`);
-                  
-                  tempWs.close();
-                  
-                  // 关闭二维码服务器
-                  try {
-                    const { closeQRServer } = await import('./qr-server.js');
-                    closeQRServer();
-                  } catch (error) {
-                    // 忽略关闭服务器的错误
-                  }
-                  
-                  resolve({ 
-                    chatId: receivedChatId, 
-                    bindingToken: receivedBindingToken,
-                    uid: receivedUid
-                  });
-                  
-                } 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?.('正在保存配置...');
-          
-          // 🔐 保存设备绑定配置
-          let configCmd;
-          if (chatId.bindingToken) {
-            // runtime.log?.('💾 保存设备绑定配置');
-            configCmd = `openclaw config set channels.qidao.chatId ${chatId.chatId} && openclaw config set channels.qidao.bindingToken "${chatId.bindingToken}" && openclaw config set channels.qidao.enabled true`;
-          } else {
-            throw new Error('认证失败：未获取到设备Token');
-          }
-          
-          execSync(configCmd, { stdio: 'inherit' });
-          runtime.log?.('配置保存成功！');
-          
-          // 执行重启命令后直接退出
-          try {
-            execSync('openclaw gateway restart');
-          } catch (error) {
-            // 忽略重启错误，配置已经保存成功
-          }
-          
-          // 直接返回，不再继续后续流程
-          return;
-          
-        } catch (error) {
-          runtime.error?.(`认证失败: ${error.message}`);
-          throw new Error('栖岛聊天缺少chatId配置，请运行 openclaw qidao-auth 完成认证');
-        }
-      }
-      
-      // runtime.log?.(`连接栖岛聊天 (chatId: ${account.chatId})`);
-      
-      connection = new QidaoChannel({
-        serverUrl: account.serverUrl,
-        chatId: account.chatId,
-        userId: account.userId,
-        bindingToken: account.bindingToken,  // 设备绑定Token
-      });
-      
-      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 {
-            // 多用户系统消息去重：避免处理自己刚发送的回复消息
-            // 使用消息内容、chatId和时间戳进行精确去重判断
-            const messageContent = message.messageText?.trim();
-            const messageChatId = message.chatId;
-            
-            // 检查是否是最近发送的消息（5秒内，同一chatId）
-            const now = Date.now();
-            const messageKey = `${messageChatId}_${messageContent}`;
-            const isRecentMessage = Array.from(recentSentMessages).some(sentMsg => {
-              const [chatId, content, timestamp] = sentMsg.split('_');
-              return parseInt(chatId) === messageChatId && 
-                     content === messageContent && 
-                     (now - parseInt(timestamp)) < 5000;
-            });
-            
-            if (isRecentMessage) {
-              // runtime.log?.(`跳过自己刚发送的消息 (chatId: ${messageChatId}): ${messageContent?.substring(0, 30)}...`);
-              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') {
-                    // 记录发送的消息，用于去重（包含chatId确保精确匹配）
-                    const messageKey = `${message.chatId}_${payload.text.trim()}_${Date.now()}`;
-                    recentSentMessages.add(messageKey);
-                    
-                    // 清理5秒前的记录
-                    setTimeout(() => {
-                      recentSentMessages.delete(messageKey);
-                    }, 5000);
-                    
-                    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('栖岛聊天加载完成');
-}