@soimy/dingtalk 3.3.0 → 3.4.1

package/src/channel.ts

@@ -1,10 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { DWClient, TOPIC_CARD, TOPIC_ROBOT } from "dingtalk-stream";
-import type {
-  ChannelMessageActionAdapter,
-  OpenClawConfig,
-} from "openclaw/plugin-sdk";
-import * as pluginSdk from "openclaw/plugin-sdk";
+import type { ChannelMessageActionAdapter } from "openclaw/plugin-sdk/channel-contract";
+import { buildChannelConfigSchema, type OpenClawConfig } from "openclaw/plugin-sdk/core";
+import { jsonResult } from "openclaw/plugin-sdk/telegram-core";
+import { readStringParam } from "openclaw/plugin-sdk/param-readers";
+import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
 import { getAccessToken } from "./auth";
 import { analyzeCardCallback } from "./card-callback-service";
 import {
@@ -18,23 +18,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 { 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 { handleDingTalkMessage } from "./inbound-handler";
+import { getLogger } from "./logger-context";
+import { prepareMediaInput, resolveOutboundMediaType } from "./media-utils";
+import { dingtalkSetupAdapter, dingtalkSetupWizard } from "./onboarding.js";
+import { resolveOriginalPeerId, preloadPeerIdsFromSessions } from "./peer-id-registry";
+import { getDingTalkRuntime } from "./runtime";
 import {
   sendMessage,
   sendProactiveMedia,
@@ -42,6 +43,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 +100,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 +112,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;
   }
 
@@ -195,26 +209,46 @@ function readBooleanLikeParam(params: Record<string, unknown>, key: string): boo
   return undefined;
 }
 
+function describeDingTalkMessageTool(cfg: OpenClawConfig): {
+  actions: readonly ["send"] | readonly [];
+  capabilities: readonly ["cards"] | readonly [];
+  schema: null;
+} {
+  const config = getConfig(cfg);
+  const configured = Boolean(config.clientId && config.clientSecret);
+  if (!configured && !(config.accounts && Object.keys(config.accounts).length > 0)) {
+    return { actions: [], capabilities: [], schema: null };
+  }
+  const hasCardMode =
+    config.messageType === "card" ||
+    (config.accounts && Object.values(config.accounts).some((a) => a?.messageType === "card"));
+  return {
+    actions: ["send"] as const,
+    capabilities: hasCardMode ? (["cards"] as const) : [],
+    schema: null,
+  };
+}
+
 const dingtalkMessageActions: ChannelMessageActionAdapter = {
-  listActions: () => ["send"],
+  describeMessageTool: ({ cfg }) => describeDingTalkMessageTool(cfg),
   supportsAction: ({ action }) => action === "send",
-  extractToolSend: ({ args }) => pluginSdk.extractToolSend(args, "sendMessage"),
-  handleAction: async ({ action, params, cfg, accountId, dryRun }) => {
+  extractToolSend: ({ args }) => extractToolSend(args, "sendMessage"),
+  handleAction: async ({ action, params, cfg, accountId, dryRun, mediaLocalRoots }) => {
     if (action !== "send") {
       throw new Error(`Action ${action} is not supported for provider dingtalk.`);
     }
 
-    const to = pluginSdk.readStringParam(params, "to", { required: true });
+    const to = readStringParam(params, "to", { required: true });
     const mediaInput =
-      pluginSdk.readStringParam(params, "media", { trim: false }) ??
-      pluginSdk.readStringParam(params, "path", { trim: false }) ??
-      pluginSdk.readStringParam(params, "filePath", { trim: false }) ??
-      pluginSdk.readStringParam(params, "mediaUrl", { trim: false });
+      readStringParam(params, "media", { trim: false }) ??
+      readStringParam(params, "path", { trim: false }) ??
+      readStringParam(params, "filePath", { trim: false }) ??
+      readStringParam(params, "mediaUrl", { trim: false });
 
     const hasMedia = Boolean(mediaInput && mediaInput.trim());
-    const caption = pluginSdk.readStringParam(params, "caption", { allowEmpty: true }) ?? "";
+    const caption = readStringParam(params, "caption", { allowEmpty: true }) ?? "";
     let message =
-      pluginSdk.readStringParam(params, "message", {
+      readStringParam(params, "message", {
         required: !hasMedia,
         allowEmpty: true,
       }) ?? "";
@@ -224,12 +258,12 @@ const dingtalkMessageActions: ChannelMessageActionAdapter = {
     }
 
     const asVoice = readBooleanLikeParam(params, "asVoice") === true;
-    const requestedMediaType = pluginSdk.readStringParam(params, "mediaType");
+    const requestedMediaType = readStringParam(params, "mediaType");
 
     const target = resolveOriginalPeerId(stripTargetPrefix(to).targetId);
 
     if (dryRun) {
-      return pluginSdk.jsonResult({
+      return jsonResult({
         ok: true,
         dryRun: true,
         to: target,
@@ -256,13 +290,14 @@ const dingtalkMessageActions: ChannelMessageActionAdapter = {
         const result = await sendProactiveMedia(config, target, mediaPath, mediaType, {
           log,
           accountId: accountId ?? undefined,
+          mediaLocalRoots: mediaLocalRoots ? [...mediaLocalRoots] : undefined,
         });
 
         if (!result.ok) {
           throw new Error(result.error || "send media failed");
         }
 
-        return pluginSdk.jsonResult({
+        return jsonResult({
           ok: true,
           to: target,
           mediaType,
@@ -294,7 +329,7 @@ const dingtalkMessageActions: ChannelMessageActionAdapter = {
     }
 
     const data = result.data as any;
-    return pluginSdk.jsonResult({
+    return jsonResult({
       ok: true,
       to: target,
       messageId: data?.processQueryKey || data?.messageId || null,
@@ -311,12 +346,13 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
     id: "dingtalk",
     label: "DingTalk",
     selectionLabel: "DingTalk (钉钉)",
-    docsPath: "/channels/dingtalk",
+    docsPath: "https://github.com/soimy/openclaw-channel-dingtalk",
     blurb: "钉钉企业内部机器人，使用 Stream 模式，无需公网 IP。",
     aliases: ["dd", "ding"],
   },
-  configSchema: pluginSdk.buildChannelConfigSchema(DingTalkConfigSchema),
-  onboarding: dingtalkOnboardingAdapter,
+  configSchema: buildChannelConfigSchema(DingTalkConfigSchema),
+  setup: dingtalkSetupAdapter,
+  setupWizard: dingtalkSetupWizard,
   capabilities: {
     chatTypes: ["direct", "group"] as Array<"direct" | "group">,
     reactions: false,
@@ -339,9 +375,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 +406,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 +425,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 +450,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);
@@ -455,6 +504,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
       mediaType: providedMediaType,
       asVoice,
       accountId,
+      mediaLocalRoots,
       log,
     }: any) => {
       const config = getConfig(cfg, accountId);
@@ -490,12 +540,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
@@ -518,10 +573,13 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
             accountId,
             storePath,
             conversationId: to,
+            mediaLocalRoots,
           });
         } 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 +715,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 +725,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 +751,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 +770,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

@@ -1,6 +1,6 @@
 import * as os from "node:os";
 import * as path from "node:path";
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import type { DingTalkConfig } from "./types";
 
 const WINDOWS_ROOT_DIRECTORIES = new Set([
@@ -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) || "👀";
 }
 
 /**

package/src/connection-manager.ts

@@ -112,6 +112,18 @@ export class ConnectionManager {
     }
   }
 
+  /**
+   * Resolve all pending waitForStop() callers without performing full stop().
+   * Called by stop() and terminal FAILED states where the manager will never
+   * reconnect again, so startAccount must be allowed to exit.
+   */
+  private resolveStopWaiters(): void {
+    for (const resolve of this.stopPromiseResolvers) {
+      resolve();
+    }
+    this.stopPromiseResolvers = [];
+  }
+
   private logRuntimeCounters(reason: string): void {
     const c = this.runtimeCounters;
     this.log?.info?.(
@@ -722,6 +734,7 @@ export class ConnectionManager {
           this.notifyStateChange(
             `Max consecutive deadline timeouts (${ConnectionManager.MAX_CONSECUTIVE_DEADLINE_TIMEOUTS}) reached`,
           );
+          this.resolveStopWaiters();
           return;
         }
 
@@ -755,6 +768,7 @@ export class ConnectionManager {
         this.consecutiveUnhealthyChecks = 0;
         this.reconnectDeadline = undefined;
         this.notifyStateChange(`Max runtime reconnect cycles (${maxCycles}) reached`);
+        this.resolveStopWaiters();
         return;
       }
 
@@ -822,10 +836,7 @@ export class ConnectionManager {
     this.log?.info?.(`[${this.accountId}] Connection manager stopped`);
 
     // Resolve all pending waitForStop() promises
-    for (const resolve of this.stopPromiseResolvers) {
-      resolve();
-    }
-    this.stopPromiseResolvers = [];
+    this.resolveStopWaiters();
   }
 
   /**
@@ -835,7 +846,7 @@ export class ConnectionManager {
    * Safe to call concurrently; all pending callers are resolved when stop() is called.
    */
   public waitForStop(): Promise<void> {
-    if (this.stopped) {
+    if (this.stopped || this.state === ConnectionStateEnum.FAILED) {
       return Promise.resolve();
     }
     return new Promise<void>((resolve) => {