@soimy/dingtalk 3.3.0 → 3.4.0

package/src/channel.ts

@@ -1,9 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { DWClient, TOPIC_CARD, TOPIC_ROBOT } from "dingtalk-stream";
-import type {
-  ChannelMessageActionAdapter,
-  OpenClawConfig,
-} from "openclaw/plugin-sdk";
+import type { ChannelMessageActionAdapter, OpenClawConfig } from "openclaw/plugin-sdk";
 import * as pluginSdk from "openclaw/plugin-sdk";
 import { getAccessToken } from "./auth";
 import { analyzeCardCallback } from "./card-callback-service";
@@ -18,23 +15,24 @@ import {
   getConfig,
   isConfigured,
   mergeAccountWithDefaults,
+  resolveGroupConfig,
   resolveRelativePath,
   stripTargetPrefix,
 } from "./config";
 import { DingTalkConfigSchema } from "./config-schema.js";
 import { ConnectionManager } from "./connection-manager";
 import { isMessageProcessed, markMessageProcessed } from "./dedup";
+import {
+  isFeedbackLearningAutoApplyEnabled,
+  isFeedbackLearningEnabled,
+  recordExplicitFeedbackLearning,
+} from "./feedback-learning-service";
 import { handleDingTalkMessage } from "./inbound-handler";
 import { getLogger } from "./logger-context";
 import { prepareMediaInput, resolveOutboundMediaType } from "./media-utils";
 import { dingtalkOnboardingAdapter } from "./onboarding.js";
 import { resolveOriginalPeerId, preloadPeerIdsFromSessions } from "./peer-id-registry";
 import { getDingTalkRuntime } from "./runtime";
-import {
-  isFeedbackLearningAutoApplyEnabled,
-  isFeedbackLearningEnabled,
-  recordExplicitFeedbackLearning,
-} from "./feedback-learning-service";
 import {
   sendMessage,
   sendProactiveMedia,
@@ -42,6 +40,12 @@ import {
   sendBySession,
   uploadMedia,
 } from "./send-service";
+import {
+  listDingTalkDirectoryGroups,
+  listDingTalkDirectoryUsers,
+  normalizeResolvedDingTalkTarget,
+} from "./targeting/target-directory-adapter";
+import { looksLikeDingTalkTargetId, normalizeDingTalkTarget } from "./targeting/target-input";
 import type {
   DingTalkInboundMessage,
   GatewayStartContext,
@@ -93,7 +97,11 @@ function getInstrumentedEndpoint(client: InstrumentedDWClient): string | undefin
   if (typeof endpointConfig === "string") {
     return endpointConfig;
   }
-  if (endpointConfig && typeof endpointConfig === "object" && typeof endpointConfig.endpoint === "string") {
+  if (
+    endpointConfig &&
+    typeof endpointConfig === "object" &&
+    typeof endpointConfig.endpoint === "string"
+  ) {
     return endpointConfig.endpoint;
   }
   return undefined;
@@ -101,7 +109,10 @@ function getInstrumentedEndpoint(client: InstrumentedDWClient): string | undefin
 
 function instrumentConnectionStages(client: DWClient): void {
   const instrumented = client as unknown as InstrumentedDWClient;
-  if (typeof instrumented.getEndpoint !== "function" || typeof instrumented._connect !== "function") {
+  if (
+    typeof instrumented.getEndpoint !== "function" ||
+    typeof instrumented._connect !== "function"
+  ) {
     return;
   }
 
@@ -339,9 +350,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
       const config = getConfig(cfg);
       const id = accountId || "default";
       const account = config.accounts?.[id];
-      const resolvedConfig = account
-        ? mergeAccountWithDefaults(config, account)
-        : config;
+      const resolvedConfig = account ? mergeAccountWithDefaults(config, account) : config;
       const configured = Boolean(resolvedConfig.clientId && resolvedConfig.clientSecret);
       return {
         accountId: id,
@@ -372,7 +381,16 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
     }),
   },
   groups: {
-    resolveRequireMention: ({ cfg }: any): boolean => getConfig(cfg).groupPolicy !== "open",
+    resolveRequireMention: ({ cfg, groupId }: any): boolean => {
+      const config = getConfig(cfg);
+      if (groupId) {
+        const groupCfg = resolveGroupConfig(config, groupId);
+        if (groupCfg?.requireMention !== undefined) {
+          return groupCfg.requireMention;
+        }
+      }
+      return config.groupPolicy !== "open";
+    },
     resolveGroupIntroHint: ({ groupId, groupChannel }: any): string | undefined => {
       const parts = [`conversationId=${groupId}`];
       if (groupChannel) {
@@ -382,12 +400,20 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
     },
   },
   messaging: {
-    normalizeTarget: (raw: string) => (raw ? raw.replace(/^(dingtalk|dd|ding):/i, "") : undefined),
+    normalizeTarget: (raw: string) => (raw ? normalizeDingTalkTarget(raw) : undefined),
     targetResolver: {
-      looksLikeId: (id: string): boolean => /^[\w+\-/=]+$/.test(id),
-      hint: "<conversationId>",
+      looksLikeId: (raw: string, normalized?: string): boolean =>
+        looksLikeDingTalkTargetId(raw, normalized),
+      hint: "<displayName|conversationId|user:staffId|user:+861...>",
     },
   },
+  directory: {
+    self: async () => null,
+    listGroups: async (params) => listDingTalkDirectoryGroups(params),
+    listGroupsLive: async (params) => listDingTalkDirectoryGroups(params),
+    listPeers: async (params) => listDingTalkDirectoryUsers(params),
+    listPeersLive: async (params) => listDingTalkDirectoryUsers(params),
+  },
   actions: dingtalkMessageActions,
   outbound: {
     deliveryMode: "direct" as const,
@@ -399,9 +425,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           error: new Error("DingTalk message requires --to <conversationId>"),
         };
       }
-      const { targetId } = stripTargetPrefix(trimmed);
-      const resolved = resolveOriginalPeerId(targetId);
-      return { ok: true as const, to: resolved };
+      return { ok: true as const, to: normalizeResolvedDingTalkTarget(trimmed) };
     },
     sendText: async ({ cfg, to, text, accountId, log }: any) => {
       const config = getConfig(cfg, accountId);
@@ -490,12 +514,17 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           preparedMedia = await prepareMediaInput(rawMediaPath, log, config.mediaUrlAllowlist);
         } catch (err: any) {
           if (err?.response?.data !== undefined) {
-            log?.error?.(formatDingTalkErrorPayloadLog("outbound.sendMedia.prepare", err.response.data));
+            log?.error?.(
+              formatDingTalkErrorPayloadLog("outbound.sendMedia.prepare", err.response.data),
+            );
           }
           const errorCode = typeof err?.code === "string" ? `[${err.code}] ` : "";
-          throw new Error(`remote media preparation failed: ${errorCode}${err?.message || "unknown error"}`, {
-            cause: err,
-          });
+          throw new Error(
+            `remote media preparation failed: ${errorCode}${err?.message || "unknown error"}`,
+            {
+              cause: err,
+            },
+          );
         }
 
         const actualMediaPath = preparedMedia.cleanup
@@ -521,7 +550,9 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           });
         } catch (err: any) {
           if (err?.response?.data !== undefined) {
-            log?.error?.(formatDingTalkErrorPayloadLog("outbound.sendMedia.send", err.response.data));
+            log?.error?.(
+              formatDingTalkErrorPayloadLog("outbound.sendMedia.send", err.response.data),
+            );
           }
           throw new Error(`proactive media send failed: ${err?.message || "unknown error"}`, {
             cause: err,
@@ -657,6 +688,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
             if (!dedupKey) {
               ctx.log?.warn?.(`[${account.accountId}] No message ID available for deduplication`);
               stats.noMessageId += 1;
+              acknowledge();
               await handleDingTalkMessage({
                 cfg,
                 accountId: account.accountId,
@@ -666,7 +698,6 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
                 dingtalkConfig: config,
               });
               stats.processed += 1;
-              acknowledge();
               if (stats.received % INBOUND_COUNTER_LOG_EVERY === 0) {
                 logInboundCounters(ctx.log, account.accountId, "periodic");
               }
@@ -693,11 +724,13 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
                   `[${account.accountId}] Skipping in-flight duplicate message: ${dedupKey}`,
                 );
                 stats.inflightSkipped += 1;
+                acknowledge();
                 logInboundCounters(ctx.log, account.accountId, "inflight-skipped");
                 return;
               }
             }
 
+            acknowledge();
             processingDedupKeys.set(dedupKey, Date.now());
             try {
               await handleDingTalkMessage({
@@ -710,7 +743,6 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
               });
               stats.processed += 1;
               markMessageProcessed(dedupKey);
-              acknowledge();
               if (stats.received % INBOUND_COUNTER_LOG_EVERY === 0) {
                 logInboundCounters(ctx.log, account.accountId, "periodic");
               }

package/src/config-schema.ts

@@ -1,5 +1,11 @@
 import { z } from "zod";
-import { DEFAULT_JOURNAL_TTL_DAYS } from "./quote-journal";
+import { DEFAULT_MESSAGE_CONTEXT_TTL_DAYS } from "./message-context-store";
+
+const AckReactionSchema = z.union([
+  z.literal(""),
+  z.enum(["off", "emoji", "kaomoji"]),
+  z.string().min(1),
+]);
 
 const DingTalkAccountConfigShape = {
   /** Account name (optional display name) */
@@ -26,18 +32,24 @@ const DingTalkAccountConfigShape = {
   /** Direct message policy: open, pairing, or allowlist */
   dmPolicy: z.enum(["open", "pairing", "allowlist"]).optional().default("open"),
 
-  /** Group message policy: open or allowlist */
-  groupPolicy: z.enum(["open", "allowlist"]).optional().default("open"),
+  /** Group message policy: open, allowlist, or disabled */
+  groupPolicy: z.enum(["open", "allowlist", "disabled"]).optional().default("open"),
 
   /** List of allowed user IDs for allowlist policy */
   allowFrom: z.array(z.string()).optional(),
 
+  /** List of allowed user IDs for group allowlist policy */
+  groupAllowFrom: z.array(z.string()).optional(),
+
+  /** Default disabled. Enabling "all" allows learned displayName lookup but may misroute on stale/duplicate names and is available to all callers until upstream exposes requester authz context. */
+  displayNameResolution: z.enum(["disabled", "all"]).optional().default("disabled"),
+
   mediaUrlAllowlist: z.array(z.string()).optional(),
 
-  /** Official OpenClaw ackReaction entry for processing feedback; empty string disables it */
-  ackReaction: z.string().optional(),
+  /** Native ack reaction mode: off, emoji, or kaomoji */
+  ackReaction: AckReactionSchema.optional(),
 
-  journalTTLDays: z.number().int().min(1).optional().default(DEFAULT_JOURNAL_TTL_DAYS),
+  journalTTLDays: z.number().int().min(1).optional().default(DEFAULT_MESSAGE_CONTEXT_TTL_DAYS),
   /** Enable debug logging */
   debug: z.boolean().optional().default(false),
 
@@ -62,6 +74,8 @@ const DingTalkAccountConfigShape = {
       z.string(),
       z.object({
         systemPrompt: z.string().optional(),
+        requireMention: z.boolean().optional(),
+        groupAllowFrom: z.array(z.string()).optional(),
       }),
     )
     .optional(),
@@ -128,6 +142,14 @@ const DingTalkAccountConfigShape = {
 
   /** @deprecated Use learningNoteTtlMs */
   feedbackLearningNoteTtlMs: z.number().int().min(60_000).optional(),
+
+  /** Whether to convert markdown tables to plain text for better rendering on some clients (default: true) */
+  convertMarkdownTables: z.boolean().optional().default(true),
+
+  /** @mention the sender after card finalization in group chats.
+   *  Set to a non-empty string (e.g. "✅ 回复完成") to enable — the value is used as the message text.
+   *  Leave empty or omit to disable. */
+  cardAtSender: z.string().optional(),
 } as const;
 
 const DingTalkAccountConfigSchema = z.object(DingTalkAccountConfigShape);

package/src/config.ts

@@ -145,7 +145,7 @@ export const resolveUserPath = resolveRelativePath;
 export function resolveGroupConfig(
   cfg: DingTalkConfig,
   groupId: string,
-): { systemPrompt?: string } | undefined {
+): { systemPrompt?: string; requireMention?: boolean; groupAllowFrom?: string[] } | undefined {
   // Group config supports exact match first, then wildcard fallback.
   const groups = cfg.groups;
   if (!groups) {
@@ -169,6 +169,30 @@ function resolveAgentIdentityEmoji(cfg: OpenClawConfig, agentId?: string | null)
   return emoji || undefined;
 }
 
+function normalizeAckReactionValue(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return "";
+  }
+  const normalized = trimmed.toLowerCase();
+  if (normalized === "off") {
+    return "off";
+  }
+  if (normalized === "emoji") {
+    return "emoji";
+  }
+  if (normalized === "kaomoji") {
+    return "kaomoji";
+  }
+  if (trimmed === "🤔思考中") {
+    return "emoji";
+  }
+  return trimmed;
+}
+
 export function resolveAckReactionSetting(params: {
   cfg: OpenClawConfig;
   accountId?: string | null;
@@ -182,18 +206,18 @@ export function resolveAckReactionSetting(params: {
       : undefined;
 
   if (hasOwn(accountConfig, "ackReaction")) {
-    return typeof accountConfig.ackReaction === "string" ? accountConfig.ackReaction.trim() : "";
+    return normalizeAckReactionValue(accountConfig.ackReaction);
   }
   if (hasOwn(dingtalk, "ackReaction")) {
-    return typeof dingtalk.ackReaction === "string" ? dingtalk.ackReaction.trim() : "";
+    return normalizeAckReactionValue(dingtalk.ackReaction);
   }
 
   const messages = (params.cfg as any)?.messages;
   if (hasOwn(messages, "ackReaction")) {
-    return typeof messages.ackReaction === "string" ? messages.ackReaction.trim() : "";
+    return normalizeAckReactionValue(messages.ackReaction);
   }
 
-  return resolveAgentIdentityEmoji(params.cfg, params.agentId);
+  return resolveAgentIdentityEmoji(params.cfg, params.agentId) || "👀";
 }
 
 /**