@yaoyuanchao/dingtalk 1.6.0 → 1.6.1

package/package.json

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

package/src/monitor.ts

@@ -190,6 +190,32 @@ interface BufferedMessage {
 const messageBuffer = new Map<string, BufferedMessage>();
 const AGGREGATION_DELAY_MS = 2000; // 2 seconds - balance between UX and catching split messages
 
+// ============================================================================
+// Per-Session Message Queue - serializes dispatch to prevent concurrent
+// processing of messages in the same conversation. Uses Promise chaining:
+// each new message's dispatch waits for the previous one to complete.
+// ============================================================================
+
+const sessionQueues = new Map<string, Promise<void>>();
+const sessionQueueLastActivity = new Map<string, number>();
+const SESSION_QUEUE_TTL_MS = 5 * 60 * 1000; // 5 min
+
+const QUEUE_BUSY_PHRASES = [
+  "收到，前面还有消息在处理，稍后按顺序继续。",
+  "当前正在处理中，你的新消息已排队，完成后马上继续。",
+  "我还在处理上一条，这条已记下，稍后继续。",
+];
+
+/** Clean up expired session queues (runs periodically) */
+function cleanupExpiredSessionQueues(): void {
+  const now = Date.now();
+  for (const [key, ts] of sessionQueueLastActivity) {
+    if (now - ts > SESSION_QUEUE_TTL_MS && !sessionQueues.has(key)) {
+      sessionQueueLastActivity.delete(key);
+    }
+  }
+}
+
 function getBufferKey(msg: DingTalkRobotMessage, accountId: string): string {
   return `${accountId}:${msg.conversationId}:${msg.senderId || msg.senderStaffId}`;
 }
@@ -219,10 +245,16 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
     cleanupOldMedia();
   }, 60 * 60 * 1000); // 1 hour
 
+  // Schedule session queue cleanup every 60s
+  const queueCleanupInterval = setInterval(cleanupExpiredSessionQueues, 60_000);
+
   // Clean up on abort (only if abortSignal is provided)
   if (abortSignal) {
     abortSignal.addEventListener('abort', () => {
       clearInterval(cleanupInterval);
+      clearInterval(queueCleanupInterval);
+      sessionQueues.clear();
+      sessionQueueLastActivity.clear();
     });
   }
 
@@ -299,10 +331,10 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
   while (!abortSignal?.aborted) {
     try {
       await client.connect();
-      reconnectAttempt = 0;
-      lastActivityTime = Date.now();
+      const connectTime = Date.now();
+      lastActivityTime = connectTime;
       log?.info?.("[dingtalk:" + account.accountId + "] Stream connected");
-      setStatus?.({ running: true, lastStartAt: Date.now() });
+      setStatus?.({ running: true, lastStartAt: connectTime });
 
       // 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
@@ -331,6 +363,13 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
           }, { once: true });
         }
       });
+
+      // Only reset backoff if connection was stable (survived > 30s)
+      // This prevents rapid reconnect loops when connect() succeeds but
+      // the socket drops immediately (e.g. gateway returns unreachable endpoint)
+      if (Date.now() - connectTime > 30_000) {
+        reconnectAttempt = 0;
+      }
     } catch (err) {
       log?.warn?.("[dingtalk] Connection error: " + (err instanceof Error ? err.message : String(err)));
     }
@@ -1308,6 +1347,7 @@ async function flushMessageBuffer(bufferKey: string): Promise<void> {
 
 /**
  * Dispatch a message to the agent (after aggregation or immediately).
+ * Enqueues into per-session queue to prevent concurrent processing.
  */
 async function dispatchMessage(params: {
   ctx: DingTalkMonitorContext;
@@ -1321,6 +1361,78 @@ async function dispatchMessage(params: {
   conversationId: string;
   mediaPath?: string;
   mediaType?: string;
+}): Promise<void> {
+  const { ctx, conversationId } = params;
+  const { account, log } = ctx;
+
+  const queueKey = `${account.accountId}:${conversationId}`;
+  const isQueueBusy = sessionQueues.has(queueKey);
+
+  // If queue is busy, send a recallable notification so it disappears when processing starts
+  let queueAckCleanup: (() => Promise<void>) | null = null;
+  if (isQueueBusy) {
+    const phrase = QUEUE_BUSY_PHRASES[Math.floor(Math.random() * QUEUE_BUSY_PHRASES.length)];
+    log?.info?.("[dingtalk] Queue busy for " + queueKey + ", notifying user");
+    try {
+      if (account.clientId && account.clientSecret) {
+        const robotCode = account.robotCode || account.clientId;
+        const result = await sendTypingIndicator({
+          clientId: account.clientId,
+          clientSecret: account.clientSecret,
+          robotCode,
+          userId: params.isDm ? params.senderId : undefined,
+          conversationId: !params.isDm ? conversationId : undefined,
+          message: '⏳ ' + phrase,
+        });
+        if (!result.error) {
+          queueAckCleanup = result.cleanup;
+        }
+      }
+    } catch (_) { /* best-effort notification */ }
+  }
+
+  // Enqueue: chain onto previous task
+  const previousTask = sessionQueues.get(queueKey) || Promise.resolve();
+  const currentTask = previousTask
+    .then(async () => {
+      // Recall queue-busy notification before starting actual processing
+      if (queueAckCleanup) {
+        try { await queueAckCleanup(); log?.info?.("[dingtalk] Queue ack recalled, starting processing"); } catch (_) {}
+      }
+      await dispatchMessageInternal(params);
+    })
+    .catch((err) => {
+      log?.info?.("[dingtalk] Queued dispatch error: " + (err instanceof Error ? err.message : String(err)));
+    })
+    .finally(() => {
+      sessionQueueLastActivity.set(queueKey, Date.now());
+      // Clean up only if this is still the latest task
+      if (sessionQueues.get(queueKey) === currentTask) {
+        sessionQueues.delete(queueKey);
+      }
+    });
+
+  sessionQueues.set(queueKey, currentTask);
+  sessionQueueLastActivity.set(queueKey, Date.now());
+
+  // Don't await — fire-and-forget so message buffering and SDK callback stay responsive
+}
+
+/**
+ * Internal dispatch: actually processes the message (typing indicator, agent call, reply).
+ */
+async function dispatchMessageInternal(params: {
+  ctx: DingTalkMonitorContext;
+  msg: DingTalkRobotMessage;
+  rawBody: string;
+  replyTarget: any;
+  sessionKey: string;
+  isDm: boolean;
+  senderId: string;
+  senderName: string;
+  conversationId: string;
+  mediaPath?: string;
+  mediaType?: string;
 }): Promise<void> {
   const { ctx, msg, rawBody, replyTarget, sessionKey, isDm, senderId, senderName, conversationId, mediaPath, mediaType } = params;
   const { account, cfg, log, setStatus } = ctx;
@@ -1437,15 +1549,16 @@ async function dispatchMessage(params: {
         GroupSystemPrompt: _fallbackGroupSystemPrompt,
       };
 
-      // Fire-and-forget: don't await to avoid blocking SDK callback during long agent runs
-      runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+      // Await dispatch so per-session queue waits for reply delivery to complete
+      // before starting the next queued message.
+      await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
         ctx: ctxPayload,
         cfg: actualCfg,
         dispatcherOptions: {
           deliver: async (payload: any) => {
             // Recall typing indicator on first delivery
             await cleanupTyping();
-            
+
             log?.info?.("[dingtalk] Deliver payload keys: " + Object.keys(payload || {}).join(',') + " text?=" + (typeof payload?.text) + " markdown?=" + (typeof payload?.markdown));
             const textToSend = resolveDeliverText(payload, log);
             if (textToSend) {
@@ -1461,9 +1574,6 @@ async function dispatchMessage(params: {
             log?.info?.("[dingtalk] Reply error: " + err);
           },
         },
-      }).catch((err) => {
-        cleanupTyping().catch(() => {});
-        log?.info?.("[dingtalk] Dispatch failed: " + err);
       });
 
       // Record activity