@qihoo/tuitui-openclaw-channel 1.0.10 → 1.0.11

package/index.ts

@@ -1,7 +1,7 @@
 import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
 import { emptyPluginConfigSchema } from 'openclaw/plugin-sdk';
-import { createTuiTuiChannelPlugin } from './src/channel.js';
-import { CHANNEL_ID, CHANNEL_NAME } from './src/utils';
+import { createTuiTuiChannelPlugin } from './src/channel';
+import { CHANNEL_ID, CHANNEL_NAME } from './src/const';
 import { id } from './openclaw.plugin.json';
 
 const plugin = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qihoo/tuitui-openclaw-channel",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "maintainers": [
     {
       "name": "huzunjie",

package/src/channel.ts

@@ -10,19 +10,19 @@ import {
   setAccountEnabledInConfigSection,
   deleteAccountFromConfigSection,
 } from 'openclaw/plugin-sdk';
-import type { TuiTuiInboundMessage, TuiTuiOutboundDeliverOptions } from './types';
+import { CHANNEL_ID, CHANNEL_NAME } from "./const";
+
 import {
-  CHANNEL_ID,
-  CHANNEL_NAME,
-  buildMessageBody,
-  tuituiEmojiReaction,
   checkAccount,
   sendTextMsg,
   sendPageMsg,
   sendMediaMsg,
-} from "./utils";
+  guessChatType,
+} from "./outbound";
+
+import { handleInboundMessage } from './inbound';
 
-import { capabilities, configSchema } from './confs';
+import { capabilities, configSchema, baseFildsDefault } from './confs';
 
 const isEnabled = (val: any) => val === undefined || !!val;
 const isConfigured = (account: any)=> !!(account?.appId && account?.appSecret);
@@ -35,16 +35,17 @@ const resolveAccount = (cfg: any, accountId?: string | null) => {
     enabled: isEnabled(acct?.enabled),
     appId: acct?.appId as string | undefined,
     appSecret: acct?.appSecret as string | undefined,
-    dmPolicy: acct?.dmPolicy || 'pairing',
-    allowFrom: acct?.allowFrom || [],
+    dmPolicy: acct?.dmPolicy || baseFildsDefault.dmPolicy,
+    allowFrom: acct?.allowFrom || baseFildsDefault.allowFrom,
     // 群组策略与白名单、群组级覆盖
-    groupPolicy: (acct?.groupPolicy as string | undefined) ?? 'allowlist',
-    groupAllowFrom: acct?.groupAllowFrom || [],
-    groups: (acct?.groups as Record<string, { requireMention?: boolean, shouldReply?: boolean }> | undefined) ?? {},
+    groupPolicy: (acct?.groupPolicy as string | undefined) || baseFildsDefault.groupPolicy,
+    groupAllowFrom: acct?.groupAllowFrom || baseFildsDefault.groupAllowFrom,
+    requireMention: isEnabled(acct?.requireMention),
+    channelContext: acct?.channelContext || baseFildsDefault.channelContext,
   };
 };
-const isToGroup = (chatId: string) => /^\d+$/.test(chatId);
-const arrLowerCaseTrim = (arr: any[]) => arr.filter((v: any) => !!v).map((v: any) => String(v).toLowerCase().trim());
+const wsReadyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'] as const;
+let wsNumber = 0;
 
 export function createTuiTuiChannelPlugin(apiRuntime: any) {
   return {
@@ -91,48 +92,29 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
             ...cfg,
             channels: {
               ...cfg.channels,
-              [CHANNEL_ID]: { ...(cfg?.channels?.[CHANNEL_ID] ?? {}), enabled },
+              [CHANNEL_ID]: { ...(cfg.channels?.[CHANNEL_ID] ?? {}), enabled },
             },
           } : setAccountEnabledInConfigSection({
             cfg,
-            sectionKey: CHANNEL_ID,
-            accountId,
             enabled,
+            accountId,
+            sectionKey: CHANNEL_ID,
             allowTopLevel: true,
           });
       },
 
       deleteAccount: ({ cfg, accountId }: any) => {
-        return accountId === DEFAULT_ACCOUNT_ID
-          // For default account, we don't delete the entire config
-          // Instead, we disable it and clear sensitive fields
-          ? {
+        return accountId === DEFAULT_ACCOUNT_ID ? {
             ...cfg,
             channels: {
               ...cfg.channels,
               [CHANNEL_ID]: {
-                ...(cfg?.channels?.[CHANNEL_ID] ?? {}),
-                enabled: true,
-                appId: undefined,
-                appSecret: undefined,
+                ...(cfg.channels?.[CHANNEL_ID] ?? {}),
+                enabled: false, // 默认账户不删除，改为禁用，并重置配置字段
+                ...baseFildsDefault, // 重置基础配置字段，恢复默认值
               },
             },
-          }
-          // For named accounts, use the standard delete function
-          : deleteAccountFromConfigSection({
-            cfg,
-            sectionKey: CHANNEL_ID,
-            accountId,
-            clearBaseFields: [
-              'appId',
-              'appSecret',
-              'dmPolicy',
-              'allowFrom',
-              'groupPolicy',
-              'groupAllowFrom',
-              'groups',
-            ],
-          });
+          } : deleteAccountFromConfigSection({ cfg, accountId, sectionKey: CHANNEL_ID }); // 多账户状态下的配置信息，按 accountId 删除指定账户; 除非子账户影响根账户字段信息，否则不应该使用 clearBaseFields
       },
     },
 
@@ -160,7 +142,7 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
         let allowFromPath =`channels.${CHANNEL_ID}.`;
         if (accId !== DEFAULT_ACCOUNT_ID) allowFromPath += `accounts.${accId}.`;
 
-        const policy = account.dmPolicy ?? 'pairing';
+        const policy = account.dmPolicy ?? baseFildsDefault.dmPolicy; // 默认使用 baseFildsDefault 中的 dmPolicy
         // dmPolicy semantics:
         // - open: always allow everyone (["*"]), ignore allowFrom values.
         // - pairing: unknown senders get a pairing code; approvals add to allowFrom store.
@@ -171,7 +153,7 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
           allowFrom: policy === 'open' ? ['*'] : (account.allowFrom ?? []),
           policyPath: `${allowFromPath}dmPolicy`,
           allowFromPath,
-          approveHint: `openclaw pairing approve ${CHANNEL_ID} <code>`,
+          approveHint: `openclaw 配对校验信息，CHANNEL_ID: ${CHANNEL_ID}, AccountId: ${accountId}, code: <code>`,
           normalizeEntry: (raw: string) => raw.toLowerCase().trim(),
         };
       },
@@ -201,7 +183,7 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
         
         const chatId = String(to || '').trim();
         // Determine if this is a group message based on 'to' being all digits (group) or not (direct)
-        await sendTextMsg(account, chatId, isToGroup(chatId), text);
+        await sendTextMsg(account, chatId, guessChatType(chatId), text);
 
         return { channel: CHANNEL_ID, messageId: `tuitui-text-${Date.now()}`, chatId };
       },
@@ -216,11 +198,7 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
         }
 
         const chatId = String(to || '').trim();
-        // Determine if this is a group message
-        // WORKAROUND: OpenClaw core doesn't pass chatType/groupId to sendPayload.
-        // If `to` is a numeric string and chatType/groupId are undefined, assume it's a group.
-        const isGroup = chatType === 'group' || !!groupId || (isToGroup(chatId) && !chatType);
-        await sendPageMsg(account, chatId, isGroup, payload.page);
+        await sendPageMsg(account, chatId, guessChatType(chatId), payload.page);
 
         return { channel: CHANNEL_ID, messageId: `tuitui-page-${Date.now()}`, chatId };
       },
@@ -231,7 +209,7 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
 
         const chatId = String(to || '').trim();
         // Determine if this is a group message based on 'to' being all digits (group) or not (direct)
-        await sendMediaMsg(account, chatId, isToGroup(chatId), mediaUrl, 'tuitui.send.media');
+        await sendMediaMsg(account, chatId, guessChatType(chatId), mediaUrl, 'tuitui.send.media');
 
         return { channel: CHANNEL_ID, messageId: `tuitui-media-${Date.now()}`, chatId };
       },
@@ -247,367 +225,77 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
         const account = resolveAccount(cfg, accountId);
 
         if (!isEnabled(account.enabled)) {
-          log?.info?.(`[${CHANNEL_ID}] account ${accountId} is disabled, skipping`);
+          log?.info?.(`[${CHANNEL_ID}] AccountId ${accountId} is disabled, skipping`);
           return _setStatus();
         }
 
         if (!isConfigured(account)) {
-          log?.warn?.(`[${CHANNEL_ID}] account ${accountId} not fully configured (missing appId/appSecret)`);
+          log?.warn?.(`[${CHANNEL_ID}] AccountId ${accountId} not fully configured (missing appId/appSecret)`);
           return _setStatus();
         }
 
-        log?.info?.(`[${CHANNEL_ID}] Starting TuiTui channel (account: ${accountId})`);
+        log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, Starting TuiTui channel`);
         _setStatus({ running: true });
         let ws: any = null;
+        wsNumber++;
+        const wsId = `${wsNumber}-${Date.now()}`;
+        const wsEvtIds = new Set<string>();
+
         const wsUrl = `wss://im.live.360.cn:8282/robot/callback/ws?auth=${account.appId}.${account.appSecret}`;
         const defSendMsg = (msg: any) => {
-          log?.info?.('[${CHANNEL_ID}] WebSocket.Error 环境未就绪，消息发送失败', msg);
+          log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}].Error 环境未就绪，消息发送失败`, msg);
         };
         let _sendMsg = defSendMsg;
         const startWebSocket = () => {
-          log?.info?.(`[${CHANNEL_ID}] Registered WebSocket URL: ${wsUrl} for TuiTui`);
+          log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, 准备连接 WebSocket[${wsId}] URL: ${wsUrl}`);
           ws = new WebSocket(wsUrl, { rejectUnauthorized: true });
           ws.on('open', () => {
-            log?.info?.(`[${CHANNEL_ID}] WebSocket connect success`);
+            log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] connect success`);
             _setStatus({ running: true, connected: true });
             _sendMsg = (msg) => ws.send(msg);
           });
 
           // on receiving messages from tuitui websocket server
           ws.on('message', async (wsData: string) => {
-            let json = null;
+            let json: any = null;
             try {
               json = JSON.parse(wsData);
-              // 收到任意消息则回复一下，权当“收到”
-              if (json.event_id) _sendMsg(`{ "ack": "${json.event_id}" }`);
-            } catch(err) {
-              log?.warn?.(`[${CHANNEL_ID}] WebSocket Message Is Invalid JSON: ${wsData}`);
+            } catch {
+              log?.warn?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] Message Is Invalid JSON: ${wsData}`);
               return;
             }
-            const wsEvent = json?.body?.event;
-            const isKeepalive = wsEvent === 'keepalive';
-
-            // 心跳日志太多了，滤掉，异常信息上面 JSON.parse catch 会输出
-            if (!isKeepalive) log?.info?.(`[${CHANNEL_ID}] Received TuiTui WebSocket message: ${wsData}`);
-
-            // 忽略无效信息、心跳信息
-            if (!json?.header || !wsEvent || !json?.body?.data|| isKeepalive) return;
-
-            // Preferred TuiTui signature validation:
-            // X-Tuitui-Robot-Checksum = sha1(app_secret + timestamp + nonce + raw_json_body)
-            // Also verifies appid in header matches configured appId.
-            const { appId, appSecret } = account;
-            if (appSecret) {
-              const hdAppId = json.header['X-Tuitui-Robot-Appid'];
-              const hdTs = json.header['X-Tuitui-Robot-Timestamp'];
-              const hdNonce = json.header['X-Tuitui-Robot-Nonce'];
-              const hdChecksum = json.header['X-Tuitui-Robot-Checksum'];
-
-              if (!hdAppId || !hdTs || !hdNonce || !hdChecksum) {
-                log?.info?.(`[${CHANNEL_ID}] Missing TuiTui authentication headers`);
-                return;
-              }
-
-              if (appId && hdAppId !== appId) {
-                log?.info?.(`[${CHANNEL_ID}] Invalid appId`);
-                return;
-              }
+            const ack = json?.event_id;
+            if (!ack) {
+              return log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] missing event_id: ${ack}`);
             }
-
-            // Parse TuiTui message format
-            // userAccount: 推推用户账号，用于 tousers（发送消息的目标用户）
-            const msg = json.body as TuiTuiInboundMessage;
-            const msgData = msg.data;
-            let userAccount: string | undefined = msg.user_account;
-            let msgUid: string | undefined = msg.uid;
-            let msgUname: string | undefined = msg.user_name;
-            let chatType: 'direct' | 'group';
-            const chatTypeIsDirect = wsEvent === 'single_chat';
-            const chatTypeIsGroup = wsEvent === 'group_chat';
-            let text: string;
-            let groupId: string | undefined;
-            let groupName: string | undefined;
-            let mediaUrls: string[] | undefined;
-            let replyToId: string | undefined;
-            let suppressReply = false; // 是否抑制回复（用于 shouldReply: false 且没有 @ 机器人的情况）
-
-            // Handle different event types
-            if (chatTypeIsDirect) {
-              // Single chat message
-              chatType = 'direct';
-              text = buildMessageBody(msgData);
-
-              log?.debug?.(`[${CHANNEL_ID}] inbound single_chat user_account=${userAccount} uid=${msgUid} user_name=${msgUname}`);
-
-              const msgType = msgData.msg_type;
-              // Extract media URLs for image/voice/file messages
-              if ((msgType === 'image' || msgType === 'mixed') && msgData.images?.length) {
-                mediaUrls = msgData.images;
-              } else if (msgType === 'voice' && msgData.voice) {
-                mediaUrls = [msgData.voice];
-              } else if (msgType === 'file' && msgData.file?.url) {
-                mediaUrls = [msgData.file.url];
-              }
-
-              // Handle reference/reply
-              if (msgData.ref?.is_me && msgData.ref?.msgid) {
-                replyToId = msgData.ref.msgid;
-              }
-
-              if (!userAccount && !msgUid) {
-                log?.info?.(`[${CHANNEL_ID}] Missing user_account or uid in single_chat event`);
-                return;
-              }
-            } else if (chatTypeIsGroup) {
-              // Group chat message - only process if bot is mentioned
-              chatType = 'group';
-              groupId = msgData.group_id;
-              groupName = msgData.group_name;
-
-              log?.debug?.(`[${CHANNEL_ID}] inbound group_chat user_account=${userAccount} uid=${msgUid} user_name=${msgUname} group_id=${groupId}`);
-
-              // Group policy gating and @mention requirements
-              const groupPolicy = String(account.groupPolicy ?? "allowlist").toLowerCase();
-              const groupAllowFromRaw = Array.isArray(account.groupAllowFrom) ? account.groupAllowFrom : [];
-              const normalizedGroupAllowFrom = arrLowerCaseTrim(groupAllowFromRaw);
-              log?.debug?.(`[${CHANNEL_ID}] groupPolicy=${groupPolicy} groupId=${groupId} groupAllowFrom=${JSON.stringify(normalizedGroupAllowFrom)} at_me=${JSON.stringify(msgData.at_me)} at=${JSON.stringify(msgData.at)}`);
-
-              if (groupPolicy === 'disabled') return log?.info?.('Groups disabled');
-     
-              // 群消息处理策略
-              const groupCfg = account.groups?.[String(groupId)];
-
-              // @机器人触发策略
-              const requireMention = typeof groupCfg?.requireMention === 'boolean' ? groupCfg.requireMention : true;
-
-              // 是否需要回复
-              let shouldReply = typeof groupCfg?.shouldReply === 'boolean' ? groupCfg.shouldReply : true;
-
-              if (!userAccount || !groupId) {
-                log?.info?.(`[${CHANNEL_ID}] Missing user_account or group_id in group_chat event`);
-                return;
-              }
-              // 群消息处理逻辑：
-              // 1. requireMention: false, shouldReply: true  -> 接收所有群消息并自动回复（无论是否 @）
-              // 2. requireMention: true,  shouldReply: true  -> 仅当 @ 机器人时才触发 Agent 并回复，不 @ 的消息直接忽略
-              // 3. requireMention: true,  shouldReply: false -> 接收所有群消息触发 Agent，但仅当 @ 机器人时才回复
-
-              if (
-                // 消息中 @ 了机器人，必须触发 Agent 并回复（即使 shouldReply: false）
-                msgData.at_me ||
-                // 消息中没有 @ 机器人，但配置为自动回复（无需 @）
-                // 触发 Agent 并回复
-                !requireMention ||
-                // 消息中没有 @ 机器人，requireMention=true，shouldReply=false
-                // 触发 Agent 但不回复（Agent 可以处理消息，但 deliver 不会发送回复）
-                !shouldReply
-              ) {
-                text = buildMessageBody(msgData);
-                if (!shouldReply) suppressReply = true; // 标记为抑制回复
-                // 继续执行后续的 Agent 处理逻辑
-              } else {
-                // 默认情况：不 @ 机器人，requireMention=true，shouldReply=true
-                // 忽略消息
-                log?.info?.(`[${CHANNEL_ID}] ignore (not mentioned)`);
-                return;
-              }
-
-              if (!normalizedGroupAllowFrom.includes(String(groupId))) {
-                await sendTextMsg(account, groupId, true, `当前openclaw群聊策略为白名单，需要主人在群白名单(Group Allow From)增加当前群ID：\n${groupId}`, 'tuitui.groupPolicy.reply');
-                return;
-              }
-
-            } else {
-              log?.info?.(`[${CHANNEL_ID}] ignore unknown event ${wsEvent}`);
-              return;
+            if (wsEvtIds.has(ack)) {
+              // 主机卡顿 ack 答复不及时等，有可能收到服务端下发重复消息，如果收到则记录日志但不处理
+              return log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] Ignore duplicate message event_id: ${ack}`);
             }
-
-            // Enforce DM allowlist at ingress to guarantee closed policy blocks unauthorized senders.
-            // We intentionally enforce here (in addition to downstream guards) because plugin runtime
-            // paths may vary between local/dev/prod setups.
-
-            // DM access gating (pairing/allowlist/open/disabled)
-            const dmPolicy = String(account.dmPolicy ?? 'pairing').toLowerCase();
-            const configuredAllowFrom = Array.isArray(account.allowFrom) ? account.allowFrom : [];
-            const normalizedAllowFrom = arrLowerCaseTrim(configuredAllowFrom);
-            // 只使用 userAccount 作为匹配依据，因为用户希望 allowFrom 匹配 user_account
-            const senderForPolicy = userAccount ? String(userAccount).toLowerCase().trim() : '';
-            log?.debug?.(`[${CHANNEL_ID}] dmPolicy=${dmPolicy} userAccount=${userAccount} msgUid=${msgUid} senderForPolicy=${senderForPolicy} allowFrom=${JSON.stringify(normalizedAllowFrom)}`);
-
-            if (chatTypeIsDirect) {
-              if (dmPolicy === 'disabled') {
-                log?.warn?.(`[${CHANNEL_ID}] DM blocked (disabled) sender=${senderForPolicy}`);
-                return;
-              }
-
-              if (dmPolicy !== 'open') {
-                // Merge pairing-store entries unless policy is allowlist-only
-                let storeAllowFrom: string[] = [];
-                if (dmPolicy !== 'allowlist') {
-                  try {
-                    const res = await apiRuntime?.channel?.pairing?.readAllowFromStore?.({
-                      channel: CHANNEL_ID,
-                      accountId: account.accountId,
-                    });
-                    if (Array.isArray(res)) storeAllowFrom = arrLowerCaseTrim(res);
-                  } catch {}
-                }
-
-                // 只检查 userAccount 是否在 allowFrom 或 storeAllowFrom 中
-                const allowSet = new Set([...normalizedAllowFrom, ...storeAllowFrom]);
-                const isAllowed = userAccount ? allowSet.has(senderForPolicy) : false;
-
-                if (!isAllowed) {
-                  if (dmPolicy === 'pairing') {
-                    try {
-                      log?.debug?.(`[${CHANNEL_ID}] pairing flow: checking if pairing request exists for sender=${senderForPolicy}`);
-                      const req = await apiRuntime?.channel?.pairing?.upsertPairingRequest?.({
-                        channel: CHANNEL_ID,
-                        accountId: account.accountId,
-                        id: senderForPolicy,
-                      });
-                      log?.debug?.(
-                        `[${CHANNEL_ID}] pairing flow: upsertPairingRequest result=${JSON.stringify(req)}`,
-                      );
-                      /***
-                       * 把 req?.created 注释掉。不然一旦发消息失败，就进入死局。
-                       * 删除这个标志，只要没配对，会每次和机器人聊，都会返回配对信息。
-                      */
-                      if (/*req?.created && */ account.appId && account.appSecret) {
-                        const replyText =
-                          apiRuntime?.channel?.pairing?.buildPairingReply?.({
-                            channel: CHANNEL_ID,
-                            code: req.code,
-                          }) ?? '需要进行配对。请让机器人所有者进行批准。';
-
-                        // tousers 使用 userAccount（推推用户账号）
-                        const toUname = String(userAccount || '').trim();
-                        await sendTextMsg(account, toUname, false, replyText, 'tuitui.pairing.reply');
-                      }
-                    } catch (err) {
-                      log?.warn?.(`[${CHANNEL_ID}] pairing flow failed for ${senderForPolicy}: ${String(err)}` );
-                    }
-                    // Drop unauthorized DM after pairing challenge
-                    log?.info?.(`[${CHANNEL_ID}] pairing required`);
-                    return;
-                  }
-
-                  // dmPolicy=allowlist and sender not allowed
-                  log?.warn?.(`[${CHANNEL_ID}] Blocked unauthorized sender (allowlist): sender=${senderForPolicy} allowFrom=${JSON.stringify(normalizedAllowFrom)}`);
-                  return;
-                }
-              }
+            // 收到任意消息则回复一下，权当“收到”
+            _sendMsg(JSON.stringify({ ack }));
+            // 记录已收到消息的 event_id，避免重复处理同一消息导致的幂等性问题
+            wsEvtIds.add(ack);
+            // 为了防止 wsEvtIds 无限制增长，这里控制一下长度，超过 1000 则删除最早的一条记录（因为服务端目前最多会囤积1000条消息）
+            if (wsEvtIds.size > 1e3) {
+              const firsEvtId = wsEvtIds.values().next().value;
+              if (firsEvtId) wsEvtIds.delete(firsEvtId);
             }
 
-            // 表情回复。因为回复较慢，所以先回复一个表情
-            await tuituiEmojiReaction(account, chatTypeIsGroup ? groupId : userAccount, chatTypeIsGroup, msgData.msgid, '收到');
-
-            // Build MsgContext
-            // 优先使用 userAccount，如果为空则降级使用 msgUid
-            const senderId = userAccount || msgUid || 'unknown';
-            // 确保 accountId 有有效值，优先使用 account.accountId，其次使用 ctx 中的 accountId，最后使用 DEFAULT_ACCOUNT_ID
-
-            const effectiveAccountId = String(account.accountId || accountId || DEFAULT_ACCOUNT_ID || 'default');
-            const chatId = chatTypeIsGroup ? String(groupId) : String(senderId);
-
-            // 关于 sessionKey 格式的解释
-            // https://docs.openclaw.ai/channels/channel-routing
-            // 但 sessionKey 一般不要自己拼字符串，需要用系统api识别(根据 bindings)
-            const route = apiRuntime.channel.routing.resolveAgentRoute({
-              cfg: await apiRuntime.config.loadConfig(),
-              channel: CHANNEL_ID,
-              accountId: account.accountId,
-              peer: {
-                  kind: chatTypeIsGroup ? 'group' : 'direct',
-                  id: chatId,
-              },
-            });
-
-            const sessionKey = route.sessionKey;
-            console.log(`[${CHANNEL_ID}] chatType: ${chatType}, chatId ${chatId}, senderId: ${senderId}, accountId: ${accountId}, DEFAULT_ACCOUNT_ID: ${DEFAULT_ACCOUNT_ID}, effectiveAccountId: ${effectiveAccountId}`);
-            console.log(`[${CHANNEL_ID}] dispatching to agent session=${sessionKey}`);
-
-            const msgCtx: any = {
-              Body: text || ' ',
-              From: String(senderId),
-              To: CHANNEL_ID,
-              SessionId: String(sessionKey).replace(/\//g, '_'),
-              SessionKey: String(sessionKey).replace(/\//g, '_'),
-              AccountId: effectiveAccountId,
-              OriginatingChannel: CHANNEL_ID,
-              OriginatingTo: chatId,
-              ChatType: chatType,
-              Surface: CHANNEL_ID,
-              Provider: CHANNEL_ID,
-              SenderName: msgUname || String(senderId),
-              MsgUname: msgUname,
-              UserAccount: userAccount,
-            };
-
-            // Add group-specific fields
-            if (chatTypeIsGroup && groupId) {
-              msgCtx.GroupSubject = groupName;
-              msgCtx.GroupId = groupId;
-            }
+            const wsEvent = json?.body?.event;
+            if (wsEvent === 'keepalive') return;
 
-            // Add media URLs if present
-            if (mediaUrls?.length) msgCtx.MediaUrls = mediaUrls;
+            log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] Received message: ${wsData}`);
 
-            // Add reply context if present
-            if (replyToId) msgCtx.ReplyToId = replyToId;
+            if (!json?.header || !wsEvent || !json?.body?.data) {
+              return log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] invalid message`);
+            } 
 
-            // Dispatch via the SDK's buffered block dispatcher
             if (!apiRuntime) {
-              log?.error?.(`[${CHANNEL_ID}] TuiTuiRuntime error，未能发送回复。`);
-              return;
+              return log?.error?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] TuiTuiRuntime error`);
             }
-            await apiRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-              ctx: msgCtx,
-              cfg: await apiRuntime.config.loadConfig(),
-              dispatcherOptions: {
-                deliver: async (payload: TuiTuiOutboundDeliverOptions) => {
-
-                  // 如果设置了 suppressReply 标志，则不发送回复
-                  if (suppressReply) {
-                    log?.debug?.(`[${CHANNEL_ID}] Reply suppressed by configuration (shouldReply: false)`);
-                    return;
-                  }
-
-                  const chatTarget = chatTypeIsGroup ? groupId : userAccount;
-                  // Handle custom messages (e.g., page messages)
-                  if (payload.custom) {
-                    const { msgtype, page, tousers, togroups } = payload.custom;
-                    // Handle page message type
-                    if (msgtype === 'page' && page) {
-                      await sendPageMsg(account, chatTarget, chatTypeIsGroup, page, 'tuitui.deliver.page', tousers, togroups);
-                      return;
-                    }
-                    log?.warn?.(`[${CHANNEL_ID}] Unsupported custom message type: ${msgtype}`);
-                    return;
-                  }
-                  if (payload.mediaUrl || payload.mediaUrls?.length) {
-                    // Handle media messages
-                    const mediaUrl = payload.mediaUrl || payload.mediaUrls?.[0];
-                    if (mediaUrl) {
-                      const at = chatTypeIsGroup && userAccount ? [userAccount] : [];
-                      await sendMediaMsg(account, chatTarget, chatTypeIsGroup, mediaUrl, 'tuitui.deliver.media', at);
-                    }
-                    return;
-                  }
-                  // Handle text messages
-                  const replyText = payload?.text || payload?.body;
-                  if (replyText) {
-                    // at 使用 userAccount（群聊 @ 用户）
-                    const at = chatTypeIsGroup && userAccount ? [userAccount] : [];
-                    // 群消息回复时不再使用 reference_msgid 避免并发时引用错乱，依靠 @ 来提醒用户
-                    await sendTextMsg(account, chatTarget, chatTypeIsGroup, replyText, 'tuitui.deliver.text', at);
-                  }
-                },
-                onReplyStart: () => {
-                  log?.info?.(`[${CHANNEL_ID}] Agent reply started for ${userAccount ?? msgUid}`);
-                },
-              },
-            });
+
+            await handleInboundMessage({ json, account, apiRuntime, log });
           });
           
           const onErrOrClose = () => {
@@ -615,18 +303,18 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
             _setStatus({ running: false, connected: false });
             _sendMsg = defSendMsg;
             if (!abortSignal?.aborted) {
-              log?.warn?.(`[${CHANNEL_ID}] WebSocket Restart`);
+              log?.warn?.(`[${CHANNEL_ID}] WebSocket[${wsId}] Restart`);
               setTimeout(startWebSocket, 10e3); // 10秒后尝试重启
             }
           };
           ws.on('close', () => {
-            log?.info?.(`[${CHANNEL_ID}] WebSocket closed, ws.readyState(0:CONNECTING, 1:OPEN, 2:CLOSING, 3:CLOSED): ${ws?.readyState}`);
+            log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] closed, ws.readyState: ${wsReadyStates[ws?.readyState]}`);
             onErrOrClose();
           });
 
           // on socket errors
           ws.on('error', (err: any) => {
-            log?.warn?.(`[${CHANNEL_ID}] WebSocket error: ${err}, ws.readyState(0:CONNECTING, 1:OPEN, 2:CLOSING, 3:CLOSED): ${ws?.readyState}`);
+            log?.warn?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] error: ${err}, ws.readyState: ${wsReadyStates[ws?.readyState]}`);
             onErrOrClose();
           });
         };

package/src/command.ts

@@ -0,0 +1,29 @@
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+export default function registerCommand2Api(api: OpenClawPluginApi) {
+  api.registerCommand({
+    name: "mystatus",
+    description: "Show my plugin status",
+    handler: (ctx: any) => {
+        console.log('xxxxx', JSON.stringify(ctx.config.channels[ctx.channel]))
+      return {
+        text: `Status of TuiTui Plugin:
+        Channel: ${ctx.channel},
+        AccountId: ${ctx.accountId},
+        Time: ${new Date().toLocaleString()}`,
+      };
+    },
+  });
+  
+  // 带参数的命令
+  api.registerCommand({
+    name: "setBotName",
+    description: "Set bot name",
+    acceptsArgs: true,
+    requireAuth: true,
+    handler: async (ctx: any) => {
+      const mode = ctx.args?.trim() || "default";
+      ///await saveMode(mode);
+      return { text: `Mode set to: ${mode}` };
+    },
+  });
+}