@xmanrui/dsh-im 0.7.0 → 0.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmanrui/dsh-im",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "通过扫码、App Manifest或机器人凭据把IM机器人接入DeepSeek Harness（支持飞书、微信、钉钉、企业微信、QQ、Slack、Telegram、Discord和WhatsApp）。",
   "license": "MIT",
   "type": "module",

package/src/channels/dingtalk/dingtalk-bridge.mjs

@@ -3,11 +3,18 @@ import {
   splitDingtalkText,
 } from './dingtalk-api.mjs';
 import { createDingTalkCardStream } from './dingtalk-card-stream.mjs';
+import {
+  harnessAnswerForQuestion,
+  harnessQuestionText,
+  validHarnessQuestion,
+} from '../shared/harness-question.mjs';
+import { HarnessApprovalQueue } from '../shared/harness-approval.mjs';
 import { runWorkspaceCommand } from '../shared/workspace-command.mjs';
 import { askInWorkspaceSession } from '../shared/workspace-session.mjs';
 
 const CARD_INITIAL_TEXT = '已连接 DeepSeek Harness，正在思考…';
 const CARD_ERROR_TEXT = '消息处理失败，请稍后重试。';
+const INTERACTION_RESOLVED_TEXT = '这个问题已在其他客户端处理，无需再次回答。';
 
 const HELP_TEXT = [
   '钉钉机器人已连接 DeepSeek Harness。',
@@ -55,6 +62,19 @@ function progressText(update) {
   return `_${nonEmptyString(update?.text) ?? '正在处理…'}_`;
 }
 
+function canClaimInteractionReply(message, pending, sender) {
+  if (pending.needsPresentation || !pending.questions[pending.index]) return false;
+  if (pending.actor !== sender) return false;
+  if (String(message?.conversationType) === '2' && message?.isInAtList !== true) return false;
+  if (message?.msgtype !== 'text' || !nonEmptyString(message?.text?.content)) return false;
+  try {
+    normalizeDingtalkSessionWebhook(message.sessionWebhook);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function ensureStats(status) {
   status.stats ??= {};
   for (const key of ['messagesReceived', 'messagesReplied', 'messagesRejected', 'messagesIgnored']) {
@@ -102,7 +122,11 @@ export class DingtalkHarnessBridge {
   #maxMessageChars;
   #signal;
   #queues = new Map();
+  #pendingInteractions = new Map();
+  #interactionKeys = new Map();
+  #interactionTasks = new Set();
   #acceptedMessageIds = new Set();
+  #approvals;
 
   constructor({
     api,
@@ -128,6 +152,7 @@ export class DingtalkHarnessBridge {
     this.#state = state;
     this.#status = status;
     this.#logger = logger;
+    this.#approvals = new HarnessApprovalQueue({ label: 'DingTalk', logger });
     this.#replyTimeoutMs = replyTimeoutMs;
     this.#maxMessageChars = maxMessageChars;
     this.#signal = signal;
@@ -157,12 +182,99 @@ export class DingtalkHarnessBridge {
       this.#status.lastRejectedAt = new Date().toISOString();
       return Promise.resolve();
     }
+
+    let sessionWebhook = null;
+    try {
+      sessionWebhook = normalizeDingtalkSessionWebhook(message.sessionWebhook);
+    } catch {
+      // An unsafe reply route must never be able to submit an approval.
+    }
+    const pending = this.#pendingInteractions.get(key);
+    const approvalReply = this.#approvals.claimReply({
+      key,
+      actor: sender,
+      messageId,
+      text: sessionWebhook && message?.msgtype === 'text'
+        ? nonEmptyString(message?.text?.content) ?? ''
+        : '',
+      addressed: String(message?.conversationType) !== '2' || message?.isInAtList === true,
+      hasPendingQuestion: Boolean(pending),
+      questionCompletion: pending?.submitting || pending?.claimedReplyMessageId
+        ? pending.queue
+        : null,
+      isQuestionPending: () => this.#pendingInteractions.has(key),
+      send: sessionWebhook
+        ? (reply) => this.#send(sessionWebhook, reply)
+        : async () => undefined,
+    });
+    if (approvalReply) {
+      let current;
+      current = approvalReply.process(async () => {
+          if (this.#state.hasSeen(messageId)) return false;
+          await this.#state.markSeen(messageId);
+          increment(this.#status, 'messagesReceived');
+          this.#status.lastMessageAt = new Date().toISOString();
+          if (!sessionWebhook) {
+            increment(this.#status, 'messagesRejected');
+            this.#status.lastRejectedAt = new Date().toISOString();
+            this.#status.lastError = '钉钉消息没有安全的回复地址。';
+          }
+          return true;
+        })
+        .catch((error) => {
+          if (this.#signal?.aborted) return;
+          this.#status.lastError = '钉钉审批处理失败。';
+          this.#logger.error?.('[dsh-dingtalk] failed to process an approval reply', error);
+        })
+        .finally(() => {
+          this.#acceptedMessageIds.delete(messageId);
+          this.#interactionTasks.delete(current);
+        });
+      this.#interactionTasks.add(current);
+      return current;
+    }
+
+    if (pending && pending.actor !== sender) {
+      return this.#enqueueMessage(message, messageId, sender, key);
+    }
+    // Once one valid answer has been claimed, later messages are subsequent
+    // prompts even if the network submission eventually needs a retry. Invalid
+    // replies do not claim the question, so the next valid answer can still
+    // pass through this interaction queue.
+    if (pending?.submitting || pending?.claimedReplyMessageId) {
+      return this.#enqueueMessage(message, messageId, sender, key);
+    }
+    if (pending) {
+      if (canClaimInteractionReply(message, pending, sender)) {
+        pending.claimedReplyMessageId = messageId;
+      }
+      const previous = pending.queue ?? Promise.resolve();
+      const current = previous
+        .catch(() => undefined)
+        .then(() => this.#processInteractionReply(message, messageId, sender, key, pending))
+        .finally(() => {
+          this.#acceptedMessageIds.delete(messageId);
+          if (pending.claimedReplyMessageId === messageId) {
+            pending.claimedReplyMessageId = null;
+          }
+          if (pending.queue === current) pending.queue = null;
+        });
+      pending.queue = current;
+      return current;
+    }
+    return this.#enqueueMessage(message, messageId, sender, key);
+  }
+
+  #enqueueMessage(message, messageId, sender, key, {
+    releaseMessageId = true,
+    alreadyRecorded = false,
+  } = {}) {
     const previous = this.#queues.get(key) ?? Promise.resolve();
     const current = previous
       .catch(() => undefined)
-      .then(() => this.#process(message, messageId, sender, key))
+      .then(() => this.#process(message, messageId, sender, key, { alreadyRecorded }))
       .finally(() => {
-        this.#acceptedMessageIds.delete(messageId);
+        if (releaseMessageId) this.#acceptedMessageIds.delete(messageId);
         if (this.#queues.get(key) === current) this.#queues.delete(key);
       });
     this.#queues.set(key, current);
@@ -170,15 +282,23 @@ export class DingtalkHarnessBridge {
   }
 
   async waitForIdle() {
-    await Promise.allSettled([...this.#queues.values()]);
+    await Promise.allSettled([
+      ...this.#queues.values(),
+      ...[...this.#pendingInteractions.values()].flatMap((pending) => (
+        pending.queue ? [pending.queue] : []
+      )),
+      ...this.#interactionTasks,
+    ]);
   }
 
-  async #process(message, messageId, sender, key) {
+  async #process(message, messageId, sender, key, { alreadyRecorded = false } = {}) {
     this.#signal?.throwIfAborted();
-    if (this.#state.hasSeen(messageId)) return;
-    await this.#state.markSeen(messageId);
-    increment(this.#status, 'messagesReceived');
-    this.#status.lastMessageAt = new Date().toISOString();
+    if (!alreadyRecorded) {
+      if (this.#state.hasSeen(messageId)) return;
+      await this.#state.markSeen(messageId);
+      increment(this.#status, 'messagesReceived');
+      this.#status.lastMessageAt = new Date().toISOString();
+    }
 
     if (String(message.conversationType) === '2' && message.isInAtList !== true) {
       increment(this.#status, 'messagesIgnored');
@@ -253,6 +373,13 @@ export class DingtalkHarnessBridge {
           onUpdate: cardStarted
             ? (update) => cardStream.push(progressText(update))
             : undefined,
+          onInteraction: (interaction) => this.#handleInteraction(interaction, {
+            key,
+            actor: sender,
+            sessionWebhook,
+            requiresMention: String(message.conversationType) === '2',
+          }),
+          onInteractionResolved: (resolution) => this.#handleInteractionResolved(resolution),
         },
       });
       const streamed = cardStarted && await cardStream.finish(answer);
@@ -270,6 +397,294 @@ export class DingtalkHarnessBridge {
       } catch {
         this.#logger.error?.('[dsh-dingtalk] failed to send the safe error reply');
       }
+    } finally {
+      await this.#cancelPendingInteraction(key);
+      await this.#approvals.closeRoute(key);
+    }
+  }
+
+  async #processInteractionReply(message, messageId, sender, key, expected) {
+    this.#signal?.throwIfAborted();
+    const current = this.#pendingInteractions.get(key);
+    const claimed = expected.claimedReplyMessageId === messageId;
+    if (!current || current !== expected || current.submitting) {
+      if (claimed && (!current || current !== expected)) {
+        return this.#discardResolvedInteractionReply(message, messageId);
+      }
+      return this.#enqueueMessage(message, messageId, sender, key, { releaseMessageId: false });
+    }
+    if (this.#state.hasSeen(messageId)) return;
+    await this.#state.markSeen(messageId);
+    increment(this.#status, 'messagesReceived');
+    this.#status.lastMessageAt = new Date().toISOString();
+
+    if (String(message.conversationType) === '2' && message.isInAtList !== true) {
+      increment(this.#status, 'messagesIgnored');
+      return;
+    }
+
+    let sessionWebhook;
+    try {
+      sessionWebhook = normalizeDingtalkSessionWebhook(message.sessionWebhook);
+    } catch {
+      increment(this.#status, 'messagesRejected');
+      this.#status.lastRejectedAt = new Date().toISOString();
+      this.#status.lastError = '钉钉消息没有安全的回复地址。';
+      return;
+    }
+
+    const text = message?.msgtype === 'text' ? nonEmptyString(message?.text?.content) : null;
+    if (!text) {
+      try {
+        await this.#send(sessionWebhook, '请用文字回答当前问题。');
+      } catch {
+        this.#logger.error?.('[dsh-dingtalk] failed to reject a non-text interaction reply');
+      }
+      return;
+    }
+
+    const pending = this.#pendingInteractions.get(key);
+    if (!pending || pending !== expected || pending.submitting) {
+      if (claimed && (!pending || pending !== expected)) {
+        try {
+          await this.#send(sessionWebhook, INTERACTION_RESOLVED_TEXT);
+        } catch {
+          this.#logger.error?.('[dsh-dingtalk] failed to send an expired interaction notice');
+        }
+        return;
+      }
+      return this.#enqueueMessage(message, messageId, sender, key, {
+        releaseMessageId: false,
+        alreadyRecorded: true,
+      });
+    }
+    pending.sessionWebhook = sessionWebhook;
+    if (pending.needsPresentation) {
+      try {
+        await this.#presentInteraction(pending);
+      } catch {
+        this.#status.lastError = '钉钉交互问题发送失败。';
+        this.#logger.error?.('[dsh-dingtalk] failed to retry an interaction question');
+        pending.interaction.reconnect?.();
+      }
+      return;
+    }
+    const question = pending.questions[pending.index];
+    if (!question) return;
+
+    pending.answers.push(harnessAnswerForQuestion(question, text));
+    pending.index += 1;
+    if (pending.index < pending.questions.length) {
+      if (pending.claimedReplyMessageId === messageId) {
+        pending.claimedReplyMessageId = null;
+      }
+      pending.needsPresentation = true;
+      try {
+        await this.#presentInteraction(pending);
+      } catch {
+        this.#status.lastError = '钉钉交互问题发送失败。';
+        this.#logger.error?.('[dsh-dingtalk] failed to send the next interaction question');
+        pending.interaction.reconnect?.();
+      }
+      return;
+    }
+
+    pending.submitting = true;
+    try {
+      await pending.interaction.respond({
+        ok: true,
+        value: {
+          sessionId: pending.sessionId,
+          answer: { answers: pending.answers },
+        },
+      });
+      this.#clearPendingInteraction(key, pending.interactionId);
+      this.#status.lastError = null;
+    } catch (error) {
+      if (this.#signal?.aborted) return;
+      if (this.#pendingInteractions.get(key) !== pending) return;
+      if (error?.code === 'interaction-not-pending') {
+        this.#clearPendingInteraction(key, pending.interactionId);
+        try {
+          await this.#send(sessionWebhook, INTERACTION_RESOLVED_TEXT);
+        } catch {
+          this.#logger.error?.('[dsh-dingtalk] failed to send an expired interaction notice');
+        }
+        return;
+      }
+      pending.submitting = false;
+      pending.answers.pop();
+      pending.index -= 1;
+      this.#status.lastError = '回答提交失败。';
+      this.#logger.error?.('[dsh-dingtalk] failed to answer a Harness interaction');
+      try {
+        await this.#send(sessionWebhook, '回答提交失败，请重新发送当前问题的答案。');
+      } catch {
+        this.#logger.error?.('[dsh-dingtalk] failed to send an interaction retry notice');
+      }
+    }
+  }
+
+  async #handleInteraction(interaction, {
+    key,
+    actor,
+    sessionWebhook,
+    requiresMention,
+  }) {
+    if (await this.#approvals.handleRequested(interaction, {
+      key,
+      actor,
+      requiresMention,
+      send: (text) => this.#send(sessionWebhook, text),
+    })) return;
+
+    // Approval requests return above; the existing question state machine stays unchanged.
+    if (interaction?.kind !== 'question') return;
+    const questions = interaction?.payload?.questions;
+    const interactionId = typeof interaction?.interactionId === 'string'
+      ? interaction.interactionId
+      : interaction?.rpcId;
+    if (typeof interaction.rpcId !== 'string'
+      || typeof interactionId !== 'string'
+      || typeof interaction.sessionId !== 'string'
+      || !Array.isArray(questions)
+      || questions.length === 0
+      || questions.some((question) => !validHarnessQuestion(question))) {
+      this.#logger.warn?.('[dsh-dingtalk] ignored an invalid Harness question interaction');
+      return;
+    }
+
+    if (interaction.recovered === true) {
+      await interaction.respond({
+        ok: false,
+        error: {
+          code: 'cancelled',
+          message: 'DingTalk safely cancelled an interaction left by an earlier client.',
+          details: {},
+        },
+      });
+      try {
+        await this.#send(sessionWebhook, '检测到这个 Session 中遗留的待回答问题，已安全取消并继续处理你刚才的消息。');
+      } catch {
+        this.#logger.error?.('[dsh-dingtalk] failed to send an interaction recovery notice');
+      }
+      return;
+    }
+
+    const existing = this.#pendingInteractions.get(key);
+    if (existing?.interactionId === interactionId) {
+      existing.interaction = interaction;
+      if (existing.needsPresentation) await this.#presentInteraction(existing);
+      return;
+    }
+    if (this.#interactionKeys.has(interactionId)) return;
+    if (existing) {
+      this.#logger.warn?.('[dsh-dingtalk] cancelled a second pending Harness question');
+      await interaction.respond({
+        ok: false,
+        error: {
+          code: 'cancelled',
+          message: 'DingTalk is already handling another user interaction.',
+          details: {},
+        },
+      });
+      return;
+    }
+
+    const pending = {
+      kind: 'question',
+      interactionId,
+      sessionId: interaction.sessionId,
+      interaction,
+      actor,
+      requiresMention,
+      questions,
+      answers: [],
+      index: 0,
+      sessionWebhook,
+      queue: null,
+      claimedReplyMessageId: null,
+      submitting: false,
+      needsPresentation: true,
+    };
+    this.#pendingInteractions.set(key, pending);
+    this.#interactionKeys.set(pending.interactionId, key);
+    await this.#presentInteraction(pending);
+  }
+
+  async #handleInteractionResolved(resolution) {
+    if (await this.#approvals.handleResolved(resolution)) return;
+    const interactionId = resolution?.interactionId;
+    if (resolution?.kind !== 'question' || typeof interactionId !== 'string') return;
+    const key = this.#interactionKeys.get(interactionId);
+    if (!key) return;
+    this.#clearPendingInteraction(key, interactionId);
+  }
+
+  async #presentInteraction(pending) {
+    const question = pending.questions[pending.index];
+    if (!question) return;
+    await this.#send(
+      pending.sessionWebhook,
+      harnessQuestionText(
+        question,
+        pending.index,
+        pending.questions.length,
+        { requiresMention: pending.requiresMention },
+      ),
+    );
+    pending.needsPresentation = false;
+  }
+
+  async #discardResolvedInteractionReply(message, messageId) {
+    if (this.#state.hasSeen(messageId)) return;
+    await this.#state.markSeen(messageId);
+    increment(this.#status, 'messagesReceived');
+    this.#status.lastMessageAt = new Date().toISOString();
+    let sessionWebhook;
+    try {
+      sessionWebhook = normalizeDingtalkSessionWebhook(message.sessionWebhook);
+    } catch {
+      increment(this.#status, 'messagesRejected');
+      this.#status.lastRejectedAt = new Date().toISOString();
+      return;
+    }
+    try {
+      await this.#send(sessionWebhook, INTERACTION_RESOLVED_TEXT);
+    } catch {
+      this.#logger.error?.('[dsh-dingtalk] failed to send an expired interaction notice');
+    }
+  }
+
+  #takePendingInteraction(key, interactionId) {
+    const pending = this.#pendingInteractions.get(key);
+    if (!pending
+      || (interactionId !== undefined && pending.interactionId !== interactionId)) return null;
+    this.#pendingInteractions.delete(key);
+    this.#interactionKeys.delete(pending.interactionId);
+    return pending;
+  }
+
+  #clearPendingInteraction(key, interactionId) {
+    return this.#takePendingInteraction(key, interactionId) !== null;
+  }
+
+  async #cancelPendingInteraction(key) {
+    const pending = this.#takePendingInteraction(key);
+    if (!pending || pending.kind !== 'question') return;
+    try {
+      await pending.interaction.respond({
+        ok: false,
+        error: {
+          code: 'cancelled',
+          message: 'The DingTalk interaction ended before the user answered.',
+          details: {},
+        },
+      }, { signal: AbortSignal.timeout(5_000) });
+    } catch (error) {
+      if (error?.code !== 'interaction-not-pending') {
+        this.#logger.warn?.('[dsh-dingtalk] failed to cancel a pending Harness interaction');
+      }
     }
   }