openclaw-channel-dmwork 0.2.17 → 0.2.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-channel-dmwork",
-  "version": "0.2.17",
+  "version": "0.2.18",
   "description": "DMWork channel plugin for OpenClaw via WuKongIM WebSocket",
   "main": "index.ts",
   "type": "module",

package/src/api-fetch.ts

@@ -147,6 +147,47 @@ export async function fetchBotGroups(params: {
   return resp.json();
 }
 
+/**
+ * 获取群成员列表
+ */
+export interface GroupMember {
+  uid: string;
+  name: string;
+  role?: string;    // admin/member
+  robot?: boolean;  // 是否是机器人
+}
+
+export async function getGroupMembers(params: {
+  apiUrl: string;
+  botToken: string;
+  groupNo: string;  // 群 ID (channel_id)
+}): Promise<GroupMember[]> {
+  const url = `${params.apiUrl.replace(/\/+$/, "")}/v1/bot/groups/${params.groupNo}/members`;
+  try {
+    const resp = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${params.botToken}`,
+      },
+    });
+    if (!resp.ok) {
+      console.log(`[dmwork] getGroupMembers failed: ${resp.status}`);
+      return [];
+    }
+    const data = await resp.json();
+    // Normalize to strict array to prevent silent failures
+    const members = Array.isArray(data?.members)
+      ? data.members
+      : Array.isArray(data)
+        ? data
+        : [];
+    return members as GroupMember[];
+  } catch (err) {
+    console.log(`[dmwork] getGroupMembers error: ${err}`);
+    return [];
+  }
+}
+
 /**
  * 获取频道历史消息（用于注入上下文）
  * @param params.log - Optional logger for consistent logging with OpenClaw log system

package/src/channel.ts

@@ -30,6 +30,41 @@ function getOrCreateHistoryMap(accountId: string): Map<string, any[]> {
   return m;
 }
 
+// Module-level member mapping: displayName -> uid
+// Used to resolve @mentions in AI replies
+const _memberMaps = new Map<string, Map<string, string>>();
+function getOrCreateMemberMap(accountId: string): Map<string, string> {
+  let m = _memberMaps.get(accountId);
+  if (!m) {
+    m = new Map<string, string>();
+    _memberMaps.set(accountId, m);
+  }
+  return m;
+}
+
+// Module-level reverse mapping: uid -> displayName
+// Used to show display names instead of uids in replies
+const _uidToNameMaps = new Map<string, Map<string, string>>();
+function getOrCreateUidToNameMap(accountId: string): Map<string, string> {
+  let m = _uidToNameMaps.get(accountId);
+  if (!m) {
+    m = new Map<string, string>();
+    _uidToNameMaps.set(accountId, m);
+  }
+  return m;
+}
+
+// Group member cache timestamps: groupId -> lastFetchedAt (ms)
+const _groupCacheTimestamps = new Map<string, Map<string, number>>();
+function getOrCreateGroupCacheTimestamps(accountId: string): Map<string, number> {
+  let m = _groupCacheTimestamps.get(accountId);
+  if (!m) {
+    m = new Map<string, number>();
+    _groupCacheTimestamps.set(accountId, m);
+  }
+  return m;
+}
+
 const meta = {
   id: "dmwork",
   label: "DMWork",
@@ -104,6 +139,22 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
           channelId = groupPart;
         }
         channelType = ChannelType.Group;
+
+        // Parse @mentions from message content (e.g., "@chenpipi_bot" -> "chenpipi_bot")
+        // Match @username where username is alphanumeric with underscores (typical uid format)
+        const contentMentions = content.match(/@([a-zA-Z0-9_]+)/g);
+        if (contentMentions) {
+          for (const mention of contentMentions) {
+            const uid = mention.slice(1); // Remove @ prefix
+            if (uid && !mentionUids.includes(uid)) {
+              mentionUids.push(uid);
+              console.log(`[dmwork] parsed @mention from content: ${uid}`);
+            }
+          }
+        }
+        if (mentionUids.length > 0) {
+          console.log(`[dmwork] sending message with mentionUids: ${mentionUids.join(", ")}`);
+        }
       }
 
       await sendMessage({
@@ -207,6 +258,15 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
 
       // 4. Group history map — persists across auto-restarts (module-level)
       const groupHistories = getOrCreateHistoryMap(account.accountId);
+      
+      // 4b. Member name->uid map — for resolving @mentions in replies
+      const memberMap = getOrCreateMemberMap(account.accountId);
+      
+      // 4c. Reverse map uid->name — for showing display names in replies
+      const uidToNameMap = getOrCreateUidToNameMap(account.accountId);
+      
+      // 4d. Group cache timestamps — track when each group's members were last fetched
+      const groupCacheTimestamps = getOrCreateGroupCacheTimestamps(account.accountId);
 
       // 5. Token refresh state — detect stale cached token
       let hasRefreshedToken = false;
@@ -232,6 +292,9 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
             message: msg,
             botUid: credentials.robot_id,
             groupHistories,
+            memberMap,
+            uidToNameMap,
+            groupCacheTimestamps,
             log,
             statusSink,
           }).catch((err) => {

package/src/inbound.ts

@@ -1,5 +1,5 @@
 import type { ChannelLogSink, OpenClawConfig } from "openclaw/plugin-sdk";
-import { sendMessage, sendReadReceipt, sendTyping, getChannelMessages } from "./api-fetch.js";
+import { sendMessage, sendReadReceipt, sendTyping, getChannelMessages, getGroupMembers } from "./api-fetch.js";
 import type { ResolvedDmworkAccount } from "./accounts.js";
 import type { BotMessage } from "./types.js";
 import { ChannelType, MessageType } from "./types.js";
@@ -51,15 +51,21 @@ function resolveContent(payload: BotMessage["payload"]): string {
   return "";
 }
 
+// Cache expiry time: 1 hour
+const GROUP_CACHE_EXPIRY_MS = 60 * 60 * 1000;
+
 export async function handleInboundMessage(params: {
   account: ResolvedDmworkAccount;
   message: BotMessage;
   botUid: string;
   groupHistories: Map<string, any[]>;
+  memberMap: Map<string, string>;  // displayName -> uid mapping
+  uidToNameMap: Map<string, string>;  // uid -> displayName mapping (reverse)
+  groupCacheTimestamps: Map<string, number>;  // groupId -> lastFetchedAt
   log?: ChannelLogSink;
   statusSink?: DmworkStatusSink;
 }) {
-  const { account, message, botUid, groupHistories, log, statusSink } = params;
+  const { account, message, botUid, groupHistories, memberMap, uidToNameMap, groupCacheTimestamps, log, statusSink } = params;
 
   await ensureSdkLoaded();
 
@@ -96,11 +102,97 @@ export async function handleInboundMessage(params: {
   // --- Mention gating for group messages ---
   const requireMention = account.config.requireMention !== false;
   let historyPrefix = "";
+  
+  // Save original mention uids for reply (exclude bot itself)
+  const originalMentionUids: string[] = (message.payload?.mention?.uids ?? []).filter((uid: string) => uid !== botUid);
+
+  // Helper function to refresh group member cache
+  async function refreshGroupMemberCache(forceRefresh = false): Promise<boolean> {
+    if (!isGroup) return false;
+    
+    const lastFetched = groupCacheTimestamps.get(sessionId) ?? 0;
+    const now = Date.now();
+    const isExpired = (now - lastFetched) > GROUP_CACHE_EXPIRY_MS;
+    
+    if (!forceRefresh && !isExpired && lastFetched > 0) {
+      return false; // Cache is still valid
+    }
+    
+    log?.info?.(`dmwork: [CACHE] ${forceRefresh ? 'Force refreshing' : 'Refreshing expired'} group member cache for ${sessionId}`);
+    
+    try {
+      const members = await getGroupMembers({
+        apiUrl: account.config.apiUrl,
+        botToken: account.config.botToken ?? "",
+        groupNo: sessionId,
+      });
+      
+      if (members.length > 0) {
+        for (const m of members) {
+          if (m.name && m.uid) {
+            memberMap.set(m.name, m.uid);
+            uidToNameMap.set(m.uid, m.name);
+          }
+        }
+        groupCacheTimestamps.set(sessionId, now);
+        log?.info?.(`dmwork: [CACHE] Loaded ${members.length} members, memberMap size: ${memberMap.size}`);
+        return true;
+      } else {
+        // Set a short backoff (30s) to prevent retry storms on empty responses
+        groupCacheTimestamps.set(sessionId, now - GROUP_CACHE_EXPIRY_MS + 30000);
+        log?.warn?.(`dmwork: [CACHE] No members returned for group ${sessionId}, backoff 30s`);
+        return false;
+      }
+    } catch (err) {
+      // Set a short backoff (30s) to prevent retry storms on errors
+      groupCacheTimestamps.set(sessionId, now - GROUP_CACHE_EXPIRY_MS + 30000);
+      log?.error?.(`dmwork: [CACHE] Failed to fetch group members: ${err}, backoff 30s`);
+      return false;
+    }
+  }
+
+  // Refresh group member cache if needed (on first message or after expiry)
+  if (isGroup) {
+    await refreshGroupMemberCache();
+  }
+
+  // Build displayName -> uid mapping from message content + mention.uids
+  // When user sends "@陈皮皮 @托马斯.福 xxx", the @ names in content correspond to mention.uids in order
+  if (isGroup) {
+    const allMentionUids: string[] = message.payload?.mention?.uids ?? [];
+    // Match all @xxx patterns (including Chinese characters and dots)
+    const contentMentions = rawBody.match(/@[\w\u4e00-\u9fa5.]+/g) ?? [];
+    
+    if (contentMentions.length > 0 && allMentionUids.length > 0) {
+      log?.debug?.(`dmwork: [MAPPING] content @names: ${JSON.stringify(contentMentions)}, mention.uids: ${JSON.stringify(allMentionUids)}`);
+      
+      // Pair them in order
+      const pairCount = Math.min(contentMentions.length, allMentionUids.length);
+      for (let i = 0; i < pairCount; i++) {
+        const displayName = contentMentions[i].slice(1); // Remove @ prefix
+        const uid = allMentionUids[i];
+        if (displayName && uid) {
+          // Update both mappings
+          if (!memberMap.has(displayName)) {
+            memberMap.set(displayName, uid);
+            log?.debug?.(`dmwork: [MAPPING] learned name->uid mapping`);
+          }
+          if (!uidToNameMap.has(uid)) {
+            uidToNameMap.set(uid, displayName);
+            log?.debug?.(`dmwork: [MAPPING] learned uid->name mapping`);
+          }
+        }
+      }
+    }
+  }
 
   if (isGroup && requireMention) {
     const mentionUids: string[] = message.payload?.mention?.uids ?? [];
     const mentionAll: boolean = message.payload?.mention?.all === true;
     const isMentioned = mentionAll || mentionUids.includes(botUid);
+    
+    // Debug: log received mention info
+    log?.debug?.(`dmwork: [RECV] mention payload: uidsCount=${mentionUids.length}, all=${mentionAll}, originalCount=${originalMentionUids.length}`);
 
     if (!isMentioned) {
       // Record as pending history context (manual — avoids SDK format incompatibility)
@@ -130,10 +222,10 @@ export async function handleInboundMessage(params: {
     // Take last N entries (sliding window)
     if (entries.length > historyLimit) {
       entries = entries.slice(-historyLimit);
-      groupHistories.set(sessionId, entries);  // Persist trimmed entries
+      groupHistories.set(sessionId, entries); // Persist trimmed array to prevent unbounded growth
     }
     const historyCountBefore = entries.length;
-    log?.info?.(`dmwork: [MENTION] 收到@消息 | from=${message.from_uid} | 缓存=${historyCountBefore}条 | historyLimit=${historyLimit} | session=${sessionId}`);
+    log?.info?.(`dmwork: [MENTION] 收到@消息 | 缓存=${historyCountBefore}条 | historyLimit=${historyLimit}`);
 
     // If memory cache is empty, try fetching from API
     if (entries.length === 0 && account.config.botToken) {
@@ -156,7 +248,6 @@ export async function handleInboundMessage(params: {
             body: m.content,
             timestamp: m.timestamp * 1000,
           }));
-        groupHistories.set(sessionId, entries);  // Persist API-fetched entries
         log?.info?.(`dmwork: [MENTION] 从API获取到 ${entries.length} 条历史消息`);
       } catch (err) {
         log?.error?.(`dmwork: [MENTION] 从API获取历史失败: ${err}`);
@@ -299,14 +390,110 @@ export async function handleInboundMessage(params: {
         const content = contentParts.join("\n").trim();
         if (!content) return;
 
+        // Build mentionUids from @mentions in content, using memberMap to resolve displayName -> uid
+        // The order of mentionUids MUST match the order of @xxx in content for correct linking!
+        let replyMentionUids: string[] = [];
+        let finalContent = content;
+        
+        if (isGroup) {
+          // Parse all @mentions from content (support Chinese, English, dots, underscores, hex uids)
+          const contentMentions = content.match(/@[\w\u4e00-\u9fa5.]+/g) ?? [];
+          
+          log?.debug?.(`dmwork: [REPLY] content @mentions count: ${contentMentions.length}`);
+          log?.debug?.(`dmwork: [REPLY] memberMap size: ${memberMap.size}, uidToNameMap size: ${uidToNameMap.size}`);
+          
+          // Track if we need to retry after cache refresh
+          let unresolvedNames: { name: string; index: number }[] = [];
+          
+          // Helper to resolve a single mention
+          const resolveMention = (name: string): { uid: string | null; newContent: string } => {
+            // First try memberMap (displayName -> uid)
+            let uid = memberMap.get(name);
+            let newContent = finalContent;
+            
+            if (uid) {
+              log?.debug?.(`dmwork: [REPLY] resolved displayName to uid`);
+              return { uid, newContent };
+            } else if (/^[a-f0-9]{32}$/i.test(name)) {
+              // Looks like a hex uid (32 chars) - try to find display name
+              const displayName = uidToNameMap.get(name);
+              if (displayName) {
+                newContent = newContent.replace(`@${name}`, `@${displayName}`);
+                log?.debug?.(`dmwork: [REPLY] replaced uid with displayName`);
+                return { uid: name, newContent };
+              } else {
+                log?.warn?.(`dmwork: [REPLY] unknown hex uid, no displayName found`);
+                return { uid: name, newContent };
+              }
+            } else if (/^[a-zA-Z0-9_]+$/.test(name)) {
+              // Looks like a uid format (alphanumeric + underscore)
+              const displayName = uidToNameMap.get(name);
+              if (displayName) {
+                newContent = newContent.replace(`@${name}`, `@${displayName}`);
+                log?.debug?.(`dmwork: [REPLY] replaced uid with displayName`);
+                return { uid: name, newContent };
+              } else {
+                log?.debug?.(`dmwork: [REPLY] using mention as uid directly`);
+                return { uid: name, newContent };
+              }
+            } else {
+              // Chinese name not found - track for retry
+              return { uid: null, newContent };
+            }
+          };
+          
+          // First pass: try to resolve all mentions, tracking indices for order preservation
+          const resolvedUids: (string | null)[] = [];
+          for (const mention of contentMentions) {
+            const name = mention.slice(1);
+            const result = resolveMention(name);
+            finalContent = result.newContent;
+            resolvedUids.push(result.uid); // null if unresolved
+            if (!result.uid) {
+              unresolvedNames.push({ name, index: resolvedUids.length - 1 });
+            }
+          }
+          
+          // If we have unresolved names, try refreshing the cache and retry
+          if (unresolvedNames.length > 0) {
+            log?.info?.(`dmwork: [REPLY] ${unresolvedNames.length} unresolved names, force refreshing cache...`);
+            const refreshed = await refreshGroupMemberCache(true);
+            
+            if (refreshed) {
+              // Retry unresolved names and insert at original positions
+              for (const { name, index } of unresolvedNames) {
+                const uid = memberMap.get(name);
+                if (uid) {
+                  resolvedUids[index] = uid; // Insert at original position
+                  log?.debug?.(`dmwork: [REPLY] after refresh: resolved @${name}`);
+                } else {
+                  log?.warn?.(`dmwork: [REPLY] after refresh: still cannot resolve @${name}`);
+                }
+              }
+            }
+          }
+          
+          // Build final mention UIDs array preserving original order
+          replyMentionUids = resolvedUids.filter((uid): uid is string => uid !== null);
+          
+          // Always include the original sender so they get notified of the reply
+          if (message.from_uid && !replyMentionUids.includes(message.from_uid)) {
+            replyMentionUids.unshift(message.from_uid);
+          }
+          
+          if (replyMentionUids.length > 0) {
+            log?.debug?.(`dmwork: [REPLY] final mentionUids count: ${replyMentionUids.length}`);
+            log?.debug?.(`dmwork: [REPLY] final content length: ${finalContent.length}`);
+          }
+        }
+
         await sendMessage({
           apiUrl: account.config.apiUrl,
           botToken: account.config.botToken ?? "",
           channelId: replyChannelId,
           channelType: replyChannelType,
-          content,
-          // In group replies, @mention the original sender
-          ...(isGroup ? { mentionUids: [message.from_uid] } : {}),
+          content: finalContent,
+          ...(replyMentionUids.length > 0 ? { mentionUids: replyMentionUids } : {}),
         });
 
         statusSink?.({ lastOutboundAt: Date.now(), lastError: null });