@yaoyuanchao/dingtalk 1.5.10 → 1.6.0

package/src/monitor.ts

@@ -1,10 +1,51 @@
 import type { DingTalkRobotMessage, ResolvedDingTalkAccount, ExtractedMessage } from "./types.js";
 import { sendViaSessionWebhook, sendMarkdownViaSessionWebhook, sendDingTalkRestMessage, batchGetUserInfo, downloadPicture, downloadMediaFile, cleanupOldMedia, uploadMediaFile, sendFileMessage, textToMarkdownFile, sendTypingIndicator } from "./api.js";
 import { getDingTalkRuntime } from "./runtime.js";
+import { cacheInboundDownloadCode, getCachedDownloadCode } from "./quoted-msg-cache.js";
+import { resolveQuotedFile } from "./quoted-file-service.js";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
 
+// ============================================================================
+// Message Deduplication - prevent duplicate processing after Stream reconnect.
+// DingTalk re-delivers messages that weren't ACK'd before disconnect using the
+// same protocol messageId, so we track recently processed IDs.
+// ============================================================================
+
+const DEDUP_MAX_SIZE = 1000;
+const DEDUP_TTL_MS = 10 * 60 * 1000; // 10 minutes
+
+const processedMessageIds = new Map<string, number>(); // messageId → timestamp
+
+function isDuplicateMessage(messageId: string): boolean {
+  if (!messageId) return false;
+  return processedMessageIds.has(messageId);
+}
+
+function markMessageProcessed(messageId: string): void {
+  if (!messageId) return;
+  processedMessageIds.set(messageId, Date.now());
+
+  // Evict expired entries when cache exceeds max size
+  if (processedMessageIds.size > DEDUP_MAX_SIZE) {
+    const cutoff = Date.now() - DEDUP_TTL_MS;
+    for (const [id, ts] of processedMessageIds) {
+      if (ts < cutoff) processedMessageIds.delete(id);
+    }
+    // If still over limit after TTL eviction, drop oldest
+    if (processedMessageIds.size > DEDUP_MAX_SIZE) {
+      const overflow = processedMessageIds.size - DEDUP_MAX_SIZE;
+      let removed = 0;
+      for (const id of processedMessageIds.keys()) {
+        if (removed >= overflow) break;
+        processedMessageIds.delete(id);
+        removed++;
+      }
+    }
+  }
+}
+
 // ============================================================================
 // Message Cache - used to resolve quoted message content from originalMsgId
 // DingTalk Stream API does NOT include quoted content in reply callbacks;
@@ -26,6 +67,15 @@ const MSG_CACHE_FILE = path.join(os.homedir(), ".openclaw", "extensions", "dingt
 
 const msgCache = new Map<string, CachedMessage>();
 
+/** Time-indexed outbound message cache for interactiveCard quote resolution.
+ *  Key = send timestamp (ms), value = message text.
+ *  When a quote comes in with msgType=interactiveCard (no content), we look up
+ *  the closest outbound message by repliedMsg.createdAt within OUTBOUND_TIME_WINDOW_MS.
+ */
+const outboundByTime: Array<{ ts: number; text: string }> = [];
+const OUTBOUND_TIME_CACHE_MAX = 100;
+const OUTBOUND_TIME_WINDOW_MS = 10_000; // ±10s tolerance
+
 /** Load persisted cache from disk on startup */
 function loadMsgCache(): void {
   try {
@@ -87,7 +137,34 @@ function msgCacheSet(msgId: string, entry: CachedMessage): void {
 /** Cache an outbound (bot-sent) message so it can be resolved when quoted */
 export function cacheOutboundMessage(key: string, text: string): void {
   if (!key || !text) return;
-  msgCacheSet(key, { senderNick: 'Jax', text, msgtype: 'text', ts: Date.now() });
+  const now = Date.now();
+  msgCacheSet(key, { senderNick: 'Jax', text, msgtype: 'text', ts: now });
+  // Also cache by timestamp for interactiveCard quote resolution
+  outboundByTime.push({ ts: now, text });
+  if (outboundByTime.length > OUTBOUND_TIME_CACHE_MAX) outboundByTime.shift();
+}
+
+/** Cache an outbound message by timestamp only (for sessionWebhook sends that return no key) */
+export function cacheOutboundMessageByTime(text: string): void {
+  if (!text) return;
+  outboundByTime.push({ ts: Date.now(), text });
+  if (outboundByTime.length > OUTBOUND_TIME_CACHE_MAX) outboundByTime.shift();
+}
+
+/** Look up an outbound message by DingTalk createdAt timestamp (for interactiveCard quotes) */
+function resolveOutboundByTime(createdAt: number): string | undefined {
+  if (!createdAt || outboundByTime.length === 0) return undefined;
+  // Find the closest entry within the tolerance window
+  let best: { ts: number; text: string } | undefined;
+  let bestDiff = Infinity;
+  for (const entry of outboundByTime) {
+    const diff = Math.abs(entry.ts - createdAt);
+    if (diff < OUTBOUND_TIME_WINDOW_MS && diff < bestDiff) {
+      best = entry;
+      bestDiff = diff;
+    }
+  }
+  return best?.text;
 }
 
 // ============================================================================
@@ -166,15 +243,39 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
   const client = new DWClient({
     clientId: account.clientId,
     clientSecret: account.clientSecret,
+    keepAlive: true,       // Enable SDK ping/pong for socket-level liveness
+    autoReconnect: false,  // We manage reconnection with exponential backoff
   });
 
+  // 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 RECONNECT_BASE_MS = 1_000;       // 1s initial backoff
+  const RECONNECT_CAP_MS = 30_000;       // 30s max backoff
+  let reconnectAttempt = 0;
+  let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  let lastActivityTime = Date.now();
+
+  // Track message activity to extend heartbeat window
+  const touchActivity = () => { lastActivityTime = Date.now(); };
+
   client.registerCallbackListener(TOPIC_ROBOT, async (downstream: any) => {
+    const protocolMsgId = downstream.headers?.messageId;
+
     // Immediately ACK to prevent DingTalk from retrying (60s timeout)
-    // SDK method is socketCallBackResponse, not socketResponse
     try {
-      client.socketCallBackResponse(downstream.headers.messageId, { status: 'SUCCESS' });
+      client.socketCallBackResponse(protocolMsgId, { status: 'SUCCESS' });
     } catch (_) { /* best-effort ACK */ }
 
+    touchActivity(); // Track message activity for heartbeat
+
+    // Deduplication: skip messages already processed (e.g. re-delivered after reconnect)
+    if (isDuplicateMessage(protocolMsgId)) {
+      log?.info?.("[dingtalk] Duplicate message skipped: " + protocolMsgId);
+      return { status: "SUCCESS", message: "OK" };
+    }
+    markMessageProcessed(protocolMsgId);
+
     try {
       const data: DingTalkRobotMessage = typeof downstream.data === "string"
         ? JSON.parse(downstream.data) : downstream.data;
@@ -190,28 +291,76 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
     return { status: "SUCCESS", message: "OK" };
   });
 
-  const onAbort = () => {
-    try { client.disconnect?.(); } catch {}
-    setStatus?.({ running: false, lastStopAt: Date.now() });
-  };
-  if (abortSignal) {
-    abortSignal.addEventListener("abort", onAbort, { once: true });
-  }
-
-  await client.connect();
-  log?.info?.("[dingtalk:" + account.accountId + "] Stream connected");
-  setStatus?.({ running: true, lastStartAt: Date.now() });
-
-  // Keep this function alive until abort signal fires.
+  // ============================================================================
+  // Connection loop with custom heartbeat + exponential backoff reconnection.
+  // Keeps this function alive until abort signal fires.
   // If we return, OpenClaw considers the channel "stopped" and enters auto-restart loop.
-  // The DingTalk SDK's connect() resolves immediately (before WebSocket opens),
-  // so we must hold the Promise pending for the channel's entire lifetime.
-  await new Promise<void>((resolve) => {
-    if (abortSignal?.aborted) return resolve();
-    if (abortSignal) {
-      abortSignal.addEventListener("abort", () => resolve(), { once: true });
+  // ============================================================================
+  while (!abortSignal?.aborted) {
+    try {
+      await client.connect();
+      reconnectAttempt = 0;
+      lastActivityTime = Date.now();
+      log?.info?.("[dingtalk:" + account.accountId + "] Stream connected");
+      setStatus?.({ running: true, lastStartAt: Date.now() });
+
+      // Start heartbeat monitor: if no activity for 5 minutes, 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
+      // the socket stays open but DingTalk stops delivering messages.
+      heartbeatTimer = setInterval(() => {
+        const elapsed = Date.now() - lastActivityTime;
+        if (elapsed > HEARTBEAT_TIMEOUT_MS) {
+          log?.warn?.("[dingtalk] Heartbeat timeout (" + Math.round(elapsed / 1000) + "s since last activity), forcing reconnect");
+          if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; }
+          try { client.disconnect?.(); } catch {}
+        }
+      }, HEARTBEAT_CHECK_MS);
+
+      // Wait for disconnect or abort
+      await new Promise<void>((resolve) => {
+        // Poll client.connected (SDK sets false on socket close / system disconnect)
+        const pollTimer = setInterval(() => {
+          if (!client.connected) { clearInterval(pollTimer); resolve(); }
+        }, 1000);
+        if (abortSignal) {
+          abortSignal.addEventListener("abort", () => {
+            clearInterval(pollTimer);
+            resolve();
+          }, { once: true });
+        }
+      });
+    } catch (err) {
+      log?.warn?.("[dingtalk] Connection error: " + (err instanceof Error ? err.message : String(err)));
     }
-  });
+
+    // Clean up heartbeat
+    if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; }
+
+    if (abortSignal?.aborted) break; // Clean shutdown
+
+    setStatus?.({ running: false });
+
+    // Exponential backoff with jitter
+    reconnectAttempt++;
+    const backoff = Math.min(RECONNECT_BASE_MS * Math.pow(2, reconnectAttempt - 1), RECONNECT_CAP_MS);
+    const jitter = Math.random() * backoff * 0.3;
+    const delay = Math.round(backoff + jitter);
+    log?.info?.("[dingtalk] Reconnect attempt " + reconnectAttempt + " in " + delay + "ms");
+
+    // Sleep with abort-awareness
+    await new Promise<void>((resolve) => {
+      const timer = setTimeout(resolve, delay);
+      if (abortSignal) {
+        abortSignal.addEventListener("abort", () => { clearTimeout(timer); resolve(); }, { once: true });
+      }
+    });
+  }
+
+  // Final cleanup
+  try { client.disconnect?.(); } catch {}
+  setStatus?.({ running: false, lastStopAt: Date.now() });
 }
 
 /**
@@ -690,6 +839,15 @@ async function processInboundMessage(
     log?.info?.("[dingtalk] Audio ASR text available, skipping .amr download");
   }
 
+  // Cache inbound file/video/audio downloadCode for quoted-message fallback
+  if (extracted.mediaDownloadCode && msg.msgId && msg.conversationId &&
+      (extracted.messageType === 'file' || extracted.messageType === 'video' || extracted.messageType === 'audio')) {
+    cacheInboundDownloadCode(
+      account.accountId, msg.conversationId, msg.msgId,
+      extracted.mediaDownloadCode, extracted.messageType, msg.createAt,
+    );
+  }
+
   let rawBody = extracted.text;
 
   // Check if this might be a quote-only @mention (user quoted a message and @bot with no extra text)
@@ -821,6 +979,120 @@ async function processInboundMessage(
           const senderTag = quoteSender ? ` (${quoteSender})` : '';
           rawBody = `[引用回复${senderTag}: "${quotedContent.trim()}"]\n${rawBody}`;
           log?.info?.("[dingtalk] Added quoted message: " + quotedContent.slice(0, 50));
+        } else if (repliedMsg.msgType === 'interactiveCard' && repliedMsg.createdAt) {
+          // interactiveCard: DingTalk doesn't include content in quote payload.
+          // Try timestamp-based lookup against our outbound message cache.
+          const timeResolved = resolveOutboundByTime(repliedMsg.createdAt);
+          if (timeResolved) {
+            rawBody = `[引用回复 (Jax): "${timeResolved.trim().substring(0, 200)}"]\n${rawBody}`;
+            log?.info?.("[dingtalk] Resolved interactiveCard quote via timestamp (createdAt=" + repliedMsg.createdAt + "): " + timeResolved.slice(0, 50));
+          } else {
+            log?.warn?.("[dingtalk] interactiveCard quote: no timestamp match in outbound cache (createdAt=" + repliedMsg.createdAt + ", cache size=" + outboundByTime.length + ")");
+          }
+        } else if (['file', 'video', 'audio', 'unknownMsgType'].includes(repliedMsg.msgType)) {
+          // Quoted file/video/audio message — bot may not have seen the original.
+          // 'unknownMsgType' is returned by DingTalk for files sent via drag-and-drop
+          // (without @bot), so the bot never indexed the original message type.
+          // Fallback chain: inline downloadCode → cache → group file API
+          log?.info?.("[dingtalk] Quoted file-type message (msgType=" + repliedMsg.msgType + "), attempting fallback resolution");
+          const quoteSender = repliedMsg.senderNick || repliedMsg.senderName || '';
+          const quoteMsgId = repliedMsg.msgId;
+          let resolvedFile = false;
+
+          // 1. Try inline downloadCode (rare — usually absent when bot didn't see the original)
+          const inlineDownloadCode = repliedMsg.content?.downloadCode || repliedMsg.downloadCode;
+          if (inlineDownloadCode && account.clientId && account.clientSecret) {
+            try {
+              const robotCode = account.robotCode || account.clientId;
+              const dlResult = await downloadMediaFile(
+                account.clientId, account.clientSecret, robotCode,
+                inlineDownloadCode, repliedMsg.msgType,
+                repliedMsg.content?.fileName,
+              );
+              if (dlResult.filePath) {
+                if (!mediaPath) {
+                  mediaPath = dlResult.filePath;
+                  mediaType = dlResult.mimeType || repliedMsg.msgType;
+                }
+                const senderTag = quoteSender ? ` (${quoteSender})` : '';
+                rawBody = `[引用文件${senderTag}: ${dlResult.filePath}]\n${rawBody}`;
+                resolvedFile = true;
+                log?.info?.("[dingtalk] Quoted file resolved via inline downloadCode: " + dlResult.filePath);
+              }
+            } catch (err) {
+              log?.warn?.("[dingtalk] Quoted file inline download failed: " + err);
+            }
+          }
+
+          // 2. Try quoted-msg-cache
+          if (!resolvedFile && quoteMsgId && account.clientId && account.clientSecret) {
+            const cached = getCachedDownloadCode(account.accountId, msg.conversationId, quoteMsgId);
+            if (cached?.downloadCode) {
+              try {
+                const robotCode = account.robotCode || account.clientId;
+                const dlResult = await downloadMediaFile(
+                  account.clientId, account.clientSecret, robotCode,
+                  cached.downloadCode, cached.msgType as any,
+                );
+                if (dlResult.filePath) {
+                  if (!mediaPath) {
+                    mediaPath = dlResult.filePath;
+                    mediaType = dlResult.mimeType || cached.msgType;
+                  }
+                  const senderTag = quoteSender ? ` (${quoteSender})` : '';
+                  rawBody = `[引用文件${senderTag}: ${dlResult.filePath}]\n${rawBody}`;
+                  resolvedFile = true;
+                  log?.info?.("[dingtalk] Quoted file resolved via cache (downloadCode): " + dlResult.filePath);
+                }
+              } catch (err) {
+                log?.warn?.("[dingtalk] Quoted file cache download failed: " + err);
+              }
+            }
+          }
+
+          // 3. Try group file API fallback
+          if (!resolvedFile && account.clientId && account.clientSecret) {
+            try {
+              const fileResult = await resolveQuotedFile(
+                { clientId: account.clientId, clientSecret: account.clientSecret },
+                {
+                  openConversationId: msg.conversationId,
+                  // repliedMsg often lacks senderStaffId (DingTalk only provides encrypted senderId).
+                  // Fall back to the outer message sender's staffId — any group member works for space query.
+                  senderStaffId: repliedMsg.senderStaffId || msg.senderStaffId,
+                  fileCreatedAt: repliedMsg.createdAt || repliedMsg.createAt,
+                },
+                log,
+              );
+              if (fileResult) {
+                if (!mediaPath) {
+                  mediaPath = fileResult.media.path;
+                  mediaType = fileResult.media.mimeType;
+                }
+                const senderTag = quoteSender ? ` (${quoteSender})` : '';
+                const nameLabel = fileResult.name ? ` ${fileResult.name}` : '';
+                rawBody = `[引用文件${senderTag}:${nameLabel} ${fileResult.media.path}]\n${rawBody}`;
+                resolvedFile = true;
+                // Write back to cache for future lookups
+                if (quoteMsgId) {
+                  cacheInboundDownloadCode(
+                    account.accountId, msg.conversationId, quoteMsgId,
+                    undefined, repliedMsg.msgType, repliedMsg.createdAt || repliedMsg.createAt || Date.now(),
+                    { spaceId: fileResult.spaceId, fileId: fileResult.fileId },
+                  );
+                }
+                log?.info?.("[dingtalk] Quoted file resolved via group file API: " + fileResult.media.path);
+              }
+            } catch (err) {
+              log?.warn?.("[dingtalk] Quoted file group API fallback failed: " + err);
+            }
+          }
+
+          if (!resolvedFile) {
+            const senderTag = quoteSender ? ` (${quoteSender})` : '';
+            rawBody = `[引用文件${senderTag}，无法获取内容]\n${rawBody}`;
+            log?.warn?.("[dingtalk] Quoted file could not be resolved, all fallbacks exhausted. msgType=" + repliedMsg.msgType + " msgId=" + (quoteMsgId || 'unknown'));
+          }
         } else {
           log?.warn?.("[dingtalk] Reply message found but no content extracted, repliedMsg keys: " + Object.keys(repliedMsg || {}).join(',') + " | full: " + JSON.stringify(repliedMsg).substring(0, 500));
         }
@@ -1260,7 +1532,7 @@ async function dispatchWithFullPipeline(params: {
   }) ?? rawBody;
 
   // 6. Finalize inbound context (includes media info)
-  const to = isDm ? `dingtalk:${senderId}` : `dingtalk:group:${conversationId}`;
+  const to = isDm ? `dingtalk:dm:${senderId}` : `dingtalk:group:${conversationId}`;
 
   // 6a. Per-group system prompt (read from account.config.groups)
   const groupsConfig = account?.config?.groups ?? {};
@@ -1453,8 +1725,8 @@ async function deliverReply(target: any, text: string, log?: any): Promise<void>
     let webhookSuccess = false;
     const maxRetries = 2;
 
-    // Try sessionWebhook with retry
-    if (target.sessionWebhook && now < target.sessionWebhookExpiry) {
+    // Try sessionWebhook with retry (60s safety buffer before expiry)
+    if (target.sessionWebhook && now < (target.sessionWebhookExpiry - 60_000)) {
       for (let attempt = 1; attempt <= maxRetries; attempt++) {
         try {
           log?.info?.("[dingtalk] Using sessionWebhook (attempt " + attempt + "/" + maxRetries + "), format=" + messageFormat);
@@ -1473,13 +1745,22 @@ async function deliverReply(target: any, text: string, log?: any): Promise<void>
           // Cache outbound message so it can be resolved when quoted
           if (sendResult.processQueryKey) {
             cacheOutboundMessage(sendResult.processQueryKey, chunk);
+          } else {
+            // sessionWebhook doesn't return processQueryKey — cache by timestamp only
+            // so interactiveCard quotes can resolve via repliedMsg.createdAt
+            cacheOutboundMessageByTime(chunk);
           }
           webhookSuccess = true;
           break;
         } catch (err) {
-          log?.info?.("[dingtalk] SessionWebhook attempt " + attempt + " failed: " + (err instanceof Error ? err.message : String(err)));
+          const errMsg = err instanceof Error ? err.message : String(err);
+          log?.info?.("[dingtalk] SessionWebhook attempt " + attempt + " failed: " + errMsg);
+          // If webhook is definitively expired/invalid, skip remaining retries
+          if (errMsg.includes('880001') || errMsg.includes('invalid session') || errMsg.includes('expired') || errMsg.includes('token is not exist')) {
+            log?.info?.("[dingtalk] SessionWebhook expired/invalid, falling through to REST API");
+            break;
+          }
           if (attempt < maxRetries) {
-            // Wait 1 second before retry
             await new Promise(resolve => setTimeout(resolve, 1000));
           }
         }
@@ -1489,16 +1770,15 @@ 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 {
-        log?.info?.("[dingtalk] SessionWebhook failed after " + maxRetries + " attempts, using REST API fallback");
-        // REST API only supports text format
-        const textChunk = messageFormat === "markdown" ? chunk : chunk;
+        log?.info?.("[dingtalk] SessionWebhook unavailable, using REST API fallback");
         const restResult = await sendDingTalkRestMessage({
           clientId: target.account.clientId,
           clientSecret: target.account.clientSecret,
           robotCode: target.account.robotCode || target.account.clientId,
           userId: target.isDm ? target.senderId : undefined,
           conversationId: !target.isDm ? target.conversationId : undefined,
-          text: textChunk,
+          text: chunk,
+          format: isMarkdown ? 'markdown' : 'text',
         });
         log?.info?.("[dingtalk] REST API send OK" + (restResult.processQueryKey ? ` pqk=${restResult.processQueryKey}` : ''));
         // Cache outbound message so it can be resolved when quoted