@agent-wechat/agent-wechat 0.15.6 → 0.16.0

package/README.md

@@ -87,6 +87,7 @@ Or edit `~/.openclaw/openclaw.json` directly:
       "enabled": true,
       "serverUrl": "http://localhost:6174",
       "dmPolicy": "open",
+      "allowFrom": ["*"],
       "groupPolicy": "open"
     }
   }
@@ -147,13 +148,18 @@ All config lives under `channels.agent-wechat` in OpenClaw's config file:
 | `serverUrl` | string | — | agent-wechat REST API URL |
 | `token` | string | — | Auth token (auto-read from `~/.config/agent-wechat/token` for local setups) |
 | `dmPolicy` | `"open" \| "allowlist" \| "disabled"` | `"disabled"` | Who can DM the bot |
-| `allowFrom` | string[] | `[]` | wxid allowlist for DMs (when policy is `allowlist`) |
+| `allowFrom` | string[] | `[]` | DM senders and command owners: `wxid_...`, `"*"` for everyone, or `accessGroup:<name>`. With `dmPolicy: "open"`, use `["*"]` |
 | `groupPolicy` | `"open" \| "allowlist" \| "disabled"` | `"disabled"` | Group message policy |
-| `groupAllowFrom` | string[] | `[]` | Global allowlist of group sender IDs (`wxid_...`) |
+| `groupAllowFrom` | string[] | `[]` | Group senders who pass `allowlist` and may run commands in groups; falls back to `allowFrom` when empty |
 | `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 |
 
+Access decisions (DM and group senders, per-group overrides, control commands, @mention
+gating) are made by OpenClaw's channel ingress policy, so `accessGroup:<name>` entries from
+the top-level `accessGroups` config work in every allowlist. The pairing store is not
+used: WeChat has no pairing flow.
+
 ## Development
 
 ### Build from source

package/dist/index.js

@@ -5937,6 +5937,9 @@ async function pollMedia(client, chatId, localId, quality, log, maxAttempts = 15
   return lastResult;
 }
 
+// src/monitor.ts
+import { resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
+
 // src/access-control.ts
 import {
   buildChannelKeyCandidates,
@@ -6021,16 +6024,6 @@ function normalizeWeChatCommandBody(raw, params) {
   }
   return trimmed;
 }
-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);
@@ -6047,13 +6040,6 @@ function resolveGroupEntry(params) {
   };
 }
 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
@@ -6074,84 +6060,86 @@ function resolveWeChatPolicyContext(params) {
       defaultGroupPolicy
     )
   ) ?? fallbackGroupPolicy;
-  const groupAllowOverride = normalizeWeChatAllowFrom(
+  const groupSenderAllowFrom = normalizeWeChatAllowFrom(
     firstDefined(groupEntry?.allowFrom, wildcardEntry?.allowFrom)
   );
-  const groupAllowFrom = groupAllowOverride.length > 0 ? unique([...groupAllowOverride, ...normalizedStoreAllowFrom]) : effectiveGroupAllowFrom;
+  const dmPolicy = normalizeDmPolicy2(params.account.dmPolicy);
+  const allowFrom = normalizeWeChatAllowFrom(params.account.allowFrom);
+  const groupAllowFrom = normalizeWeChatAllowFrom(params.account.groupAllowFrom);
+  const impliedOpenDmWildcard = dmPolicy === "open" && !allowFrom.includes("*");
+  const scoped = impliedOpenDmWildcard ? {
+    allowFrom: ["*", ...allowFrom],
+    impliedOpenDmWildcard,
+    groupAllowFrom: groupAllowFrom.length > 0 ? groupAllowFrom : allowFrom,
+    groupAllowFromFallbackToAllowFrom: false,
+    commandOwnerAllowFrom: allowFrom
+  } : { allowFrom, groupAllowFrom, groupAllowFromFallbackToAllowFrom: true };
   return {
     dmPolicy,
     groupPolicy,
     requireMention,
     groupEnabled,
-    effectiveAllowFrom,
-    effectiveGroupAllowFrom: groupAllowFrom
+    ...scoped,
+    ...groupSenderAllowFrom.length > 0 ? { groupSenderAllowFrom } : {}
   };
 }
-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) {
-  if (!params.deps.shouldComputeCommandAuthorized(params.rawBody, params.cfg)) {
-    return void 0;
+var WECHAT_INGRESS_IDENTITY = {
+  key: "wechat-id",
+  entryIdPrefix: "wechat",
+  sensitivity: "pii",
+  normalize: (value) => normalizeWeChatId(value) || null
+};
+function resolveWeChatIngress(params) {
+  const { policy, isGroup } = params;
+  const routes = [];
+  if (isGroup && !policy.groupEnabled) {
+    routes.push({
+      id: "wechat-group",
+      kind: "route",
+      configured: true,
+      matched: true,
+      enabled: true,
+      allowed: false,
+      blockReason: "group_disabled"
+    });
   }
-  const normalizedSenderId = normalizeWeChatId(params.senderId ?? "");
-  const usesStore = !params.isGroup && params.dmPolicy !== "allowlist" && params.dmPolicy !== "open";
-  const storeAllowFrom = usesStore ? normalizeWeChatAllowFrom(await params.deps.readAllowFromStore().catch(() => [])) : [];
-  const configuredAllowFrom = normalizeWeChatAllowFrom(params.allowFromForCommands);
-  const effectiveAllowFrom = unique([...configuredAllowFrom, ...storeAllowFrom]);
-  const effectiveGroupAllowFrom = configuredAllowFrom;
-  return params.deps.resolveCommandAuthorizedFromAuthorizers({
-    useAccessGroups: true,
-    authorizers: [
-      {
-        configured: effectiveAllowFrom.length > 0,
-        allowed: isWeChatSenderAllowed(normalizedSenderId, effectiveAllowFrom)
-      },
-      {
-        configured: effectiveGroupAllowFrom.length > 0,
-        allowed: isWeChatSenderAllowed(normalizedSenderId, effectiveGroupAllowFrom)
-      }
-    ]
+  const groupAllowFrom = isGroup && policy.groupSenderAllowFrom || policy.groupAllowFrom;
+  const mention = isGroup ? params.mention : void 0;
+  const readStoreAllowFrom = params.readStoreAllowFrom;
+  return params.resolve({
+    channelId: "agent-wechat",
+    accountId: params.accountId,
+    identity: WECHAT_INGRESS_IDENTITY,
+    cfg: params.cfg,
+    subject: { stableId: normalizeWeChatId(params.senderId ?? "") || null },
+    conversation: { kind: isGroup ? "group" : "direct", id: params.chatId },
+    event: { kind: "message", authMode: "inbound", mayPair: false },
+    dmPolicy: policy.dmPolicy,
+    groupPolicy: policy.groupPolicy,
+    policy: {
+      groupAllowFromFallbackToAllowFrom: policy.groupAllowFromFallbackToAllowFrom,
+      ...mention ? { activation: { requireMention: policy.requireMention, allowTextCommands: mention.allowTextCommands } } : {}
+    },
+    allowFrom: policy.allowFrom,
+    groupAllowFrom,
+    ...routes.length > 0 ? { route: routes } : {},
+    ...readStoreAllowFrom ? { readStoreAllowFrom: async () => readStoreAllowFrom() } : {},
+    ...mention ? { mentionFacts: { canDetectMention: true, wasMentioned: mention.wasMentioned } } : {},
+    command: params.command ? {
+      ...params.command,
+      // Group commands are authorized by the group's sender allowlist only, as before.
+      groupOwnerAllowFrom: "none",
+      ...policy.commandOwnerAllowFrom && !isGroup ? { commandOwnerAllowFrom: policy.commandOwnerAllowFrom, commandGroupAllowFromFallbackToAllowFrom: false } : {}
+    } : false
   });
 }
-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 warnedOpenDmWildcard = /* @__PURE__ */ new Set();
+function getIngressResolver(core) {
+  const runtimeResolve = core.channel.inbound?.ingress?.resolveStable;
+  return runtimeResolve ?? resolveStableChannelMessageIngress;
+}
 var HISTORY_CONTEXT_MARKER = "[Chat messages since your last reply - for context]";
 var CURRENT_MESSAGE_MARKER = "[Current message - respond to this]";
 var voiceTranscriptCache = /* @__PURE__ */ new Map();
@@ -6378,7 +6366,7 @@ async function startWeChatMonitor(opts) {
     connected: false
   });
 }
-async function prepareMessage(client, msg, chatId, chat, liveAccount, policy, log) {
+async function prepareMessage(client, msg, chatId, chat, liveAccount, admitSender, log) {
   if (msg.isSelf) {
     log?.info?.(`[wechat:${liveAccount.accountId}] Skipping self-sent msg ${msg.localId}`);
     return null;
@@ -6387,11 +6375,7 @@ async function prepareMessage(client, msg, chatId, chat, liveAccount, policy, lo
   const senderId = msg.sender ?? chatId;
   const senderName = msg.senderName ?? msg.sender ?? chat.name;
   const wasMentioned = isGroup && msg.isMentioned === true;
-  const access = resolveWeChatInboundAccessDecision({
-    isGroup,
-    senderId,
-    policy
-  });
+  const access = await admitSender({ isGroup, senderId });
   if (!access.allowed) {
     log?.info?.(
       `[wechat:${liveAccount.accountId}] Blocked by policy (${access.reason}) from ${senderId}`
@@ -6482,40 +6466,34 @@ async function dispatchSegment(segment, client, chatId, chat, liveAccount, polic
     `[wechat:${liveAccount.accountId}] Dispatching segment: ${segment.length} msg(s), last=${msg.localId}${mediaPath ? " with model media" : ""} attachments=${attachmentPaths.length}`
   );
   const hasControlCommand = allowTextCommands && core.channel.commands.isControlCommandMessage(commandBody, cfg);
-  const commandAuthorized = await resolveWeChatCommandAuthorization({
+  const wasMentioned = segment.some((pm) => pm.isMentioned);
+  const ingress = await resolveWeChatIngress({
+    resolve: getIngressResolver(core),
     cfg,
-    rawBody: commandBody,
+    accountId: liveAccount.accountId,
+    policy,
     isGroup,
+    chatId,
     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
-    }
+    readStoreAllowFrom: async () => storeAllowFrom,
+    command: { allowTextCommands, hasControlCommand },
+    mention: { wasMentioned, allowTextCommands }
   });
-  if (isGroup && allowTextCommands && hasControlCommand && commandAuthorized !== true) {
+  if (ingress.ingress.admission === "skip") {
     log?.info?.(
-      `[wechat:${liveAccount.accountId}] Dropping unauthorized group control command from ${senderId} in ${chatId}`
+      `[wechat:${liveAccount.accountId}] Skipping group segment (${ingress.ingress.reasonCode}) in ${chatId}`
     );
     return "ignored";
   }
-  const mentionGate = resolveWeChatMentionGate({
-    isGroup,
-    requireMention: policy.requireMention,
-    canDetectMention: true,
-    wasMentioned: segment.some((pm) => pm.isMentioned),
-    allowTextCommands,
-    hasControlCommand,
-    commandAuthorized: commandAuthorized === true
-  });
-  if (isGroup && mentionGate.shouldSkip) {
+  const dmUnauthorizedCommand = !isGroup && ingress.ingress.reasonCode === "control_command_unauthorized";
+  if (ingress.ingress.admission !== "dispatch" && !dmUnauthorizedCommand) {
     log?.info?.(
-      `[wechat:${liveAccount.accountId}] Skipping group segment (mention required) in ${chatId}`
+      `[wechat:${liveAccount.accountId}] Dropping segment (${ingress.ingress.reasonCode}) from ${senderId} in ${chatId}`
     );
     return "ignored";
   }
+  const commandAuthorized = core.channel.commands.shouldComputeCommandAuthorized(commandBody, cfg) ? ingress.commandAccess.authorized : void 0;
+  const effectiveWasMentioned = ingress.activationAccess.effectiveWasMentioned ?? wasMentioned;
   try {
     for (const item of segment) {
       const attachment = item.attachment;
@@ -6632,7 +6610,7 @@ async function dispatchSegment(segment, client, chatId, chat, liveAccount, polic
       Provider: "agent-wechat",
       Surface: "agent-wechat",
       MessageSid: `wechat:${chatId}:${msg.localId}`,
-      WasMentioned: isGroup ? mentionGate.effectiveWasMentioned : void 0,
+      WasMentioned: isGroup ? effectiveWasMentioned : void 0,
       CommandAuthorized: commandAuthorized,
       OriginatingChannel: "agent-wechat",
       OriginatingTo: `wechat:${chatId}`,
@@ -6739,9 +6717,31 @@ async function processUnreadChat(client, chat, lastSeenId, account, cfg, log, sk
   const policy = resolveWeChatPolicyContext({
     account: liveAccount,
     cfg,
-    chatId,
-    storeAllowFrom
+    chatId
   });
+  if (policy.impliedOpenDmWildcard && !warnedOpenDmWildcard.has(liveAccount.accountId)) {
+    warnedOpenDmWildcard.add(liveAccount.accountId);
+    log?.info?.(
+      `[wechat:${liveAccount.accountId}] dmPolicy is "open" but allowFrom has no "*"; treating it as ["*"]. Add "*" to channels.agent-wechat.allowFrom to make this explicit.`
+    );
+  }
+  const resolveIngress = getIngressResolver(core);
+  const admitSender = async ({ isGroup: isGroup2, senderId }) => {
+    const result = await resolveWeChatIngress({
+      resolve: resolveIngress,
+      cfg,
+      accountId: liveAccount.accountId,
+      policy,
+      isGroup: isGroup2,
+      chatId,
+      senderId,
+      readStoreAllowFrom: async () => storeAllowFrom
+    });
+    return {
+      allowed: result.ingress.admission === "dispatch",
+      reason: result.ingress.reasonCode
+    };
+  };
   const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
     cfg,
     surface: "agent-wechat"
@@ -6808,7 +6808,7 @@ 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}`
     );
-    const pm = await prepareMessage(client, msg, chatId, chat, liveAccount, policy, log);
+    const pm = await prepareMessage(client, msg, chatId, chat, liveAccount, admitSender, log);
     if (pm) {
       processed.push(pm);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-wechat/agent-wechat",
-  "version": "0.15.6",
+  "version": "0.16.0",
   "type": "module",
   "files": [
     "dist",