npm - @qihoo/tuitui-openclaw-channel - Versions diffs - 1.0.18 → 1.0.19 - Mend

@qihoo/tuitui-openclaw-channel 1.0.18 → 1.0.19

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/openclaw.plugin.json CHANGED Viewed

@@ -6,5 +6,178 @@
     "type": "object",
     "additionalProperties": false,
     "properties": {}
+  },
+  "channelConfigs": {
+    "tuitui": {
+      "schema": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "enabled": { "type": "boolean", "default": true },
+          "appId": { "type": "string", "default": "" },
+          "appSecret": { "type": "string" },
+          "dmPolicy": {
+            "type": "string",
+            "default": "pairing",
+            "enum": ["pairing", "allowlist", "open", "disabled"]
+          },
+          "allowFrom": {
+            "type": "array",
+            "default": [],
+            "items": { "type": "string" }
+          },
+          "groupPolicy": {
+            "type": "string",
+            "default": "allowlist",
+            "enum": ["allowlist", "disabled"]
+          },
+          "requireMention": { "type": "boolean", "default": true },
+          "groupAllowFrom": {
+            "type": "array",
+            "default": [],
+            "items": { "type": "string" }
+          },
+          "channelContext": {
+            "type": "string",
+            "default": "thread",
+            "enum": ["channel", "thread"]
+          },
+          "emojiReaction": { "type": "boolean", "default": true },
+          "accounts": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "enabled": { "type": "boolean", "default": true },
+                "appId": { "type": "string", "default": "" },
+                "appSecret": { "type": "string" },
+                "dmPolicy": {
+                  "type": "string",
+                  "default": "pairing",
+                  "enum": ["pairing", "allowlist", "open", "disabled"]
+                },
+                "allowFrom": {
+                  "type": "array",
+                  "default": [],
+                  "items": { "type": "string" }
+                },
+                "groupPolicy": {
+                  "type": "string",
+                  "default": "allowlist",
+                  "enum": ["allowlist", "disabled"]
+                },
+                "requireMention": { "type": "boolean", "default": true },
+                "groupAllowFrom": {
+                  "type": "array",
+                  "items": { "type": "string" }
+                },
+                "channelContext": {
+                  "type": "string",
+                  "default": "thread",
+                  "enum": ["channel", "thread"]
+                },
+                "emojiReaction": { "type": "boolean", "default": true }
+              }
+            }
+          }
+        }
+      },
+      "uiHints": {
+        "enabled": { "order": 1, "help": "开启或关闭" },
+        "appId": {
+          "help": "推推机器人身份 AppId（你可以推推搜索【推推机器人助手】，和它聊天自助申请推推机器人）",
+          "order": 2
+        },
+        "appSecret": {
+          "help": "推推机器人密钥 Secret（推推机器人的 App Secret）",
+          "order": 3
+        },
+        "dmPolicy": {
+          "help": "私聊策略（pairing=配对（默认）；allowlist=白名单；open=允许所有（不安全）；disabled=禁用私聊）",
+          "order": 10,
+          "advanced": true
+        },
+        "allowFrom": {
+          "help": "私聊白名单-域账号（dmPolicy=allowlist 时生效；pairing 下可用于显式放行用户）。对群聊/团队也能生效",
+          "order": 11,
+          "advanced": true
+        },
+        "groupPolicy": {
+          "help": "群聊/团队策略（allowlist=白名单；disabled=禁用）",
+          "order": 12,
+          "advanced": true
+        },
+        "requireMention": {
+          "help": "群组/团队是否需要 @ 机器人才触发 Agent（默认 true）。注意：如果你关闭了这个开关，且有多个龙虾机器人在同一个群里，他们会聊的停不下来",
+          "order": 13,
+          "advanced": true
+        },
+        "groupAllowFrom": {
+          "help": "群组/团队白名单-包含群ID、团队ID或频道ID（仅在 groupPolicy=allowlist 生效）",
+          "order": 14,
+          "advanced": true
+        },
+        "channelContext": {
+          "help": "团队-频道上下文（channel=每个频道共享上下文; thread=每个帖子使用独立上下文）。修改后对后续对话生效，对历史数据不生效。",
+          "order": 15,
+          "advanced": true
+        },
+        "emojiReaction": {
+          "help": "在收到消息后，大模型给出反应结果前，先对原消息发送一个\"收到\"的表情回复。",
+          "order": 16,
+          "advanced": true
+        },
+        "accounts": {
+          "help": "Accounts（多账户配置）",
+          "order": 30,
+          "advanced": true
+        },
+        "accounts.*.enabled": { "order": 301, "help": "开启或关闭" },
+        "accounts.*.appId": {
+          "help": "推推机器人身份 AppId（你可以推推搜索【推推机器人助手】，和它聊天自助申请推推机器人）",
+          "order": 302
+        },
+        "accounts.*.appSecret": {
+          "help": "推推机器人密钥 Secret（推推机器人的 App Secret）",
+          "order": 303
+        },
+        "accounts.*.dmPolicy": {
+          "help": "私聊策略（pairing=配对（默认）；allowlist=白名单；open=允许所有（不安全）；disabled=禁用私聊）",
+          "order": 304,
+          "advanced": true
+        },
+        "accounts.*.allowFrom": {
+          "help": "私聊白名单-推推域账号（dmPolicy=allowlist 时生效；pairing 下可用于显式放行用户）；对群、团队也生效",
+          "order": 305,
+          "advanced": true
+        },
+        "accounts.*.groupPolicy": {
+          "help": "群聊/团队策略（allowlist=白名单；disabled=禁用）",
+          "order": 306,
+          "advanced": true
+        },
+        "accounts.*.requireMention": {
+          "help": "群组/团队是否需要 @ 机器人才触发 Agent（默认 true）",
+          "order": 307,
+          "advanced": true
+        },
+        "accounts.*.groupAllowFrom": {
+          "help": "群组/团队白名单-包含群ID、团队ID或频道ID（仅在 groupPolicy=allowlist 生效）。如果不想所有人使用，可以配置私聊白名单，私聊白名单对群/团队仍然有效",
+          "order": 308,
+          "advanced": true
+        },
+        "accounts.*.channelContext": {
+          "help": "团队-频道上下文（channel=每个频道共享上下文; thread=每个帖子使用独立上下文）",
+          "order": 309,
+          "advanced": true
+        },
+        "accounts.*.emojiReaction": {
+          "help": "在收到消息后，大模型给出反应结果前，先对原消息发送一个\"收到\"的表情回复。",
+          "order": 310,
+          "advanced": true
+        }
+      }
+    }
   }
-}
+}

package/package.json CHANGED Viewed

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

package/src/accounts.ts CHANGED Viewed

@@ -1,24 +1,28 @@
 import { parseAllowFroms, isEnabled } from './utils';
-import { baseFildsDefault } from './confs';
 import { CHANNEL_ID } from './const';
 import { DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk/account-id';
+export const dmPolicyDefault = 'pairing';
+export const getDefaultAccountConfig = (acct?: any) => ({
+  enabled: isEnabled(acct?.enabled),
+  appId: acct?.appId || '',
+  appSecret: acct?.appSecret || undefined, // 避免默认值覆盖用户输入的空字符串 Secret 空字串系统也会认为是已填写
+  dmPolicy: acct?.dmPolicy || dmPolicyDefault,
+  allowFrom: parseAllowFroms(acct?.allowFrom || []),
+  // 群组策略与白名单、群组级覆盖
+  groupPolicy: acct?.groupPolic || 'allowlist',
+  groupAllowFrom: parseAllowFroms(acct?.groupAllowFrom || []),
+  requireMention: isEnabled(acct?.requireMention ?? true),
+  channelContext: acct?.channelContext || 'thread',
+  emojiReaction: isEnabled(acct?.emojiReaction ?? true),
+});
 export const resolveAccount = (cfg: any, accountId?: string | null) => {
-  const channelConfig = cfg?.channels?.[CHANNEL_ID] || {};
-  const targetId = accountId || DEFAULT_ACCOUNT_ID;
-  const acct = targetId === DEFAULT_ACCOUNT_ID ? channelConfig : channelConfig.accounts?.[targetId];
-  return {
-    accountId: targetId,
-    enabled: isEnabled(acct?.enabled),
-    appId: acct?.appId || '',
-    appSecret: acct?.appSecret || '',
-    dmPolicy: acct?.dmPolicy || baseFildsDefault.dmPolicy,
-    allowFrom: parseAllowFroms(acct?.allowFrom || baseFildsDefault.allowFrom),
-    // 群组策略与白名单、群组级覆盖
-    groupPolicy: acct?.groupPolic || baseFildsDefault.groupPolicy,
-    groupAllowFrom: parseAllowFroms(acct?.groupAllowFrom || baseFildsDefault.groupAllowFrom),
-    requireMention: isEnabled(acct?.requireMention ?? baseFildsDefault.requireMention),
-    channelContext: acct?.channelContext || baseFildsDefault.channelContext,
-    emojiReaction: isEnabled(acct?.emojiReaction ?? baseFildsDefault.emojiReaction),
-  };
-};
+  accountId = accountId || DEFAULT_ACCOUNT_ID;
+  let currAccount = cfg?.channels?.[CHANNEL_ID] || {};
+  if (accountId && accountId !== DEFAULT_ACCOUNT_ID) {
+    currAccount = currAccount.accounts?.[accountId];
+  }
+  return { accountId, ...getDefaultAccountConfig(currAccount) };
+};

package/src/channel.ts CHANGED Viewed

@@ -3,7 +3,6 @@
  *
  * Implements the ChannelPlugin interface following the Synology Chat pattern.
  */
-import WebSocket from 'ws';
 import { DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk/account-id';
 import { setAccountEnabledInConfigSection, deleteAccountFromConfigSection } from 'openclaw/plugin-sdk/core';
 import { CHANNEL_ID, CHANNEL_NAME } from "./const";
@@ -14,16 +13,14 @@ import {
   sendMediaMsg,
   guessChatType,
 } from "./outbound";
-import { handleInboundMessage } from './inbound';
-import { capabilities, configSchema, baseFildsDefault } from './confs';
-import { resolveAccount } from "./accounts"
+import createWebSocket from './websocket';
+import { channelConfigs } from '../openclaw.plugin.json';
 import { isEnabled } from './utils';
+import { dmPolicyDefault, resolveAccount, getDefaultAccountConfig } from "./accounts"
 const isConfigured = (account: any)=> !!(account?.appId && account?.appSecret);
-const wsReadyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'] as const;
-let wsNumber = 0;
-const checkTuiTuiConfig = async (apiRuntime: any) => {
+const checkAndSetDefaultTuiTuiConfig = async (apiRuntime: any) => {
   const cfg = await apiRuntime.config.loadConfig();
   const channels = cfg?.channels || {};
   const currChannel = channels?.[CHANNEL_ID] || {};
@@ -34,8 +31,7 @@ const checkTuiTuiConfig = async (apiRuntime: any) => {
         ...channels,
         [CHANNEL_ID]: {
           ...currChannel,
-          ...baseFildsDefault,
-          appSecret: undefined,
+          ...getDefaultAccountConfig(),
         }
       }
     });
@@ -43,7 +39,7 @@ const checkTuiTuiConfig = async (apiRuntime: any) => {
 };
 export function createTuiTuiChannelPlugin(apiRuntime: any) {
-  checkTuiTuiConfig(apiRuntime);
+  checkAndSetDefaultTuiTuiConfig(apiRuntime);
   return {
     id: CHANNEL_ID,
     meta: {
@@ -55,8 +51,19 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
       blurb: `Connect to ${CHANNEL_NAME} bot via WebSocket`,
       order: 100,
     },
-    capabilities,
-    configSchema,
+    /*** 能力清单配置 ***/
+    capabilities: {
+      chatTypes: ['direct' as const, 'group' as const],
+      media: true,
+      threads: false,
+      reactions: false,
+      edit: false,
+      unsend: false,
+      reply: true,
+      effects: false,
+      blockStreaming: false,
+    },
+    configSchema: channelConfigs.tuitui,
     reload: { configPrefixes: [`channels.${CHANNEL_ID}`] },
     config: {
@@ -105,8 +112,8 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
               ...cfg.channels,
               [CHANNEL_ID]: {
                 ...(cfg.channels?.[CHANNEL_ID] ?? {}),
+                ...getDefaultAccountConfig(), // 重置基础配置字段，恢复默认值
                 enabled: false, // 默认账户不删除，改为禁用，并重置配置字段
-                ...baseFildsDefault, // 重置基础配置字段，恢复默认值
               },
             },
           } : deleteAccountFromConfigSection({ cfg, accountId, sectionKey: CHANNEL_ID }); // 多账户状态下的配置信息，按 accountId 删除指定账户; 除非子账户影响根账户字段信息，否则不应该使用 clearBaseFields
@@ -144,7 +151,7 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
         let allowFromPath =`channels.${CHANNEL_ID}.`;
         if (accId !== DEFAULT_ACCOUNT_ID) allowFromPath += `accounts.${accId}.`;
-        const policy = account.dmPolicy ?? baseFildsDefault.dmPolicy; // 默认使用 baseFildsDefault 中的 dmPolicy
+        const policy = account.dmPolicy ?? dmPolicyDefault;
         // dmPolicy semantics:
         // - open: always allow everyone (["*"]), ignore allowFrom values.
         // - pairing: unknown senders get a pairing code; approvals add to allowFrom store.
@@ -240,97 +247,22 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
         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>();
-        let wsRetryTimerId: any = 0;
-        const wsUrl = `wss://im.live.360.cn:8282/robot/callback/ws?auth=${account.appId}.${account.appSecret}`;
-        const defSendMsg = (msg: any) => {
-          log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}].Error 环境未就绪，消息发送失败`, msg);
-        };
-        let _sendMsg = defSendMsg;
-        const startWebSocket = () => {
-          log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, 准备连接 WebSocket[${wsId}] URL: ${wsUrl}`);
-          ws = new WebSocket(wsUrl, { rejectUnauthorized: true });
-          ws.on('open', () => {
-            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: any = null;
-            try {
-              json = JSON.parse(wsData);
-            } catch {
-              log?.warn?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] Message Is Invalid JSON: ${wsData}`);
-              return;
-            }
-            const ack = json?.event_id;
-            if (!ack) {
-              return log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] missing event_id: ${ack}`);
-            }
-            if (wsEvtIds.has(ack)) {
-              // 主机卡顿 ack 答复不及时等，有可能收到服务端下发重复消息，如果收到则记录日志但不处理
-              return log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] Ignore duplicate message event_id: ${ack}`);
-            }
-            // 收到任意消息则回复一下，权当“收到”
-            _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);
-            }
-            const wsEvent = json?.body?.event;
-            if (wsEvent === 'keepalive') return;
-            log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}], Received event ${wsEvent}, body ${JSON.stringify(json?.body, null, 2)}`);
-            if (!json?.header || !wsEvent || !json?.body?.data) {
-              return log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] invalid message`);
-            }
-            if (!apiRuntime) {
-              return log?.error?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] TuiTuiRuntime error`);
-            }
-            await handleInboundMessage({ json, account, apiRuntime, log });
-          });
-          const onErrOrClose = () => {
-            if (ws && ws.readyState !== WebSocket.CLOSED) ws.close(); // 关闭超时链接，防止产生多个
-            _setStatus({ running: false, connected: false });
-            _sendMsg = defSendMsg;
-            if (!abortSignal?.aborted) {
-              log?.warn?.(`[${CHANNEL_ID}] WebSocket[${wsId}] Restart`);
-              if (wsRetryTimerId) clearTimeout(wsRetryTimerId);
-              wsRetryTimerId = setTimeout(startWebSocket, 10e3); // 10秒后尝试重启
-            }
-          };
-          ws.on('close', () => {
-            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}] AccountId: ${accountId}, WebSocket[${wsId}] error: ${err}, ws.readyState: ${wsReadyStates[ws?.readyState]}`);
-            onErrOrClose();
-          });
-        };
-        startWebSocket();
+        // 创建 WebSocket 连接，并得到在需要时关闭该连接的方法。
+        const _closeWs = createWebSocket({
+          account,
+          log,
+          abortSignal,
+          apiRuntime,
+          onConnected: () => _setStatus({ running: true, connected: true }),
+          onDisconnected: () => _setStatus({ running: false, connected: false }),
+        });
-        // Keep the account running until abortSignal is triggered
+        // 保持账户运行状态，直至触发“abortSignal”信号为止。
         await new Promise<void>((resolve) => {
           const _onAbort = () => {
             log?.info?.(`[${CHANNEL_ID}] AccountId ${accountId} stopping (abort signal)`);
-            if (ws && ws.readyState !== WebSocket.CLOSED) ws.close();
+            _closeWs();
             resolve();
           };
           if (abortSignal?.aborted) return _onAbort();

package/src/inbound.ts CHANGED Viewed

@@ -176,6 +176,20 @@ async function sendSingleChatPairingMsg(account: any, payload: any, log: any, ap
   }
 }
+//目标存在于私聊白名单或配对存储中
+async function isAllowFrom(chatId: any, apiRuntime: any, account: InboundAccount) {
+  if(!chatId) return false;
+  const { accountId, allowFrom } = account;
+  let storeAllowFrom: string[] = [];
+  try {
+    storeAllowFrom = parseAllowFroms(
+      await apiRuntime?.channel?.pairing?.readAllowFromStore?.({ channel: CHANNEL_ID, accountId })
+    );
+  } catch {}
+  return [...allowFrom, ...storeAllowFrom].includes(chatId);
+}
 /**
  * 处理单聊（single_chat）、群聊、团队帖子分支，直接修改并校验 payload。
  * 返回 false 表示消息不合法，外层应提前 return；返回 true 表示校验通过，继续执行。
@@ -183,7 +197,7 @@ async function sendSingleChatPairingMsg(account: any, payload: any, log: any, ap
 const parseAndVerifyPayload: Record<string, Function> = {
   single_chat: async (payload: ChatPayload, msgData: any, account: InboundAccount, apiRuntime: any, log: any): Promise<boolean> => {
     const { accountId, dmPolicy, allowFrom } = account;
-    const chatId     = payload.tuituiAccount ? String(payload.tuituiAccount || '').toLowerCase().trim() : '';
+    const chatId = payload.tuituiAccount ? String(payload.tuituiAccount || '').toLowerCase().trim() : '';
     if (dmPolicy === 'disabled') {  //['pairing', 'allowlist', 'open', 'disabled'],
       log?.warn?.(`[${CHANNEL_ID}] AccountId: ${accountId}, DM disabled sender=${chatId}`);
       return false;
@@ -208,15 +222,8 @@ const parseAndVerifyPayload: Record<string, Function> = {
     if (dmPolicy === 'open') return true;
-    let storeAllowFrom: string[] = [];
-    try {
-      storeAllowFrom = parseAllowFroms(
-        await apiRuntime?.channel?.pairing?.readAllowFromStore?.({ channel: CHANNEL_ID, accountId })
-      );
-    } catch {}
-    if(chatId && [...allowFrom, ...storeAllowFrom].includes(chatId)) {
-      return true; // isAllowed：单聊目标存在于白名单或配对存储中
+    if(await isAllowFrom(chatId, apiRuntime, account)){
+      return true;
     }
     if (dmPolicy === 'pairing') {
@@ -236,9 +243,10 @@ const parseAndVerifyPayload: Record<string, Function> = {
     payload.groupName = msgData.group_name;
     payload.msgId  = msgData.msgid;
     payload.text = parseChatMessageBody(msgData);
+    const { tuituiAccount } = payload;
     log?.debug?.(
       `[${CHANNEL_ID}] AccountId: ${accountId}, inbound group_chat:
-      tuituiAccount=${payload.tuituiAccount},
+      tuituiAccount=${tuituiAccount},
       tuituiUid=${payload.tuituiUid},
       tuituiUserName=${payload.tuituiUserName},
       groupId=${chatId},
@@ -252,34 +260,39 @@ const parseAndVerifyPayload: Record<string, Function> = {
       return false;
     }
-    if (!payload.tuituiAccount || !chatId) {
+    if (!tuituiAccount || !chatId) {
       log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, Missing tuituiAccount or chatId in group_chat event`);
       return false;
     }
     if (!msgData.at_me && account.requireMention) {
       log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, ignore group message (not mentioned), add to history key: ${chatId}`);
-      await addUnmentionedHistory(apiRuntime, accountId, chatId, payload.tuituiUserName, payload.tuituiAccount, payload.text, payload.timestamp);
+      await addUnmentionedHistory(apiRuntime, accountId, chatId, payload.tuituiUserName, tuituiAccount, payload.text, payload.timestamp);
       return false;
     }
+    // 私聊白名单对群聊仍然生效，当群里只想特定人@时，可以不配置groupAllowFrom，而是配置 allowFrom
+    if(await isAllowFrom(tuituiAccount, apiRuntime, account)){
+      return true;
+    }
     if (!groupAllowFrom.includes(chatId)) {
       if (needPairingThrottle(accountId, chatId)) {
         log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, group pairing throttled for groupId=${chatId}`);
         return false;
       }
-      await sendTextMsg(
-        account,
-        chatId,
-        payload.chatType,
-        `当前openclaw（AccountId: ${accountId}）群聊策略为白名单，需要主人在群白名单(Group Allow From)增加当前群ID：\n${chatId}`,
-        'tuitui.groupPolicy.reply',
-      );
+      const msgTxt=`当前 OpenClaw（AccountId: ${accountId}）的群聊策略为白名单模式。
+需由龙虾主人在配置中添加白名单（两种方式二选一即可）：
+- 允许群中所有人用，在群白名单（Group Allow From）添加当前群ID： ${chatId}
+- 不想群所有人用，只想特定人用，在私聊白名单(Allow From)添加当前用户 ${payload.tuituiAccount} ，私聊白名单对群仍然有效`
+      await sendTextMsg(account, chatId, payload.chatType, msgTxt, 'tuitui.groupPolicy.reply');
       return false;
     }
     return true;
   },
   teams_post_create: async (payload: ChatPayload, msgData: any, account: InboundAccount, apiRuntime: any, log: any): Promise<boolean> => {
@@ -293,9 +306,10 @@ const parseAndVerifyPayload: Record<string, Function> = {
     payload.text      = content;
     payload.channelName = channel_name;
     payload.replyToId = "";
+    const { tuituiAccount } = payload;
     log?.debug?.(
       `[${CHANNEL_ID}] AccountId: ${accountId}, inbound teams:
-      tuituiAccount=${payload.tuituiAccount},
+      tuituiAccount=${tuituiAccount},
       tuituiUid=${payload.tuituiUid},
       tuituiUserName=${payload.tuituiUserName},
       chatId=${chatId},
@@ -310,17 +324,22 @@ const parseAndVerifyPayload: Record<string, Function> = {
       return false;
     }
-    if (!payload.tuituiAccount) {
+    if (!tuituiAccount) {
       log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, Missing tuituiAccount or chatId in event`);
       return false;
     }
     if (!msgData.at_me && account.requireMention) {
       log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, ignore teams post (not mentioned), add to history key: ${chatId}`);
-      await addUnmentionedHistory(apiRuntime, accountId, chatId, payload.tuituiUserName, payload.tuituiAccount, payload.text, payload.timestamp);
+      await addUnmentionedHistory(apiRuntime, accountId, chatId, payload.tuituiUserName, tuituiAccount, payload.text, payload.timestamp);
       return false;
     }
+    // 私聊白名单对团队仍然生效，限制特定人@时，可以不配置groupAllowFrom，而是配置 allowFrom
+    if(await isAllowFrom(tuituiAccount, apiRuntime, account)){
+      return true;
+    }
     if (!groupAllowFrom.includes(String(team_id)) && !groupAllowFrom.includes(String(channel_id)) ) {
       if (!msgData.at_me) {
         // 解决这个case：requireMention=false时，团队里发任意帖子都会回复加白，搞得没法用
@@ -332,13 +351,15 @@ const parseAndVerifyPayload: Record<string, Function> = {
         log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, teams pairing throttled for teamsChatId=${chatId}`);
         return false;
       }
-      await sendTextMsg(
-        account,
-        chatId,
-        payload.chatType,
-        `当前openclaw（AccountId: ${accountId}）群聊/团队策略为白名单，需要主人在群白名单(Group Allow From)增加当前团队ID: ${team_id} 或者频道ID: ${channel_id} 如果配置团队ID指当前团队下所有频道都可以使用，如果配置频道ID则仅此频道可使用`,
-        'tuitui.groupPolicy.reply',
-      );
+      const msgTxt=`当前 OpenClaw（AccountId: ${accountId}）的群聊/团队策略为白名单模式。
+需由龙虾主人在配置中添加白名单（3种方式选一种即可）：
+- 允许团队中所有人用，在群白名单（Group Allow From）添加当前团队ID: ${team_id}
+- 仅允许当前频道使用，在群白名单（Group Allow From）添加当前频道ID: ${channel_id}
+- 仅允许特定人使用，在私聊白名单(Allow From)添加当前用户: ${payload.tuituiAccount} ，私聊白名单对团队仍然有效`
+      await sendTextMsg(account, chatId, payload.chatType, msgTxt, 'tuitui.groupPolicy.reply');
       return false;
     }

package/src/outbound.ts CHANGED Viewed

@@ -250,43 +250,37 @@ export async function tuituiEmojiReaction(
 ): Promise<void> {
   const payload = {
     msgtype: 'emoji_reaction',
-    tousers: [] as TuiTuiSingleEmojiReactionTarget[],
-    togroups: [] as TuiTuiGroupEmojiReactionTarget[],
-    toteams: [] as TuiTuiTeamsTarget[],
     emoji_reaction: { emoji, cancel: false},
-  };
+  } as any;
   if(chatType == CHAT_TYPE_GROUP) {
-    payload.togroups.push({ group: target, msgid });
+    payload.togroups = [{ group: target, msgid }] as TuiTuiGroupEmojiReactionTarget[];
   } else if(chatType == CHAT_TYPE_DIRECT) {
-    payload.tousers.push({ user: target, msgid });
+    payload.tousers = [{ user: target, msgid }] as TuiTuiSingleEmojiReactionTarget[];
   } else {
-    var toteam = teamsParseChatId(target);
-    toteam.parent_id = "";
-    toteam.post_id = msgid;
-    payload.toteams.push(toteam);
+    payload.toteams = [{ ...teamsParseChatId(target), parent_id: '', post_id: msgid }] as TuiTuiTeamsTarget[];
   }
   const { appId: appid, appSecret: secret } = account;
+  const toTarget = (payload.togroups || payload.tousers || payload.toteams)[0];
+  const _logTxt =`[${CHANNEL_ID}] emoji_reaction "${emoji}"`;
+  console.log(`${_logTxt} request`, toTarget);
   const sendUrl = addParams2Url('https://im.live.360.cn:8282/robot/message/custom/modify', { appid, secret });
-  console.log('tuitui emoji_reaction request', payload);
   const { response, release } = await _fetchJson(sendUrl, payload, 'tuitui.emoji_reaction');
   try {
-    const body = await response.text().catch(() => "");
-    console.log('tuitui emoji_reaction response', body);
+    const body = JSON.parse(await response.text().catch(() => "{}"));
+    console.log(`${_logTxt} response errcode=${body.errcode} errmsg=${body.errmsg}`, toTarget);
   } catch (err) {
-    console.error(`[${CHANNEL_ID}] tuituiEmojiReaction Caught exception:`, err)
+    console.error(`${_logTxt} Caught exception:`, err)
   } finally {
     await release();
   }
 }
 export function teamsBuildChatId(team_id: string, channel_id:string, thread_id:string) : string{
-  if(thread_id) {
-    return `teams_${team_id}_${channel_id}_${thread_id}`;
-  } else {
-    return `teams_${team_id}_${channel_id}`;
-  }
+  let ret = `teams_${team_id}_${channel_id}`;
+  if(thread_id) ret += `_${thread_id}`;
+  return ret;
 }
 export function teamsParseChatId(chatId: string): TuiTuiTeamsTarget {
@@ -443,11 +437,11 @@ export async function sendMediaMsg(
   const targets = getTargets(chatId, chatType);
   if (chatType == CHAT_TYPE_CHANNEL) {
-    var content = "";
-    if (isImage){
+    let content = '';
+    if (isImage) {
       content = `![]({{tuitui_image "${fid}"}})`;
     } else {
-      content = `[${filename}]({{tuitui_file "${fid}"}})`;
+      content = `[${filename}]({{tuitui_file "${fid}"}})`
     }
     const msg: TuiTuiOutboundTeamsMarkdownMessage = {
       ...targets,

package/src/websocket.ts ADDED Viewed

@@ -0,0 +1,110 @@
+import WebSocket from 'ws';
+import { CHANNEL_ID } from "./const";
+import { handleInboundMessage } from './inbound';
+const wsReadyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'] as const;
+let wsNum = 0;
+export default function createWebSocket({ account, log, abortSignal, onConnected, onDisconnected, apiRuntime }: any): () => void {
+  const { accountId, appId, appSecret } = account;
+  let ws: any = null;
+  const _closeWS = () => ws && ws.readyState !== WebSocket.CLOSED && ws.close();
+  wsNum++;
+  const wsId = `${wsNum}-${Date.now()}`;
+  let _retryTimerId: any = 0;
+  const _clearRetryTimer = () => _retryTimerId && clearTimeout(_retryTimerId);
+  let _timeoutId: any = 0;
+  const _clearTimeoutTimer = () => _timeoutId && clearTimeout(_timeoutId);
+  const wsEvtIds = new Set<string>();
+  const wsUrl = `wss://im.live.360.cn:8282/robot/callback/ws?auth=${appId}.${appSecret}`;
+  const _startWS = () => {
+    _closeWS(); // 启动新链接前先关闭旧链接，防止产生空指针链接
+    log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, 准备连接 WebSocket[${wsId}] URL: ${wsUrl}`);
+    const _restartWS = (ts: number = 1e4) => {
+      if (abortSignal?.aborted) return;
+      log?.warn?.(`[${CHANNEL_ID}] WebSocket[${wsId}] Restart`);
+      _clearRetryTimer();
+      _retryTimerId = setTimeout(_startWS, ts);
+    };
+    _clearTimeoutTimer();
+    _timeoutId = setTimeout(() => {
+      log?.warn?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] Connection Timeout`);
+      _closeWS();
+      _restartWS(1e3);
+    }, 3e4); // 30秒连接超时
+    ws = new WebSocket(wsUrl);
+    ws.on('open', () => {
+      log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] connect success`);
+      _clearTimeoutTimer();
+      onConnected();
+    });
+    // on receiving messages from tuitui websocket server
+    ws.on('message', (wsData: string) => {
+      let json: any = null;
+      try {
+        json = JSON.parse(wsData);
+      } catch {
+        log?.warn?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] Message Is Invalid JSON: ${wsData}`);
+        return;
+      }
+      const ack = json?.event_id;
+      if (!ack) return log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] missing event_id: ${ack}`);
+      // 收到任意消息则回复一下，权当“收到”
+      ws.send(JSON.stringify({ ack }));
+      if (wsEvtIds.has(ack)) {
+        // 主机卡顿 ack 答复不及时等，有可能收到服务端下发重复消息，如果收到则记录日志但不处理
+        return log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] Ignore duplicate message event_id: ${ack}`);
+      }
+      // 记录已收到消息的 event_id，避免重复处理同一消息导致的幂等性问题
+      wsEvtIds.add(ack);
+      // 为了防止 wsEvtIds 无限制增长，这里控制一下长度，超过 1000 则删除最早的一条记录（因为服务端目前最多会囤积1000条消息）
+      if (wsEvtIds.size > 1e3) {
+        const firsEvtId = wsEvtIds.values().next().value;
+        if (firsEvtId) wsEvtIds.delete(firsEvtId);
+      }
+      const wsEvent = json?.body?.event;
+      if (wsEvent === 'keepalive') return;
+      console.log(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}], Received event ${wsEvent}, json.body:`, json?.body);
+      if (!json?.header || !wsEvent || !json?.body?.data) {
+        return log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] invalid message`);
+      }
+      if (!apiRuntime) {
+        return log?.error?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] TuiTuiRuntime error`);
+      }
+      handleInboundMessage({ json, account, apiRuntime, log });
+    });
+    const onErrOrClose = (errStr: string) => {
+      log?.info?.(`[${CHANNEL_ID}] AccountId: ${accountId}, WebSocket[${wsId}] ${errStr}, ws.readyState: ${wsReadyStates[ws?.readyState]}`);
+      _closeWS(); // 关闭已异常或超时的连接，防止产生多个（超时并不会主动关闭或断开）
+      _clearTimeoutTimer(); // 清除连接超时计时器，防止误触发
+      _restartWS(1e4); // 不是主动终止的，则10秒后尝试重启
+      onDisconnected();
+    };
+    ws.on('close', () => onErrOrClose('closed'));
+    ws.on('error', (err: any) => onErrOrClose(`error: ${err}`));
+  };
+  _startWS();
+  // 返回一个函数，调用它可以关闭 WebSocket 连接并清除重试计时器
+  return () => {
+    _clearRetryTimer();
+    _closeWS();
+  };
+}

package/src/confs.ts DELETED Viewed

@@ -1,146 +0,0 @@
-/*** 能力清单配置 ***/
-export const capabilities = {
-  chatTypes: ['direct' as const, 'group' as const],
-  media: true,
-  threads: false,
-  reactions: false,
-  edit: false,
-  unsend: false,
-  reply: true,
-  effects: false,
-  blockStreaming: false,
-};
-/*** 一些配置字段设定信息 ***/
-const baseFields = {
-  appId: { type: 'string', default: '' } ,
-  appSecret: { type: 'string', default: '' },
-  dmPolicy: {
-    type: 'string',
-    default: 'pairing',
-    enum: ['pairing', 'allowlist', 'open', 'disabled'],
-  },
-  allowFrom: {
-    type: 'array',
-    default: [],
-    items: { type: 'string' }
-  },
-  groupPolicy: {
-    type: 'string',
-    default: 'allowlist',
-    enum: ['allowlist', 'disabled']
-  },
-  requireMention: {
-    type: 'boolean',
-    default: true,
-  },
-  groupAllowFrom: {
-    type: 'array',
-    default: [],
-    items: { type: 'string' }
-  },
-  channelContext: {
-    type: 'string',
-    default: 'thread',
-    enum: ['channel', 'thread']
-  },
-  emojiReaction: {
-    type: 'boolean',
-    default: true,
-  },
-};
-const baseFieldsKeys = Object.keys(baseFields);
-export const baseFildsDefault = {} as Record<string, any>;
-baseFieldsKeys.forEach(k => baseFildsDefault[k] = (baseFields as any)[k].default);
-const fields = {
-  enabled: { type: 'boolean', default: true },
-  ...baseFields,
-};
-const fieldsUiHints = {
-    // 基础配置（优先显示）
-    enabled: { order: 1, help: '开启或关闭' },
-    appId: {
-      help: '推推机器人身份 AppId（你可以推推搜索【推推机器人助手】，和它聊天自助申请推推机器人）',
-      order: 2,
-    },
-    appSecret: {
-      help: '推推机器人密钥 Secret（推推机器人的 App Secret）',
-      order: 3,
-    },
-    // 高级配置
-    dmPolicy: {
-      help: '私聊策略（pairing=配对（默认）；allowlist=白名单；open=允许所有（不安全）；disabled=禁用私聊）',
-      order: 10,
-      advanced: true,
-    },
-    allowFrom: {
-      help: '私聊白名单-域账号（dmPolicy=allowlist 时生效；pairing 下可用于显式放行用户）',
-      order: 11,
-      advanced: true,
-    },
-    groupPolicy: {
-      help: '群聊/团队策略（allowlist=白名单；disabled=禁用）',
-      order: 12,
-      advanced: true,
-    },
-    requireMention: {
-      help: '群组/团队是否需要 @ 机器人才触发 Agent（默认 true）。注意：如果你关闭了这个开关，且有多个龙虾机器人在同一个群里，他们会聊的停不下来',
-      order: 13,
-      advanced: true,
-    },
-    groupAllowFrom: {
-      help: '群组/团队白名单-包含群ID、团队ID或频道ID（仅在 groupPolicy=allowlist 生效）',
-      order: 14,
-      advanced: true,
-    },
-    channelContext: {
-      help: '团队-频道上下文（channel=每个频道共享上下文; thread=每个帖子使用独立上下文）。修改后对后续对话生效，对历史数据不生效。',
-      order: 15,
-      advanced: true,
-    },
-    emojiReaction: {
-      help: '在收到消息后，大模型给出反应结果前，先对原消息发送一个”收到“的表情回复。',
-      order: 16,
-      advanced: true,
-    },
-};
-/* 多账户管理 */
-const accountsFieldsUiHints = {} as Record<string, any>;
-function isValidObjKey(key: string | number | symbol , object: object): key is keyof typeof object {
-  return key in object;
-}
-for (const k in fieldsUiHints) {
-  if (isValidObjKey(k, fieldsUiHints)) accountsFieldsUiHints[`accounts.*.${k}` as string] = fieldsUiHints[k];
-}
-export const configSchema = {
-  schema: {
-    type: 'object',
-    additionalProperties: false,
-    properties: {
-      ...fields,
-      /* 基础配置信息中，准备 accounts 配置支持多账户管理 */
-      accounts: {
-        type: 'object',
-        additionalProperties: {
-          type: 'object',
-          additionalProperties: false,
-          properties: { ...fields },
-        },
-      },
-    },
-  },
-  uiHints: {
-    ...fieldsUiHints,
-    /* 基础配置信息中，准备 accounts 配置支持多账户管理 */
-    accounts: {
-      help: 'Accounts（多账户配置）',
-      order: 30,
-      advanced: true
-    },
-    ...accountsFieldsUiHints,
-  },
-};