@yaoyuanchao/dingtalk 1.7.6 → 1.7.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaoyuanchao/dingtalk",
-  "version": "1.7.6",
+  "version": "1.7.8",
   "type": "module",
   "description": "DingTalk channel plugin for ClawdBot/OpenClaw with Stream Mode support",
   "license": "MIT",

package/src/api.ts

@@ -116,11 +116,16 @@ export async function getDingTalkAccessToken(clientId: string, clientSecret: str
 export async function sendViaSessionWebhook(
   sessionWebhook: string,
   text: string,
+  atUserIds?: string[],
 ): Promise<{ ok: boolean; errcode?: number; errmsg?: string; processQueryKey?: string }> {
-  const res = await jsonPost(sessionWebhook, {
+  const body: any = {
     msgtype: "text",
     text: { content: text },
-  });
+  };
+  if (atUserIds?.length) {
+    body.at = { atUserIds, isAtAll: false };
+  }
+  const res = await jsonPost(sessionWebhook, body);
   const ok = res?.errcode === 0 || !res?.errcode;
   if (!ok) {
     console.warn(`[dingtalk] SessionWebhook text error: errcode=${res?.errcode}, errmsg=${res?.errmsg}`);
@@ -133,11 +138,16 @@ export async function sendMarkdownViaSessionWebhook(
   sessionWebhook: string,
   title: string,
   text: string,
+  atUserIds?: string[],
 ): Promise<{ ok: boolean; errcode?: number; errmsg?: string; processQueryKey?: string }> {
-  const res = await jsonPost(sessionWebhook, {
+  const body: any = {
     msgtype: "markdown",
     markdown: { title, text },
-  });
+  };
+  if (atUserIds?.length) {
+    body.at = { atUserIds, isAtAll: false };
+  }
+  const res = await jsonPost(sessionWebhook, body);
   const ok = res?.errcode === 0 || !res?.errcode;
   if (!ok) {
     console.warn(`[dingtalk] SessionWebhook markdown error: errcode=${res?.errcode}, errmsg=${res?.errmsg}`);

package/src/monitor.ts

@@ -46,6 +46,65 @@ function markMessageProcessed(messageId: string): void {
   }
 }
 
+// ============================================================================
+// Content-level dedup: DingTalk may re-deliver the same message with a NEW
+// msgId after Stream reconnect. Detect by sender + content hash + time window.
+// ============================================================================
+
+const CONTENT_DEDUP_WINDOW_MS = 2 * 60 * 1000; // 2 minutes
+const CONTENT_DEDUP_MAX = 200;
+const recentContentHashes = new Map<string, number>(); // hash → timestamp
+
+function simpleHash(str: string): string {
+  let h = 0;
+  for (let i = 0; i < str.length; i++) {
+    h = ((h << 5) - h + str.charCodeAt(i)) | 0;
+  }
+  return h.toString(36);
+}
+
+function isContentDuplicate(senderId: string, text: string, log?: any): boolean {
+  if (!senderId || !text || text.length < 4) return false;
+  const key = `${senderId}:${simpleHash(text)}:${text.length}`;
+  const prev = recentContentHashes.get(key);
+  if (prev && Date.now() - prev < CONTENT_DEDUP_WINDOW_MS) {
+    log?.info?.("[dingtalk] Content-level duplicate detected: sender=" + senderId + " len=" + text.length);
+    return true;
+  }
+  return false;
+}
+
+function markContentProcessed(senderId: string, text: string): void {
+  if (!senderId || !text || text.length < 4) return;
+  const key = `${senderId}:${simpleHash(text)}:${text.length}`;
+  recentContentHashes.set(key, Date.now());
+
+  // Evict old entries
+  if (recentContentHashes.size > CONTENT_DEDUP_MAX) {
+    const cutoff = Date.now() - CONTENT_DEDUP_WINDOW_MS;
+    for (const [k, ts] of recentContentHashes) {
+      if (ts < cutoff) recentContentHashes.delete(k);
+    }
+  }
+}
+
+// ============================================================================
+// Send Throttle - prevent hitting DingTalk's 40 QPS API rate limit.
+// Enforces a minimum interval between outbound API calls.
+// ============================================================================
+
+const SEND_THROTTLE_MS = 500; // 500ms minimum between sends
+let lastSendTime = 0;
+
+async function throttleSend(): Promise<void> {
+  const now = Date.now();
+  const elapsed = now - lastSendTime;
+  if (elapsed < SEND_THROTTLE_MS) {
+    await new Promise(resolve => setTimeout(resolve, SEND_THROTTLE_MS - elapsed));
+  }
+  lastSendTime = Date.now();
+}
+
 // ============================================================================
 // Message Cache - used to resolve quoted message content from originalMsgId
 // DingTalk Stream API does NOT include quoted content in reply callbacks;
@@ -311,7 +370,7 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
 
   // Reconnection configuration
   const HEARTBEAT_CHECK_MS = 30_000;     // Check connectivity every 30s
-  const HEARTBEAT_TIMEOUT_MS = 5 * 60 * 1000; // 5 min no activity = force reconnect
+  const HEARTBEAT_TIMEOUT_MS = 5 * 60 * 1000; // 5 min no activity = force reconnect (safety net only)
   const RECONNECT_BASE_MS = 1_000;       // 1s initial backoff
   const RECONNECT_CAP_MS = 30_000;       // 30s max backoff
   let reconnectAttempt = 0;
@@ -362,6 +421,7 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
   });
 
   client.registerAllEventListener((msg: any) => {
+    touchActivity(); // SDK events (including ping/pong) count as activity
     return { status: "SUCCESS", message: "OK" };
   });
 
@@ -378,7 +438,7 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
       log?.info?.("[dingtalk:" + account.accountId + "] Stream connected");
       setStatus?.({ running: true, lastStartAt: connectTime });
 
-      // Start heartbeat monitor: if no activity for 5 minutes, force disconnect to trigger reconnect.
+      // Start heartbeat monitor: if no activity for 5 min, force disconnect to trigger reconnect.
       // The SDK's keepAlive ping/pong (8s interval) handles socket-level liveness and sets
       // client.connected=false on missed pongs, which our poll loop below detects.
       // This heartbeat is a secondary safety net for higher-level silent failures where
@@ -1280,6 +1340,13 @@ async function processInboundMessage(
     }
   }
 
+  // Content-level dedup: DingTalk may re-deliver the same message with a
+  // completely new msgId after Stream reconnect. Catch by sender + content hash.
+  if (isContentDuplicate(senderId, rawBody, log)) {
+    return;
+  }
+  markContentProcessed(senderId, rawBody);
+
   const sessionKey = "dingtalk:" + account.accountId + ":" + (isDm ? "dm" : "group") + ":" + conversationId;
 
   const replyTarget = {
@@ -1959,6 +2026,10 @@ async function deliverReply(target: any, text: string, log?: any): Promise<void>
     }
   }
 
+  // Auto @mention sender in group chats (only on first chunk to avoid spam)
+  const atUserIds = (!target.isDm && target.senderId) ? [target.senderId] : undefined;
+  let atApplied = false; // Only @ on the first chunk
+
   for (const chunk of chunks) {
     let webhookSuccess = false;
     const maxRetries = 2;
@@ -1967,14 +2038,16 @@ async function deliverReply(target: any, text: string, log?: any): Promise<void>
     if (target.sessionWebhook && now < (target.sessionWebhookExpiry - 60_000)) {
       for (let attempt = 1; attempt <= maxRetries; attempt++) {
         try {
+          await throttleSend();
           log?.info?.("[dingtalk] Using sessionWebhook (attempt " + attempt + "/" + maxRetries + "), format=" + messageFormat);
           log?.info?.("[dingtalk] Sending text (" + chunk.length + " chars): " + chunk.substring(0, 200));
+          const currentAt = (!atApplied && atUserIds) ? atUserIds : undefined;
           let sendResult: { ok: boolean; errcode?: number; errmsg?: string; processQueryKey?: string };
           if (isMarkdown) {
             const markdownTitle = buildMarkdownPreviewTitle(chunk, "Jax");
-            sendResult = await sendMarkdownViaSessionWebhook(target.sessionWebhook, markdownTitle, chunk);
+            sendResult = await sendMarkdownViaSessionWebhook(target.sessionWebhook, markdownTitle, chunk, currentAt);
           } else {
-            sendResult = await sendViaSessionWebhook(target.sessionWebhook, chunk);
+            sendResult = await sendViaSessionWebhook(target.sessionWebhook, chunk, currentAt);
           }
           if (!sendResult.ok) {
             throw new Error(`SessionWebhook rejected: errcode=${sendResult.errcode}, errmsg=${sendResult.errmsg}`);
@@ -1988,6 +2061,7 @@ async function deliverReply(target: any, text: string, log?: any): Promise<void>
             // so interactiveCard quotes can resolve via repliedMsg.createdAt
             cacheOutboundMessageByTime(chunk);
           }
+          if (currentAt) atApplied = true;
           webhookSuccess = true;
           break;
         } catch (err) {
@@ -2008,6 +2082,7 @@ async function deliverReply(target: any, text: string, log?: any): Promise<void>
     // Fallback to REST API if webhook failed after all retries
     if (!webhookSuccess && target.account.clientId && target.account.clientSecret) {
       try {
+        await throttleSend();
         log?.info?.("[dingtalk] SessionWebhook unavailable, using REST API fallback");
         const restResult = await sendDingTalkRestMessage({
           clientId: target.account.clientId,