qidao-openclaw-plugin 1.2.8 → 1.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qidao-openclaw-plugin",
-  "version": "1.2.8",
+  "version": "1.3.2",
   "type": "module",
   "main": "./src/index.js",
   "description": "OpenClaw 栖岛聊天 Channel 插件 - 连接到栖岛聊天服务",

package/src/index.js

@@ -6,6 +6,19 @@ 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',
@@ -19,6 +32,7 @@ const qidaoChannel = {
   
   capabilities: {
     chatTypes: ['direct', 'group'],
+    hasGateway: true,
   },
   
   config: {
@@ -126,37 +140,25 @@ const qidaoChannel = {
       }
     },
   },
-};
-
-export default function register(api) {
-  api.logger.info('栖岛聊天插件加载中...');
   
-  api.registerChannel({ plugin: qidaoChannel });
-  
-  // 注册认证命令
-  registerAuthCommand(api);
-  
-  // 延迟初始化，确保配置已加载
-  setTimeout(async () => {
-    try {
-      const cfg = api.getGatewayConfig?.() || {};
-      
-      // 调试日志
-      api.logger.info(`栖岛聊天配置: ${JSON.stringify(cfg.channels?.qidao || {})}`);
+  gateway: {
+    startAccount: async (ctx) => {
+      const { account, cfg, runtime, abortSignal } = ctx;
       
-      const account = qidaoChannel.config.resolveAccount(cfg);
+      runtime.log?.('🚀 栖岛聊天 gateway.startAccount 被调用！');
+      runtime.log?.(`账户信息: ${JSON.stringify(account)}`);
       
       if (!account.enabled) {
-        api.logger.info('栖岛聊天未启用');
+        runtime.log?.('栖岛聊天未启用');
         return;
       }
       
       if (!account.chatId) {
-        api.logger.warn('栖岛聊天缺少chatId配置');
+        runtime.log?.('栖岛聊天缺少chatId配置');
         return;
       }
       
-      api.logger.info(`连接栖岛聊天 (chatId: ${account.chatId})`);
+      runtime.log?.(`连接栖岛聊天 (chatId: ${account.chatId})`);
       
       connection = new QidaoChannel({
         serverUrl: account.serverUrl,
@@ -165,38 +167,127 @@ export default function register(api) {
       });
       
       connection.on('connect', () => {
-        api.logger.info('栖岛聊天已连接');
+        runtime.log?.('栖岛聊天已连接');
       });
       
       connection.on('disconnect', () => {
-        api.logger.warn('栖岛聊天已断开');
+        runtime.log?.('栖岛聊天已断开');
       });
       
       connection.on('error', (error) => {
-        api.logger.error(`栖岛聊天错误: ${error.message}`);
+        runtime.error?.(`栖岛聊天错误: ${error.message}`);
       });
       
-      connection.on('message', (message) => {
+      connection.on('message', async (message) => {
         if (message.type === 'new_message') {
-          api.ingestMessage({
-            channelId: 'qidao',
-            accountId: 'default',
-            senderId: message.senderId.toString(),
-            senderName: message.senderName,
-            text: message.messageText,
-            timestamp: message.timestamp,
-            chatType: message.chatType === 0 ? 'direct' : 'group',
-            chatId: message.chatId.toString(),
-          });
+          try {
+            // 过滤掉机器人自己发送的消息，避免循环
+            // 栖岛消息中，senderId=1 是畅小猪，otherUserId=175 是机器人
+            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,
+            });
+            
+            // 使用 core.channel.reply.dispatchReplyWithBufferedBlockDispatcher 处理消息
+            await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+              ctx: ctxPayload,
+              cfg,
+              dispatcherOptions: {
+                deliver: async (payload, info) => {
+                  runtime.log?.(`发送回复: ${payload.text.substring(0, 50)}...`);
+                  
+                  // 通过 connection 发送回复
+                  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();
       
-    } catch (error) {
-      api.logger.error(`栖岛聊天插件初始化失败: ${error.message}`);
-    }
-  }, 2000); // 延迟2秒，确保配置已加载
+      // 返回 Promise，保持连接直到被中止
+      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('栖岛聊天插件加载完成');
 }