@agent-wechat/wechat 0.7.10 → 0.8.1

package/README.md

@@ -146,8 +146,8 @@ All config lives under `channels.wechat` in OpenClaw's config file:
 | `dmPolicy` | `"open" \| "allowlist" \| "disabled"` | `"disabled"` | Who can DM the bot |
 | `allowFrom` | string[] | `[]` | wxid allowlist for DMs (when policy is `allowlist`) |
 | `groupPolicy` | `"open" \| "allowlist" \| "disabled"` | `"disabled"` | Group message policy |
-| `groupAllowFrom` | string[] | `[]` | wxid allowlist for group senders |
-| `groups` | object | `{}` | Per-group overrides (e.g. `{ "id@chatroom": { "requireMention": false } }`) |
+| `groupAllowFrom` | string[] | `[]` | Global allowlist of group sender IDs (`wxid_...`) |
+| `groups` | object | `{}` | Per-group overrides (e.g. `{ "id@chatroom": { "requireMention": false, "enabled": true, "groupPolicy": "allowlist", "allowFrom": ["wxid_..."] } }`) |
 | `pollIntervalMs` | integer | `1000` | Message polling interval |
 | `authPollIntervalMs` | integer | `30000` | Auth status check interval |
 

package/dist/index.js

@@ -1085,6 +1085,12 @@ import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID2 } from "openclaw/plugin-sdk";
 
 // src/types.ts
+function normalizeDmPolicy(policy) {
+  return policy === "allowlist" || policy === "open" || policy === "disabled" ? policy : "disabled";
+}
+function normalizeGroupPolicy(policy) {
+  return policy === "open" || policy === "disabled" || policy === "allowlist" ? policy : "disabled";
+}
 var DEFAULT_POLL_INTERVAL_MS = 1e3;
 var DEFAULT_AUTH_POLL_INTERVAL_MS = 3e4;
 var DEFAULT_ACCOUNT_ID = "default";
@@ -1096,9 +1102,9 @@ function resolveWeChatAccount(cfg, accountId) {
     enabled: wechat.enabled !== false,
     serverUrl: wechat.serverUrl,
     token: wechat.token,
-    dmPolicy: wechat.dmPolicy ?? "disabled",
+    dmPolicy: normalizeDmPolicy(wechat.dmPolicy),
     allowFrom: wechat.allowFrom ?? [],
-    groupPolicy: wechat.groupPolicy ?? "disabled",
+    groupPolicy: normalizeGroupPolicy(wechat.groupPolicy),
     groupAllowFrom: wechat.groupAllowFrom ?? [],
     groups: wechat.groups ?? {},
     pollIntervalMs: wechat.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
@@ -1204,6 +1210,13 @@ var WeChatClient = class {
   async openChat(chatId, clearUnreads) {
     return this.post(`/api/chats/${encodeURIComponent(chatId)}/open${qs({ clearUnreads })}`);
   }
+  // ---- Contacts ----
+  async listContacts(limit, offset) {
+    return this.get(`/api/contacts${qs({ limit, offset })}`);
+  }
+  async findContacts(name) {
+    return this.get(`/api/contacts/find${qs({ name })}`);
+  }
   // ---- Messages ----
   async listMessages(chatId, limit, offset) {
     return this.get(`/api/messages/${encodeURIComponent(chatId)}${qs({ limit, offset })}`);
@@ -5498,6 +5511,172 @@ var agentConfigSchema = external_exports.object({
 
 // src/monitor.ts
 import { createReplyPrefixOptions } from "openclaw/plugin-sdk";
+
+// src/access-control.ts
+import {
+  buildChannelKeyCandidates,
+  resolveAllowlistProviderRuntimeGroupPolicy,
+  resolveChannelEntryMatchWithFallback,
+  resolveDefaultGroupPolicy,
+  resolveSenderCommandAuthorization
+} from "openclaw/plugin-sdk";
+function unique(values) {
+  return Array.from(new Set(values));
+}
+function normalizeDmPolicy2(policy) {
+  if (policy === "open" || policy === "allowlist" || policy === "disabled") {
+    return policy;
+  }
+  return "disabled";
+}
+function normalizeGroupPolicy2(policy) {
+  if (policy === "open" || policy === "allowlist" || policy === "disabled") {
+    return policy;
+  }
+  return void 0;
+}
+function firstDefined(...values) {
+  for (const value of values) {
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function normalizeWeChatId(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return "";
+  }
+  return trimmed.replace(/^wechat:/i, "").trim();
+}
+function normalizeWeChatAllowFrom(values) {
+  const normalized = (values ?? []).map((entry) => String(entry).trim()).filter(Boolean).map((entry) => entry === "*" ? "*" : normalizeWeChatId(entry)).filter(Boolean);
+  return unique(normalized);
+}
+function isWeChatSenderAllowed(senderId, allowFrom) {
+  if (allowFrom.includes("*")) {
+    return true;
+  }
+  const normalizedSender = senderId ? normalizeWeChatId(senderId) : "";
+  if (!normalizedSender) {
+    return false;
+  }
+  return allowFrom.includes(normalizedSender);
+}
+function resolveGroupEntry(params) {
+  const groups = params.account.groups ?? {};
+  const normalizedChatId = normalizeWeChatId(params.chatId);
+  const keys = buildChannelKeyCandidates(params.chatId, normalizedChatId);
+  const match = resolveChannelEntryMatchWithFallback({
+    entries: groups,
+    keys,
+    wildcardKey: "*",
+    normalizeKey: normalizeWeChatId
+  });
+  return {
+    groupEntry: match.entry,
+    wildcardEntry: match.wildcardEntry
+  };
+}
+function resolveWeChatPolicyContext(params) {
+  const dmPolicy = normalizeDmPolicy2(params.account.dmPolicy);
+  const configuredAllowFrom = normalizeWeChatAllowFrom(params.account.allowFrom);
+  const configuredGroupAllowFrom = normalizeWeChatAllowFrom(params.account.groupAllowFrom);
+  const normalizedStoreAllowFrom = dmPolicy === "allowlist" ? [] : normalizeWeChatAllowFrom(params.storeAllowFrom);
+  const effectiveAllowFrom = unique([...configuredAllowFrom, ...normalizedStoreAllowFrom]);
+  const groupBase = configuredGroupAllowFrom.length > 0 ? configuredGroupAllowFrom : configuredAllowFrom;
+  const effectiveGroupAllowFrom = unique([...groupBase, ...normalizedStoreAllowFrom]);
+  const { groupEntry, wildcardEntry } = resolveGroupEntry({
+    account: params.account,
+    chatId: params.chatId
+  });
+  const groupEnabled = firstDefined(groupEntry?.enabled, wildcardEntry?.enabled, true) !== false;
+  const requireMention = firstDefined(groupEntry?.requireMention, wildcardEntry?.requireMention, true) !== false;
+  const defaultGroupPolicy = resolveDefaultGroupPolicy(params.cfg);
+  const { groupPolicy: fallbackGroupPolicy } = resolveAllowlistProviderRuntimeGroupPolicy({
+    providerConfigPresent: params.cfg.channels?.wechat !== void 0,
+    groupPolicy: normalizeGroupPolicy2(params.account.groupPolicy),
+    defaultGroupPolicy: normalizeGroupPolicy2(defaultGroupPolicy)
+  });
+  const groupPolicy = normalizeGroupPolicy2(
+    firstDefined(
+      groupEntry?.groupPolicy,
+      wildcardEntry?.groupPolicy,
+      params.account.groupPolicy,
+      defaultGroupPolicy
+    )
+  ) ?? fallbackGroupPolicy;
+  const groupAllowOverride = normalizeWeChatAllowFrom(
+    firstDefined(groupEntry?.allowFrom, wildcardEntry?.allowFrom)
+  );
+  const groupAllowFrom = groupAllowOverride.length > 0 ? unique([...groupAllowOverride, ...normalizedStoreAllowFrom]) : effectiveGroupAllowFrom;
+  return {
+    dmPolicy,
+    groupPolicy,
+    requireMention,
+    groupEnabled,
+    effectiveAllowFrom,
+    effectiveGroupAllowFrom: groupAllowFrom
+  };
+}
+function resolveWeChatInboundAccessDecision(params) {
+  if (params.isGroup) {
+    if (!params.policy.groupEnabled) {
+      return { allowed: false, reason: "group-config-disabled" };
+    }
+    if (params.policy.groupPolicy === "disabled") {
+      return { allowed: false, reason: "groupPolicy=disabled" };
+    }
+    if (params.policy.groupPolicy === "allowlist") {
+      if (params.policy.effectiveGroupAllowFrom.length === 0) {
+        return { allowed: false, reason: "groupPolicy=allowlist (empty allowlist)" };
+      }
+      if (!isWeChatSenderAllowed(params.senderId, params.policy.effectiveGroupAllowFrom)) {
+        return { allowed: false, reason: "groupPolicy=allowlist (sender not allowlisted)" };
+      }
+    }
+    return { allowed: true, reason: `groupPolicy=${params.policy.groupPolicy}` };
+  }
+  if (params.policy.dmPolicy === "disabled") {
+    return { allowed: false, reason: "dmPolicy=disabled" };
+  }
+  if (params.policy.dmPolicy === "allowlist") {
+    if (params.policy.effectiveAllowFrom.length === 0) {
+      return { allowed: false, reason: "dmPolicy=allowlist (empty allowlist)" };
+    }
+    if (!isWeChatSenderAllowed(params.senderId, params.policy.effectiveAllowFrom)) {
+      return { allowed: false, reason: "dmPolicy=allowlist (sender not allowlisted)" };
+    }
+  }
+  return { allowed: true, reason: `dmPolicy=${params.policy.dmPolicy}` };
+}
+async function resolveWeChatCommandAuthorization(params) {
+  const normalizedSenderId = normalizeWeChatId(params.senderId ?? "");
+  const { commandAuthorized } = await resolveSenderCommandAuthorization({
+    cfg: params.cfg,
+    rawBody: params.rawBody,
+    isGroup: params.isGroup,
+    dmPolicy: params.dmPolicy,
+    configuredAllowFrom: params.allowFromForCommands,
+    senderId: normalizedSenderId,
+    isSenderAllowed: (senderId, allowFrom) => isWeChatSenderAllowed(senderId, normalizeWeChatAllowFrom(allowFrom)),
+    readAllowFromStore: async () => normalizeWeChatAllowFrom(await params.deps.readAllowFromStore()),
+    shouldComputeCommandAuthorized: params.deps.shouldComputeCommandAuthorized,
+    resolveCommandAuthorizedFromAuthorizers: params.deps.resolveCommandAuthorizedFromAuthorizers
+  });
+  return commandAuthorized;
+}
+function resolveWeChatMentionGate(params) {
+  const implicitMention = params.implicitMention === true;
+  const baseWasMentioned = params.wasMentioned || implicitMention;
+  const shouldBypassMention = params.isGroup && params.requireMention && !baseWasMentioned && params.allowTextCommands && params.hasControlCommand && params.commandAuthorized;
+  const effectiveWasMentioned = baseWasMentioned || shouldBypassMention;
+  const shouldSkip = params.requireMention && params.canDetectMention && !effectiveWasMentioned;
+  return { effectiveWasMentioned, shouldSkip, shouldBypassMention };
+}
+
+// src/monitor.ts
 var MEDIA_TYPES = /* @__PURE__ */ new Set([3, 34]);
 var HISTORY_CONTEXT_MARKER = "[Chat messages since your last reply - for context]";
 var CURRENT_MESSAGE_MARKER = "[Current message - respond to this]";
@@ -5526,20 +5705,6 @@ async function pollMedia(client, chatId, localId, log, maxAttempts = 15, interva
   }
   return null;
 }
-function isMessageAllowed(account, isGroup, senderId) {
-  if (isGroup) {
-    if (account.groupPolicy === "disabled") return false;
-    if (account.groupPolicy === "allowlist") {
-      return account.groupAllowFrom.includes(senderId);
-    }
-    return true;
-  }
-  if (account.dmPolicy === "disabled") return false;
-  if (account.dmPolicy === "allowlist") {
-    return account.allowFrom.includes(senderId);
-  }
-  return true;
-}
 function enqueueWeChatSystemEvent(text, contextKey) {
   try {
     const core = getWeChatRuntime();
@@ -5677,7 +5842,7 @@ async function startWeChatMonitor(opts) {
     connected: false
   });
 }
-async function prepareMessage(client, msg, chatId, chat, liveAccount, log) {
+async function prepareMessage(client, msg, chatId, chat, liveAccount, policy, log) {
   const core = getWeChatRuntime();
   if (msg.isSelf) {
     log?.info?.(`[wechat:${liveAccount.accountId}] Skipping self-sent msg ${msg.localId}`);
@@ -5686,8 +5851,15 @@ async function prepareMessage(client, msg, chatId, chat, liveAccount, log) {
   const isGroup = chatId.includes("@chatroom");
   const senderId = msg.sender ?? chatId;
   const senderName = msg.senderName ?? msg.sender ?? chat.name;
-  if (!isMessageAllowed(liveAccount, isGroup, senderId)) {
-    log?.info?.(`[wechat:${liveAccount.accountId}] Blocked by policy: ${isGroup ? "group" : "dm"} from ${senderId}`);
+  const access = resolveWeChatInboundAccessDecision({
+    isGroup,
+    senderId,
+    policy
+  });
+  if (!access.allowed) {
+    log?.info?.(
+      `[wechat:${liveAccount.accountId}] Blocked by policy (${access.reason}) from ${senderId}`
+    );
     return null;
   }
   let mediaPath;
@@ -5765,6 +5937,7 @@ ${replyBlock}` : replyBlock;
   return {
     msg,
     rawBody,
+    commandBody: rawBody,
     mediaPath,
     mediaMime,
     senderName,
@@ -5794,27 +5967,50 @@ function buildSegments(processed) {
   }
   return segments;
 }
-async function dispatchSegment(segment, client, chatId, chat, liveAccount, cfg, log, remainingSegments, groupHistory) {
+async function dispatchSegment(segment, client, chatId, chat, liveAccount, policy, storeAllowFrom, allowTextCommands, cfg, log, remainingSegments) {
   const core = getWeChatRuntime();
   const lastMsg = segment[segment.length - 1];
-  const { isGroup, senderId, senderName, timestamp, rawBody, msg } = lastMsg;
+  const { isGroup, senderId, senderName, timestamp, rawBody, commandBody, msg } = lastMsg;
   const mediaMsg = segment.find((pm) => pm.mediaPath);
   const mediaPath = mediaMsg?.mediaPath;
   const mediaMime = mediaMsg?.mediaMime;
   log?.info?.(
     `[wechat:${liveAccount.accountId}] Dispatching segment: ${segment.length} msg(s), last=${msg.localId}${mediaPath ? ` media=${mediaPath}` : ""}`
   );
-  if (isGroup) {
-    const wechatCfg = cfg?.channels?.wechat;
-    const groupEntry = wechatCfg?.groups?.[chatId];
-    const defaultEntry = wechatCfg?.groups?.["*"];
-    const requireMention = groupEntry?.requireMention ?? defaultEntry?.requireMention ?? true;
-    if (requireMention && !lastMsg.isMentioned) {
-      log?.info?.(
-        `[wechat:${liveAccount.accountId}] Skipping group message (mention required, not mentioned) in ${chatId}`
-      );
-      return;
+  const hasControlCommand = allowTextCommands && core.channel.text.hasControlCommand(commandBody, cfg);
+  const commandAuthorized = await resolveWeChatCommandAuthorization({
+    cfg,
+    rawBody: commandBody,
+    isGroup,
+    senderId,
+    dmPolicy: policy.dmPolicy,
+    allowFromForCommands: isGroup ? policy.effectiveGroupAllowFrom : policy.effectiveAllowFrom,
+    deps: {
+      shouldComputeCommandAuthorized: (raw, loadedCfg) => core.channel.commands.shouldComputeCommandAuthorized(raw, loadedCfg),
+      resolveCommandAuthorizedFromAuthorizers: (params) => core.channel.commands.resolveCommandAuthorizedFromAuthorizers(params),
+      readAllowFromStore: async () => storeAllowFrom
     }
+  });
+  if (isGroup && allowTextCommands && hasControlCommand && commandAuthorized !== true) {
+    log?.info?.(
+      `[wechat:${liveAccount.accountId}] Dropping unauthorized group control command from ${senderId} in ${chatId}`
+    );
+    return false;
+  }
+  const mentionGate = resolveWeChatMentionGate({
+    isGroup,
+    requireMention: policy.requireMention,
+    canDetectMention: true,
+    wasMentioned: segment.some((pm) => pm.isMentioned),
+    allowTextCommands,
+    hasControlCommand,
+    commandAuthorized: commandAuthorized === true
+  });
+  if (isGroup && mentionGate.shouldSkip) {
+    log?.info?.(
+      `[wechat:${liveAccount.accountId}] Skipping group segment (mention required) in ${chatId}`
+    );
+    return false;
   }
   try {
     const route = core.channel.routing.resolveAgentRoute({
@@ -5889,7 +6085,7 @@ async function dispatchSegment(segment, client, chatId, chat, liveAccount, cfg,
       Body: body,
       BodyForAgent: rawBody,
       RawBody: rawBody,
-      CommandBody: rawBody,
+      CommandBody: commandBody,
       InboundHistory: inboundHistory,
       From: isGroup ? `wechat:group:${chatId}` : `wechat:${senderId}`,
       To: `wechat:${chatId}`,
@@ -5902,7 +6098,8 @@ async function dispatchSegment(segment, client, chatId, chat, liveAccount, cfg,
       Provider: "wechat",
       Surface: "wechat",
       MessageSid: `wechat:${chatId}:${msg.localId}`,
-      WasMentioned: isGroup ? lastMsg.isMentioned : void 0,
+      WasMentioned: isGroup ? mentionGate.effectiveWasMentioned : void 0,
+      CommandAuthorized: commandAuthorized,
       OriginatingChannel: "wechat",
       OriginatingTo: `wechat:${chatId}`,
       ...mediaPath ? { MediaPath: mediaPath, MediaUrl: mediaPath, MediaType: mediaMime } : {},
@@ -6005,13 +6202,12 @@ async function dispatchSegment(segment, client, chatId, chat, liveAccount, cfg,
       direction: "inbound",
       at: timestamp
     });
-    if (isGroup && groupHistory) {
-      groupHistory.set(chatId, []);
-    }
+    return true;
   } catch (err) {
     log?.error?.(
       `[wechat:${liveAccount.accountId}] Failed to dispatch segment (last msg ${msg.localId}): ${err}`
     );
+    return false;
   }
 }
 function bufferGroupHistory(groupHistory, chatId, pm, limit) {
@@ -6028,8 +6224,20 @@ function bufferGroupHistory(groupHistory, chatId, pm, limit) {
   }
 }
 async function processUnreadChat(client, chat, lastSeenId, account, cfg, log, skipOpen, groupHistory, groupHistoryLimit) {
+  const core = getWeChatRuntime();
   const liveAccount = resolveWeChatAccount(cfg, account.accountId) ?? account;
   const chatId = chat.username ?? chat.id;
+  const storeAllowFrom = await core.channel.pairing.readAllowFromStore("wechat", process.env, liveAccount.accountId).catch(() => []);
+  const policy = resolveWeChatPolicyContext({
+    account: liveAccount,
+    cfg,
+    chatId,
+    storeAllowFrom
+  });
+  const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
+    cfg,
+    surface: "wechat"
+  });
   if (!skipOpen) {
     log?.info?.(`[wechat:${liveAccount.accountId}] Opening chat ${chatId}...`);
     try {
@@ -6087,20 +6295,18 @@ async function processUnreadChat(client, chat, lastSeenId, account, cfg, log, sk
     log?.info?.(
       `[wechat:${liveAccount.accountId}] Processing msg ${msg.localId}: type=${msg.type}, sender=${msg.sender}, isSelf=${msg.isSelf}, content=${(msg.content || "").slice(0, 50)}`
     );
-    const pm = await prepareMessage(client, msg, chatId, chat, liveAccount, log);
+    const pm = await prepareMessage(client, msg, chatId, chat, liveAccount, policy, log);
     if (pm) {
       processed.push(pm);
     }
   }
   const isGroup = chatId.includes("@chatroom");
+  let clearBufferedHistory = false;
+  const hasControlCommandInWindow = allowTextCommands && processed.some((pm) => core.channel.text.hasControlCommand(pm.commandBody, cfg));
   if (isGroup && groupHistory) {
-    const wechatCfg = cfg?.channels?.wechat;
-    const groupEntry = wechatCfg?.groups?.[chatId];
-    const defaultEntry = wechatCfg?.groups?.["*"];
-    const requireMention = groupEntry?.requireMention ?? defaultEntry?.requireMention ?? true;
-    if (requireMention) {
+    if (policy.requireMention) {
       const hasMention = processed.some((pm) => pm.isMentioned);
-      if (!hasMention) {
+      if (!hasMention && !hasControlCommandInWindow) {
         const limit = groupHistoryLimit ?? 50;
         for (const pm of processed) {
           bufferGroupHistory(groupHistory, chatId, pm, limit);
@@ -6110,37 +6316,67 @@ async function processUnreadChat(client, chat, lastSeenId, account, cfg, log, sk
         lastSeenId.set(chatId, maxId2);
         return;
       }
-      const buffered = groupHistory.get(chatId) ?? [];
-      if (buffered.length > 0) {
-        for (const pm of buffered) {
-          pm.isMentioned = true;
+      if (hasMention) {
+        clearBufferedHistory = true;
+        const buffered = groupHistory.get(chatId) ?? [];
+        if (buffered.length > 0) {
+          for (const pm of buffered) {
+            pm.isMentioned = true;
+          }
+          processed.unshift(...buffered);
+          log?.info?.(
+            `[wechat:${liveAccount.accountId}] Injected ${buffered.length} buffered msg(s) as history in ${chatId}`
+          );
         }
-        processed.unshift(...buffered);
-        groupHistory.set(chatId, []);
-        log?.info?.(`[wechat:${liveAccount.accountId}] Injected ${buffered.length} buffered msg(s) as history in ${chatId}`);
-      }
-      let latestMediaIdx = -1;
-      for (let i = processed.length - 1; i >= 0; i--) {
-        if (processed[i].mediaPath) {
-          latestMediaIdx = i;
-          break;
+        let latestMediaIdx = -1;
+        for (let i = processed.length - 1; i >= 0; i--) {
+          if (processed[i].mediaPath) {
+            latestMediaIdx = i;
+            break;
+          }
         }
-      }
-      for (let i = 0; i < processed.length; i++) {
-        if (processed[i].mediaPath && i !== latestMediaIdx) {
-          processed[i] = { ...processed[i], mediaPath: void 0, mediaMime: void 0, hasMedia: false };
+        for (let i = 0; i < processed.length; i++) {
+          if (processed[i].mediaPath && i !== latestMediaIdx) {
+            processed[i] = {
+              ...processed[i],
+              mediaPath: void 0,
+              mediaMime: void 0,
+              hasMedia: false
+            };
+          }
         }
       }
+    } else {
+      clearBufferedHistory = true;
     }
   }
   if (processed.length > 0) {
-    const segments = buildSegments(processed);
+    const segments = hasControlCommandInWindow ? processed.map((pm) => [pm]) : buildSegments(processed);
     log?.info?.(
       `[wechat:${liveAccount.accountId}] ${chatId}: ${processed.length} dispatchable msg(s) in ${segments.length} segment(s)`
     );
+    let allDispatched = true;
     for (let i = 0; i < segments.length; i++) {
       const remaining = segments.length - i - 1;
-      await dispatchSegment(segments[i], client, chatId, chat, liveAccount, cfg, log, remaining, groupHistory);
+      const dispatched = await dispatchSegment(
+        segments[i],
+        client,
+        chatId,
+        chat,
+        liveAccount,
+        policy,
+        storeAllowFrom,
+        allowTextCommands,
+        cfg,
+        log,
+        hasControlCommandInWindow ? void 0 : remaining
+      );
+      if (!dispatched) {
+        allDispatched = false;
+      }
+    }
+    if (clearBufferedHistory && allDispatched && groupHistory) {
+      groupHistory.set(chatId, []);
     }
   }
   const maxId = Math.max(...newMessages.map((m) => m.localId));
@@ -6514,7 +6750,7 @@ var wechatOnboardingAdapter = {
     wechatCfg.groupPolicy = groupPolicy;
     if (groupPolicy === "allowlist") {
       const raw = await prompter.text({
-        message: "Allowed group IDs (comma-separated xxx@chatroom values)"
+        message: "Allowed group sender IDs (comma-separated wxid_xxx values; use * to allow any sender)"
       });
       wechatCfg.groupAllowFrom = raw.split(",").map((s) => s.trim()).filter(Boolean);
     }
@@ -6748,7 +6984,13 @@ var wechatPlugin = {
           additionalProperties: {
             type: "object",
             properties: {
-              requireMention: { type: "boolean" }
+              enabled: { type: "boolean" },
+              requireMention: { type: "boolean" },
+              groupPolicy: {
+                type: "string",
+                enum: ["open", "allowlist", "disabled"]
+              },
+              allowFrom: { type: "array", items: { type: "string" } }
             }
           }
         },
@@ -6793,7 +7035,8 @@ var wechatPlugin = {
       allowFrom: account.allowFrom ?? [],
       allowFromPath: "channels.wechat.allowFrom",
       policyPath: "channels.wechat.dmPolicy",
-      approveHint: "Add the wxid to channels.wechat.allowFrom"
+      approveHint: "Add the wxid to channels.wechat.allowFrom",
+      normalizeEntry: (raw) => raw.replace(/^wechat:/i, "").trim()
     })
   },
   // ---- Groups adapter ----
@@ -6801,10 +7044,18 @@ var wechatPlugin = {
     resolveRequireMention: ({ cfg, groupId }) => {
       const wechat = cfg?.channels?.wechat;
       if (!wechat) return true;
-      if (groupId && wechat.groups?.[groupId]?.requireMention != null) {
-        return wechat.groups[groupId].requireMention;
+      if (!groupId) {
+        return wechat.groups?.["*"]?.requireMention ?? true;
+      }
+      const exact = wechat.groups?.[groupId];
+      if (exact?.requireMention != null) {
+        return exact.requireMention;
+      }
+      const normalizedGroupId = normalizeWeChatId(groupId);
+      if (normalizedGroupId && wechat.groups?.[normalizedGroupId]?.requireMention != null) {
+        return wechat.groups[normalizedGroupId].requireMention;
       }
-      return true;
+      return wechat.groups?.["*"]?.requireMention ?? true;
     }
   },
   // ---- Messaging adapter ----

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-wechat/wechat",
-  "version": "0.7.10",
+  "version": "0.8.1",
   "type": "module",
   "files": [
     "dist",
@@ -41,6 +41,7 @@
   },
   "scripts": {
     "build": "esbuild index.ts --bundle --format=esm --platform=node --outfile=dist/index.js --external:openclaw",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "node --test --experimental-strip-types src/*.test.ts"
   }
 }