openclaw-channel-dmwork 0.5.12 → 0.5.14

package/package.json

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

package/src/api-fetch.test.ts

@@ -794,3 +794,83 @@ describe("uploadFileToCOS putParams ContentType", () => {
     expect(capturedParams.ContentType).toBe("text/plain; charset=utf-8");
   });
 });
+
+// --- fetchUserInfo ---
+import { fetchUserInfo } from "./api-fetch.js";
+
+describe("fetchUserInfo", () => {
+  it("returns user info on success", async () => {
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ uid: "s14_abc", name: "Alice", avatar: "https://example.com/a.png" }),
+    }) as any;
+
+    const result = await fetchUserInfo({
+      apiUrl: "http://localhost:8090",
+      botToken: "tok",
+      uid: "s14_abc",
+    });
+    expect(result).toEqual({ uid: "s14_abc", name: "Alice", avatar: "https://example.com/a.png" });
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      "http://localhost:8090/v1/bot/user/info?uid=s14_abc",
+      expect.objectContaining({ method: "GET" }),
+    );
+  });
+
+  it("returns null on 404 (endpoint not implemented)", async () => {
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: false,
+      status: 404,
+    }) as any;
+
+    const result = await fetchUserInfo({
+      apiUrl: "http://localhost:8090",
+      botToken: "tok",
+      uid: "s14_abc",
+    });
+    expect(result).toBeNull();
+  });
+
+  it("returns null on 500 error", async () => {
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: false,
+      status: 500,
+    }) as any;
+
+    const result = await fetchUserInfo({
+      apiUrl: "http://localhost:8090",
+      botToken: "tok",
+      uid: "s14_abc",
+      log: { error: vi.fn() },
+    });
+    expect(result).toBeNull();
+  });
+
+  it("returns null on network error", async () => {
+    globalThis.fetch = vi.fn().mockRejectedValue(new Error("ECONNREFUSED")) as any;
+
+    const result = await fetchUserInfo({
+      apiUrl: "http://localhost:8090",
+      botToken: "tok",
+      uid: "s14_abc",
+      log: { error: vi.fn() },
+    });
+    expect(result).toBeNull();
+  });
+
+  it("returns null when response has no name", async () => {
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ uid: "s14_abc" }),
+    }) as any;
+
+    const result = await fetchUserInfo({
+      apiUrl: "http://localhost:8090",
+      botToken: "tok",
+      uid: "s14_abc",
+    });
+    expect(result).toBeNull();
+  });
+});

package/src/api-fetch.ts

@@ -649,3 +649,40 @@ export async function editMessage(params: {
     content_edit: params.contentEdit,
   }, params.signal);
 }
+
+/**
+ * Fetch user info by UID. Requires backend `/v1/bot/user/info` endpoint.
+ * Returns null if the endpoint is unavailable (404) or returns an error,
+ * so callers can gracefully degrade.
+ */
+export async function fetchUserInfo(params: {
+  apiUrl: string;
+  botToken: string;
+  uid: string;
+  log?: { info?: (msg: string) => void; error?: (msg: string) => void };
+}): Promise<{ uid: string; name: string; avatar?: string } | null> {
+  const url = `${params.apiUrl.replace(/\/+$/, "")}/v1/bot/user/info?uid=${encodeURIComponent(params.uid)}`;
+  try {
+    const resp = await fetch(url, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${params.botToken}` },
+      signal: AbortSignal.timeout(5000),
+    });
+    if (resp.status === 404) {
+      // Endpoint not implemented yet — silent degrade
+      return null;
+    }
+    if (!resp.ok) {
+      params.log?.error?.(`dmwork: fetchUserInfo(${params.uid}) failed: ${resp.status}`);
+      return null;
+    }
+    const data = await resp.json() as { uid?: string; name?: string; avatar?: string };
+    if (data?.name) {
+      return { uid: data.uid ?? params.uid, name: data.name, avatar: data.avatar };
+    }
+    return null;
+  } catch (err) {
+    params.log?.error?.(`dmwork: fetchUserInfo(${params.uid}) error: ${String(err)}`);
+    return null;
+  }
+}

package/src/channel.ts

@@ -11,7 +11,7 @@ import {
   resolveDmworkAccount,
   type ResolvedDmworkAccount,
 } from "./accounts.js";
-import { registerBot, sendMessage, sendHeartbeat, sendMediaMessage, inferContentType, ensureTextCharset, fetchBotGroups, getGroupMd, parseImageDimensions, parseImageDimensionsFromFile, getUploadCredentials, uploadFileToCOS } from "./api-fetch.js";
+import { registerBot, sendMessage, sendHeartbeat, sendMediaMessage, inferContentType, ensureTextCharset, fetchBotGroups, getGroupMd, getGroupMembers, parseImageDimensions, parseImageDimensionsFromFile, getUploadCredentials, uploadFileToCOS } from "./api-fetch.js";
 import { WKSocket } from "./socket.js";
 import { handleInboundMessage, type DmworkStatusSink } from "./inbound.js";
 import { ChannelType, MessageType, type BotMessage, type MessagePayload } from "./types.js";
@@ -125,16 +125,26 @@ function getOrCreateGroupCacheTimestamps(accountId: string): Map<string, number>
 }
 
 
-// --- Group → Account mapping: tracks which account each group was received from ---
+// --- Group → Account mapping: tracks which accounts are active in each group ---
 // Used by handleAction to resolve the correct account when framework passes wrong accountId
-const _groupToAccount = new Map<string, string>(); // groupNo → accountId
+// A group may have multiple bots (1:N), so we store a Set of accountIds per group.
+const _groupToAccount = new Map<string, Set<string>>(); // groupNo → Set<accountId>
 
 export function registerGroupToAccount(groupNo: string, accountId: string): void {
-  _groupToAccount.set(groupNo, accountId);
+  let accounts = _groupToAccount.get(groupNo);
+  if (!accounts) {
+    accounts = new Set<string>();
+    _groupToAccount.set(groupNo, accounts);
+  }
+  accounts.add(accountId);
 }
 
 export function resolveAccountForGroup(groupNo: string): string | undefined {
-  return _groupToAccount.get(groupNo);
+  const accounts = _groupToAccount.get(groupNo);
+  if (!accounts || accounts.size === 0) return undefined;
+  // Only resolve when exactly one bot owns the group; multi-bot → ambiguous
+  if (accounts.size === 1) return accounts.values().next().value;
+  return undefined;
 }
 
 // --- Cache cleanup: evict groups inactive for >4 hours ---
@@ -155,7 +165,8 @@ function cleanupStaleCaches(): void {
       if (lastAccess < cutoff) {
         _historyMaps.get(accountId)?.delete(groupId);
         _memberMaps.get(accountId)?.delete(groupId);
-        _uidToNameMaps.get(accountId)?.delete(groupId);
+        // Note: uidToNameMap is a flat uid→name map (not keyed by groupId),
+        // so we don't delete from it here — names remain valid across groups.
         _groupCacheTimestamps.get(accountId)?.delete(groupId);
         activityMap.delete(groupId);
       }
@@ -252,11 +263,14 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
     handleAction: async (ctx: any) => {
       // Resolve correct accountId: framework may pass wrong one when agent has multiple accounts.
       // Use currentChannelId to look up which account actually owns the group.
+      // When multiple bots share the same group, do NOT correct — the caller's accountId is authoritative.
       let accountId = ctx.accountId ?? DEFAULT_ACCOUNT_ID;
       const currentChannelId = ctx.toolContext?.currentChannelId;
       if (currentChannelId) {
         const rawGroupNo = currentChannelId.replace(/^dmwork:/, '');
         const correctAccountId = resolveAccountForGroup(rawGroupNo);
+        // Only correct when resolveAccountForGroup returns a definitive answer
+        // (exactly one bot owns the group); multi-bot → undefined → no correction
         if (correctAccountId && correctAccountId !== accountId) {
           ctx.log?.info?.(`dmwork: handleAction accountId corrected: ${accountId} → ${correctAccountId} (group=${rawGroupNo})`);
           accountId = correctAccountId;
@@ -593,27 +607,49 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
       // Check for updates in background (fire-and-forget)
       checkForUpdates(account.config.apiUrl, log).catch(() => {});
 
-      // Prefetch GROUP.md for all groups (fire-and-forget)
+      // Prefetch GROUP.md and group members for all groups (fire-and-forget)
       const groupMdCache = getOrCreateGroupMdCache(account.accountId);
       (async () => {
         try {
           const groups = await fetchBotGroups({ apiUrl: account.config.apiUrl, botToken: account.config.botToken!, log });
           registerBotGroupIds(groups.map(g => g.group_no));
+          let mdCount = 0;
+          let memberCount = 0;
           for (const g of groups) {
+            // Prefetch GROUP.md
             try {
               const md = await getGroupMd({ apiUrl: account.config.apiUrl, botToken: account.config.botToken!, groupNo: g.group_no, log });
               if (md.content) {
                 groupMdCache.set(g.group_no, { content: md.content, version: md.version });
+                mdCount++;
               }
             } catch {
               // Ignore per-group failures (group may not have GROUP.md)
             }
+            // Prefetch group members → fill uidToNameMap for SenderName resolution
+            try {
+              const members = await getGroupMembers({ apiUrl: account.config.apiUrl, botToken: account.config.botToken!, groupNo: g.group_no, log });
+              const prefetchMemberMap = getOrCreateMemberMap(account.accountId);
+              const prefetchUidMap = getOrCreateUidToNameMap(account.accountId);
+              for (const m of members) {
+                if (m.uid && m.name) {
+                  prefetchMemberMap.set(m.name, m.uid);
+                  prefetchUidMap.set(m.uid, m.name);
+                  memberCount++;
+                }
+              }
+            } catch {
+              // Ignore per-group failures
+            }
+          }
+          if (mdCount > 0) {
+            log?.info?.(`dmwork: prefetched GROUP.md for ${mdCount} groups`);
           }
-          if (groupMdCache.size > 0) {
-            log?.info?.(`dmwork: prefetched GROUP.md for ${groupMdCache.size} groups`);
+          if (memberCount > 0) {
+            log?.info?.(`dmwork: prefetched ${memberCount} member names from ${groups.length} groups`);
           }
         } catch (err) {
-          log?.error?.(`dmwork: GROUP.md prefetch failed: ${String(err)}`);
+          log?.error?.(`dmwork: group prefetch failed: ${String(err)}`);
         }
       })();
 

package/src/inbound.ts

@@ -1,5 +1,5 @@
 import type { ChannelLogSink, OpenClawConfig } from "openclaw/plugin-sdk";
-import { sendMessage, sendReadReceipt, sendTyping, getChannelMessages, getGroupMembers, getGroupMd, postJson, sendMediaMessage, inferContentType, ensureTextCharset, parseImageDimensions, parseImageDimensionsFromFile, getUploadCredentials, uploadFileToCOS } from "./api-fetch.js";
+import { sendMessage, sendReadReceipt, sendTyping, getChannelMessages, getGroupMembers, getGroupMd, postJson, sendMediaMessage, inferContentType, ensureTextCharset, parseImageDimensions, parseImageDimensionsFromFile, getUploadCredentials, uploadFileToCOS, fetchUserInfo } from "./api-fetch.js";
 import type { ResolvedDmworkAccount } from "./accounts.js";
 import type { BotMessage } from "./types.js";
 import { ChannelType, MessageType } from "./types.js";
@@ -10,6 +10,7 @@ import {
   extractMentionUids,
   convertContentForLLM,
   buildSenderPrefix,
+  resolveSenderName,
   parseStructuredMentions,
   convertStructuredMentions,
   buildEntitiesFromFallback,
@@ -1035,6 +1036,14 @@ export async function handleInboundMessage(params: {
   const resolved = resolveContent(message.payload, account.config.apiUrl, log, account.config.cdnUrl);
   let rawBody = resolved.text;
   let inboundMediaUrl = resolved.mediaUrl;
+
+  // Opportunistic uid→name cache fill from MultipleForward payloads
+  if (message.payload?.type === MessageType.MultipleForward && Array.isArray(message.payload.users)) {
+    for (const u of message.payload.users as Array<{ uid?: string; name?: string }>) {
+      if (u.uid && u.name) uidToNameMap.set(u.uid, u.name);
+    }
+  }
+
   // For Image/GIF/Voice/Video: download media to local temp file so Core reads
   // local files instead of remote URLs (avoids hang on large/slow downloads in Core)
   const mediaDownloadTypes = [MessageType.Image, MessageType.GIF, MessageType.Voice, MessageType.Video];
@@ -1091,6 +1100,10 @@ export async function handleInboundMessage(params: {
       quotePrefix = `[Quoted message from ${replyFrom}]: ${replyContent}\n---\n`;
       log?.info?.(`dmwork: message quotes a reply (${quotePrefix.length} chars)`);
     }
+    // Cache reply sender name for uid→name resolution (opportunistic fill)
+    if (replyData.from_uid && replyData.from_name) {
+      uidToNameMap.set(replyData.from_uid, replyData.from_name);
+    }
   }
 
   // --- Mention gating for group messages ---
@@ -1105,15 +1118,18 @@ export async function handleInboundMessage(params: {
     await refreshGroupMemberCache({ sessionId, memberMap, uidToNameMap, groupCacheTimestamps, apiUrl: account.config.apiUrl, botToken: account.config.botToken ?? "", log });
   }
 
-  if (isGroup && requireMention) {
+  // Compute isMentioned at top level so it's available for WasMentioned in finalizeInboundContext
+  let isMentioned = false;
+  if (isGroup) {
     const mentionUids = extractMentionUids(message.payload?.mention);
-    // mention.all can be boolean `true` or numeric `1` depending on API version
     const mentionAllRaw = message.payload?.mention?.all;
     const mentionAll: boolean = mentionAllRaw === true || mentionAllRaw === 1;
-    const isMentioned = mentionAll || mentionUids.includes(botUid);
-    
+    isMentioned = mentionAll || mentionUids.includes(botUid);
+  }
+
+  if (isGroup && requireMention) {
     // Debug: log received mention info
-    log?.debug?.(`dmwork: [RECV] mention payload: uidsCount=${mentionUids.length}, all=${mentionAll}, originalCount=${originalMentionUids.length}`);
+    log?.debug?.(`dmwork: [RECV] mention payload: isMentioned=${isMentioned}, originalCount=${originalMentionUids.length}`);
 
     if (!isMentioned) {
       // Record as pending history context (manual — avoids SDK format incompatibility)
@@ -1302,6 +1318,29 @@ export async function handleInboundMessage(params: {
   // Inject GROUP.md as GroupSystemPrompt for group messages
   const groupSystemPrompt = isGroup && groupMdCache ? groupMdCache.get(message.channel_id!)?.content : undefined;
 
+  // Resolve sender display name — async fallback for DM users not in cache
+  let senderName = resolveSenderName(message.from_uid, uidToNameMap);
+  if (!senderName && !isGroup) {
+    // DM user not in any group cache — try backend user info API
+    // Skip if we already tried and failed (negative cache sentinel "")
+    const cached = uidToNameMap.get(message.from_uid);
+    if (cached === undefined) {
+      const userInfo = await fetchUserInfo({
+        apiUrl: account.config.apiUrl,
+        botToken: account.config.botToken ?? "",
+        uid: message.from_uid,
+        log,
+      });
+      if (userInfo?.name) {
+        senderName = userInfo.name;
+        uidToNameMap.set(message.from_uid, userInfo.name);
+      } else {
+        // Negative cache — prevent repeated API calls for unknown UIDs
+        uidToNameMap.set(message.from_uid, "");
+      }
+    }
+  }
+
   const ctxPayload = core.channel.reply.finalizeInboundContext({
     Body: body,
     BodyForAgent: body,  // ← 关键！AI 实际读取的是这个字段！
@@ -1321,6 +1360,9 @@ export async function handleInboundMessage(params: {
     ChatType: isGroup ? "group" : "direct",
     ConversationLabel: fromLabel,
     SenderId: message.from_uid,
+    SenderName: senderName,
+    SenderUsername: message.from_uid,
+    WasMentioned: isGroup ? isMentioned : undefined,
     MessageSid: String(message.message_id),
     Timestamp: message.timestamp ? message.timestamp * 1000 : undefined,
     GroupSubject: isGroup ? message.channel_id : undefined,

package/src/mention-utils.test.ts

@@ -486,3 +486,75 @@ describe("边界情况", () => {
     expect(allEntities[1]).toEqual({ uid: "uid_bob", offset: 13, length: 4 });
   });
 });
+
+// --- extractBaseUid & resolveSenderName ---
+import { extractBaseUid, resolveSenderName } from "./mention-utils.js";
+
+describe("extractBaseUid", () => {
+  it("strips space prefix", () => {
+    expect(extractBaseUid("s14_abc123")).toBe("abc123");
+  });
+
+  it("handles multi-digit space id", () => {
+    expect(extractBaseUid("s1234_user456")).toBe("user456");
+  });
+
+  it("returns uid unchanged when no space prefix", () => {
+    expect(extractBaseUid("abc123")).toBe("abc123");
+  });
+
+  it("returns uid unchanged for 's' without underscore", () => {
+    expect(extractBaseUid("system")).toBe("system");
+  });
+
+  it("does not strip non-numeric space prefix (e.g. service_bot)", () => {
+    expect(extractBaseUid("service_bot")).toBe("service_bot");
+    expect(extractBaseUid("support_team")).toBe("support_team");
+  });
+});
+
+describe("resolveSenderName", () => {
+  it("returns direct match", () => {
+    const map = new Map([["s14_abc", "Alice"]]);
+    expect(resolveSenderName("s14_abc", map)).toBe("Alice");
+  });
+
+  it("returns undefined when no match", () => {
+    const map = new Map([["s14_abc", "Alice"]]);
+    expect(resolveSenderName("s14_xyz", map)).toBeUndefined();
+  });
+
+  it("falls back to base uid (non-space entry)", () => {
+    const map = new Map([["abc", "Alice"]]);
+    expect(resolveSenderName("s14_abc", map)).toBe("Alice");
+  });
+
+  it("falls back to cross-space variant", () => {
+    // User known as s10_abc in one space, DM from s14_abc
+    const map = new Map([["s10_abc", "Alice"]]);
+    expect(resolveSenderName("s14_abc", map)).toBe("Alice");
+  });
+
+  it("does not cross-space fallback for non-prefixed uid", () => {
+    // uid "abc" without space prefix should not scan
+    const map = new Map([["s10_abc", "Alice"]]);
+    expect(resolveSenderName("abc", map)).toBeUndefined();
+  });
+
+  it("prefers direct match over cross-space", () => {
+    const map = new Map([["s14_abc", "Alice-14"], ["s10_abc", "Alice-10"]]);
+    expect(resolveSenderName("s14_abc", map)).toBe("Alice-14");
+  });
+});
+
+describe("buildSenderPrefix with cross-space", () => {
+  it("shows name(uid) for cross-space hit", () => {
+    const map = new Map([["s10_abc", "Alice"]]);
+    expect(buildSenderPrefix("s14_abc", map)).toBe("Alice(s14_abc)");
+  });
+
+  it("shows raw uid when no match", () => {
+    const map = new Map([["s10_xyz", "Bob"]]);
+    expect(buildSenderPrefix("s14_abc", map)).toBe("s14_abc");
+  });
+});

package/src/mention-utils.ts

@@ -319,13 +319,51 @@ export function convertContentForLLM(
 // ── Sender prefix utility ────────────────────────────────────────────────────
 
 /**
- * Build a sender label in the format "displayName(uid)" for history context.
- * Falls back to just uid if no name is found.
+/**
+ * Extract the base uid from a space-prefixed uid.
+ * "s14_abc123" → "abc123", "abc123" → "abc123"
+ */
+export function extractBaseUid(uid: string): string {
+  // Space-prefixed format: s{digits}_{baseUid}
+  const match = uid.match(/^s(\d+)_(.+)$/);
+  if (match) return match[2];
+  return uid;
+}
+
+/**
+ * Resolve sender display name from uidToNameMap with cross-space fallback.
+ * 1. Direct lookup: uidToNameMap.get(from_uid)
+ * 2. Base uid fallback: strip space prefix and scan map for matching base uid
+ *    (covers DM users who appear in groups under a different space prefix)
  */
+export function resolveSenderName(
+  fromUid: string,
+  uidToNameMap: Map<string, string>,
+): string | undefined {
+  // Direct hit (same space or no space prefix)
+  const direct = uidToNameMap.get(fromUid);
+  if (direct) return direct;
+
+  // Cross-space fallback: extract base uid and scan
+  const baseUid = extractBaseUid(fromUid);
+  if (baseUid !== fromUid) {
+    // Check if the base uid itself is in the map (non-space account)
+    const baseHit = uidToNameMap.get(baseUid);
+    if (baseHit) return baseHit;
+
+    // Scan for any space-prefixed variant with the same base uid
+    for (const [uid, name] of uidToNameMap) {
+      if (extractBaseUid(uid) === baseUid) return name;
+    }
+  }
+
+  return undefined;
+}
+
 export function buildSenderPrefix(
   fromUid: string,
   uidToNameMap: Map<string, string>,
 ): string {
-  const name = uidToNameMap.get(fromUid);
+  const name = resolveSenderName(fromUid, uidToNameMap);
   return name ? `${name}(${fromUid})` : fromUid;
 }