@xmanrui/dsh-im 2.5.0 → 2.6.0

package/src/channels/feishu/bridge.mjs

@@ -55,6 +55,7 @@ import {
   messageFailureText,
   setLastMessageFailure,
 } from '../shared/message-failure.mjs';
+import { beginStatusReaction } from '../shared/status-reaction.mjs';
 import {
   MENU_PAGE_SIZE,
   PRESET_FOLLOW_DEFAULT_SENTINEL,
@@ -549,7 +550,7 @@ export class FeishuHarnessBridge {
     }
 
     this.#acceptedMessageIds.add(messageId);
-    const processingReaction = this.#addReaction(messageId, 'OnIt');
+    const processingReaction = this.#beginReaction(messageId);
     const commandMessage = extractInboundMessage(event, this.#client);
     const commandText = nonEmptyString(commandMessage.content) ?? '';
     const batchText = event.message.message_type === 'text'
@@ -3603,35 +3604,24 @@ export class FeishuHarnessBridge {
     return t('_{text}_', { text: update.text || t('正在处理…') });
   }
 
-  async #addReaction(messageId, emojiType) {
-    if (!this.#channel?.addReaction) return null;
-    try {
-      const reactionId = await this.#channel.addReaction(messageId, emojiType);
-      this.#status.reactionsAdded = (this.#status.reactionsAdded ?? 0) + 1;
-      return reactionId;
-    } catch (error) {
-      this.#status.reactionErrors = (this.#status.reactionErrors ?? 0) + 1;
-      this.#logger.warn?.(`[dsh-feishu] unable to add ${emojiType} reaction:`, error.message);
-      return null;
-    }
+  #beginReaction(messageId) {
+    return beginStatusReaction({
+      adapter: this.#channel,
+      target: messageId,
+      reactions: { processing: 'OnIt', success: 'DONE', error: 'ERROR' },
+      status: this.#status,
+      logger: this.#logger,
+      label: 'feishu',
+    });
   }
 
-  async #removeProcessingReaction(messageId, processingReaction) {
-    const reactionId = await processingReaction;
-    if (reactionId && this.#channel?.removeReaction) {
-      try {
-        await this.#channel.removeReaction(messageId, reactionId);
-        this.#status.reactionsRemoved = (this.#status.reactionsRemoved ?? 0) + 1;
-      } catch (error) {
-        this.#status.reactionErrors = (this.#status.reactionErrors ?? 0) + 1;
-        this.#logger.warn?.('[dsh-feishu] unable to remove processing reaction:', error.message);
-      }
-    }
+  #removeProcessingReaction(_messageId, processingReaction) {
+    processingReaction.clear();
   }
 
-  async #finishReaction(messageId, processingReaction, finalEmojiType) {
-    await this.#removeProcessingReaction(messageId, processingReaction);
-    await this.#addReaction(messageId, finalEmojiType);
+  #finishReaction(_messageId, processingReaction, finalEmojiType) {
+    if (finalEmojiType === 'ERROR') processingReaction.error();
+    else processingReaction.success();
   }
 
   async #send(chatId, text) {

package/src/channels/shared/status-reaction.mjs

@@ -0,0 +1,107 @@
+const DEFAULT_TIMEOUT_MS = 2_000;
+
+const NOOP_REACTION = Object.freeze({
+  success() {},
+  error() {},
+  clear() {},
+  settled: () => Promise.resolve(),
+});
+
+function increment(status, key) {
+  if (!status || typeof status !== 'object') return;
+  status[key] = (status[key] ?? 0) + 1;
+}
+
+async function runWithTimeout(operation, timeoutMs) {
+  const signal = AbortSignal.timeout(timeoutMs);
+  let onAbort;
+  const aborted = new Promise((_, reject) => {
+    onAbort = () => reject(signal.reason ?? new DOMException('Timed out', 'TimeoutError'));
+    signal.addEventListener('abort', onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([operation(signal), aborted]);
+  } finally {
+    signal.removeEventListener('abort', onAbort);
+  }
+}
+
+/**
+ * Starts a best-effort status reaction lifecycle which is deliberately not
+ * part of the caller's message queue. Calls are serialized only for this one
+ * source message; every provider operation is bounded and absorbs failures.
+ */
+export function beginStatusReaction({
+  adapter,
+  target,
+  reactions,
+  status,
+  logger = console,
+  label = 'channel',
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+} = {}) {
+  if (!target
+    || typeof adapter?.addReaction !== 'function'
+    || typeof adapter?.removeReaction !== 'function'
+    || typeof reactions?.processing !== 'string'
+    || !reactions.processing
+    || !Number.isSafeInteger(timeoutMs)
+    || timeoutMs <= 0) return NOOP_REACTION;
+
+  let currentReaction = null;
+  let terminal = false;
+
+  const safely = async (kind, operation) => {
+    try {
+      const value = await runWithTimeout(operation, timeoutMs);
+      increment(status, kind === 'add' ? 'reactionsAdded' : 'reactionsRemoved');
+      return { ok: true, value };
+    } catch (cause) {
+      increment(status, 'reactionErrors');
+      logger.warn?.(
+        `[dsh-im:${label}] status reaction ${kind} failed:`,
+        cause?.message ?? cause?.name ?? String(cause),
+      );
+      return { ok: false, value: null };
+    }
+  };
+
+  const transition = async (emoji) => {
+    if (currentReaction !== null) {
+      const previous = currentReaction;
+      currentReaction = null;
+      await safely('remove', (signal) => adapter.removeReaction(
+        target,
+        previous,
+        { signal },
+      ));
+    }
+    if (typeof emoji !== 'string' || !emoji) return;
+    const added = await safely('add', (signal) => adapter.addReaction(
+      target,
+      emoji,
+      { signal },
+    ));
+    if (added.ok && added.value !== undefined && added.value !== null) {
+      currentReaction = added.value;
+    }
+  };
+
+  // Calling an async function starts the provider request synchronously up to
+  // its first await, while the returned tail remains completely detached from
+  // normal message processing.
+  let tail = transition(reactions.processing);
+  const finish = (emoji) => {
+    if (terminal) return;
+    terminal = true;
+    tail = tail.then(() => transition(emoji), () => transition(emoji));
+    void tail.catch(() => undefined);
+  };
+
+  return Object.freeze({
+    success: () => finish(reactions.success),
+    error: () => finish(reactions.error),
+    clear: () => finish(null),
+    settled: () => tail,
+  });
+}

package/src/channels/shared/text-harness-bridge.mjs

@@ -52,6 +52,7 @@ import {
   messageFailureText,
   setLastMessageFailure,
 } from './message-failure.mjs';
+import { beginStatusReaction } from './status-reaction.mjs';
 
 const INTERACTION_RESOLVED_TEXT = '这个问题已在其他客户端处理，无需再次回答。';
 const FILE_ONLY_COMPLETION_TEXT = '任务已完成。';
@@ -114,6 +115,9 @@ export function createTextBridgeStatus() {
     lastRejectedAt: null,
     lastError: null,
     lastMessageError: null,
+    reactionsAdded: 0,
+    reactionsRemoved: 0,
+    reactionErrors: 0,
   };
 }
 
@@ -178,6 +182,27 @@ export class TextHarnessBridge {
       return Promise.resolve();
     }
     this.#acceptedMessageIds.add(messageId);
+    const statusReaction = beginStatusReaction({
+      adapter: this.#bot,
+      target: normalized.kind === 'direct' || normalized.addressed === true
+        ? normalized.reactionTarget
+        : null,
+      reactions: this.#descriptor.reactions,
+      status: this.#status,
+      logger: this.#logger,
+      label: this.#descriptor.key,
+    });
+    normalized.statusReaction = statusReaction;
+
+    const processing = this.#acceptAcceptedMessage(normalized, messageId, senderId);
+    void processing.then(
+      () => statusReaction.success(),
+      () => statusReaction.error(),
+    );
+    return processing;
+  }
+
+  #acceptAcceptedMessage(normalized, messageId, senderId) {
     if (normalized.kind === 'direct') {
       rememberConnectionTestTarget(
         this.#state,
@@ -185,7 +210,7 @@ export class TextHarnessBridge {
       );
     }
 
-    const key = `${kind}:${conversationId}`;
+    const key = `${normalized.kind}:${normalized.conversationId}`;
     const pending = this.#pendingInteractions.get(key);
     const text = cleanText(normalized.content);
     const batchCommand = isBatchInputCommand(text);
@@ -326,7 +351,11 @@ export class TextHarnessBridge {
       if (reply) await this.#bot.sendText(message.replyTarget, reply);
       this.#status.lastError = null;
     })().catch(async (error) => {
-      if (this.#signal?.aborted) return;
+      if (this.#signal?.aborted) {
+        message.statusReaction?.clear();
+        return;
+      }
+      message.statusReaction?.error();
       this.#status.lastError = error?.message ?? String(error);
       const failure = setLastMessageFailure(this.#status, error);
       this.#logger.error?.(
@@ -406,7 +435,11 @@ export class TextHarnessBridge {
       }
       this.#status.lastError = null;
     } catch (error) {
-      if (error?.code === 'turn-stopped' || this.#signal?.aborted) return;
+      if (error?.code === 'turn-stopped' || this.#signal?.aborted) {
+        message.statusReaction?.clear();
+        return;
+      }
+      message.statusReaction?.error();
       this.#status.lastError = error?.message ?? String(error);
       const failure = setLastMessageFailure(this.#status, error);
       this.#logger.error?.(
@@ -706,6 +739,7 @@ export class TextHarnessBridge {
         ? this.#batches.fail(conversationKey, batchSubmission.token)
         : null;
       if (turnStopped) {
+        message.statusReaction?.clear();
         if (stream) {
           try {
             await stream.finish(t('已停止。'));
@@ -716,9 +750,11 @@ export class TextHarnessBridge {
         return;
       }
       if (this.#signal?.aborted) {
+        message.statusReaction?.clear();
         stream?.cancel?.();
         return;
       }
+      message.statusReaction?.error();
       this.#status.lastError = error?.message ?? String(error);
       const presentStreamFailure = async (text) => {
         const method = typeof stream?.fail === 'function'
@@ -773,7 +809,10 @@ export class TextHarnessBridge {
   }
 
   async #processInteractionReply(message, messageId, senderId, key, expected) {
-    if (this.#signal?.aborted) return;
+    if (this.#signal?.aborted) {
+      message.statusReaction?.clear();
+      return;
+    }
     const current = this.#pendingInteractions.get(key);
     const claimed = expected.claimedReplyMessageId === messageId;
     if (!current || current !== expected || current.submitting) {
@@ -827,6 +866,7 @@ export class TextHarnessBridge {
       try {
         await this.#presentInteraction(pending);
       } catch (error) {
+        message.statusReaction?.error();
         this.#status.lastError = t('{label}交互问题发送失败。', { label: this.#descriptor.label });
         this.#logger.error?.(
           `[dsh-im:${this.#descriptor.key}] failed to retry an interaction question:`,
@@ -865,6 +905,7 @@ export class TextHarnessBridge {
       try {
         await this.#presentInteraction(pending);
       } catch (error) {
+        message.statusReaction?.error();
         this.#status.lastError = t('{label}交互问题发送失败。', { label: this.#descriptor.label });
         this.#logger.error?.(
           `[dsh-im:${this.#descriptor.key}] failed to send the next interaction question:`,
@@ -889,7 +930,10 @@ export class TextHarnessBridge {
     } catch (error) {
       if (error?.code === 'interaction-not-pending') {
         this.#clearPendingInteraction(key, pending.interactionId);
-        if (this.#signal?.aborted) return;
+        if (this.#signal?.aborted) {
+          message.statusReaction?.clear();
+          return;
+        }
         try {
           await this.#bot.sendText(target, t(INTERACTION_RESOLVED_TEXT));
         } catch (sendError) {
@@ -900,7 +944,15 @@ export class TextHarnessBridge {
         }
         return;
       }
-      if (this.#signal?.aborted || this.#pendingInteractions.get(key) !== pending) return;
+      if (this.#signal?.aborted) {
+        message.statusReaction?.clear();
+        return;
+      }
+      if (this.#pendingInteractions.get(key) !== pending) {
+        message.statusReaction?.clear();
+        return;
+      }
+      message.statusReaction?.error();
       pending.submitting = false;
       pending.answers.pop();
       pending.index -= 1;

package/src/channels/slack/manifest.mjs

@@ -20,6 +20,7 @@ oauth_config:
       - files:read
       - files:write
       - im:history
+      - reactions:write
 settings:
   event_subscriptions:
     bot_events:

package/src/channels/slack/slack-api.mjs

@@ -276,6 +276,34 @@ export class SlackApi {
     });
   }
 
+  addReaction({ channelId, messageTs, emojiName, signal, timeoutMs }) {
+    return this.#request('reactions.add', {
+      tokenKind: 'bot',
+      signal,
+      timeoutMs,
+      retry: false,
+      body: {
+        channel: slackId(channelId, 'channel id'),
+        timestamp: requiredString(messageTs, 'message timestamp'),
+        name: requiredString(emojiName, 'reaction name'),
+      },
+    });
+  }
+
+  removeReaction({ channelId, messageTs, emojiName, signal, timeoutMs }) {
+    return this.#request('reactions.remove', {
+      tokenKind: 'bot',
+      signal,
+      timeoutMs,
+      retry: false,
+      body: {
+        channel: slackId(channelId, 'channel id'),
+        timestamp: requiredString(messageTs, 'message timestamp'),
+        name: requiredString(emojiName, 'reaction name'),
+      },
+    });
+  }
+
   startStream({ channelId, threadTs, recipientTeamId, recipientUserId, markdownText, signal }) {
     return this.#request('chat.startStream', {
       tokenKind: 'bot',

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

@@ -4,6 +4,11 @@ export const SLACK_DESCRIPTOR = Object.freeze({
   key: 'slack',
   label: 'Slack',
   connectionLabel: ' Socket Mode 长连接',
+  reactions: Object.freeze({
+    processing: 'eyes',
+    success: 'white_check_mark',
+    error: 'x',
+  }),
 });
 
 export class SlackHarnessBridge extends TextHarnessBridge {

package/src/channels/slack/slack-runtime.mjs

@@ -127,6 +127,10 @@ export function normalizeSlackEvent(payload, botUserId, {
       ? event.files.map((file) => slackFileSource(file, loadFileStream, loadFileInfo)).filter(Boolean)
       : [],
     addressed: direct || mentioned,
+    reactionTarget: {
+      channelId: String(event.channel),
+      messageTs: String(event.ts),
+    },
     replyTarget: {
       channelId: String(event.channel),
       threadTs,
@@ -284,6 +288,26 @@ export class SlackBotClient {
     return { providerMessageIds };
   }
 
+  async addReaction(target, emoji, { signal } = {}) {
+    const reactionKey = String(emoji ?? '').trim();
+    await this.#api.addReaction({
+      channelId: target.channelId,
+      messageTs: target.messageTs,
+      emojiName: reactionKey,
+      signal: signal ?? this.#signal,
+    });
+    return reactionKey;
+  }
+
+  removeReaction(target, reactionKey, { signal } = {}) {
+    return this.#api.removeReaction({
+      channelId: target.channelId,
+      messageTs: target.messageTs,
+      emojiName: reactionKey,
+      signal: signal ?? this.#signal,
+    });
+  }
+
   openStream(target) {
     return createSlackMessageStream({
       api: this.#api,

package/src/channels/telegram/telegram-api.mjs

@@ -203,6 +203,15 @@ export class TelegramApi {
     }, { signal });
   }
 
+  async setMessageReaction({ chatId, messageId, emoji, signal, timeoutMs }) {
+    const normalizedEmoji = cleanString(emoji);
+    return this.#call('setMessageReaction', {
+      chat_id: chatId,
+      message_id: messageId,
+      reaction: normalizedEmoji ? [{ type: 'emoji', emoji: normalizedEmoji }] : [],
+    }, { signal, timeoutMs });
+  }
+
   async sendRichMessage({
     chatId,
     richMessage,

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

@@ -4,6 +4,7 @@ export const TELEGRAM_DESCRIPTOR = Object.freeze({
   key: 'telegram',
   label: 'Telegram',
   connectionLabel: ' Bot API 长轮询',
+  reactions: Object.freeze({ processing: '👀', success: '👍', error: '👎' }),
 });
 
 export class TelegramHarnessBridge extends TextHarnessBridge {

package/src/channels/telegram/telegram-runtime.mjs

@@ -168,6 +168,7 @@ export function normalizeTelegramUpdate(update, {
     images: image ? [image] : [],
     files: file ? [file] : [],
     addressed,
+    reactionTarget: { chatId, messageId },
     replyTarget: {
       chatId,
       chatType: message.chat.type,
@@ -303,6 +304,25 @@ export class TelegramBotClient {
     return { providerMessageIds };
   }
 
+  async addReaction(target, emoji, { signal } = {}) {
+    const reactionKey = String(emoji ?? '').trim();
+    await this.#api.setMessageReaction({
+      chatId: target.chatId,
+      messageId: target.messageId,
+      emoji: reactionKey,
+      signal: signal ?? this.#signal,
+    });
+    return reactionKey;
+  }
+
+  removeReaction(target, _reactionKey, { signal } = {}) {
+    return this.#api.setMessageReaction({
+      chatId: target.chatId,
+      messageId: target.messageId,
+      signal: signal ?? this.#signal,
+    });
+  }
+
   sendTyping(target) {
     return this.#api.sendChatAction({
       chatId: target.chatId,

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

@@ -6,6 +6,7 @@ export const WHATSAPP_DESCRIPTOR = Object.freeze({
   label: 'WhatsApp',
   // Translated lazily: t() must run after setImHostLanguage, not at import time.
   get connectionLabel() { return t(' Web 关联设备'); },
+  reactions: Object.freeze({ processing: '👀', success: '✅', error: '❌' }),
 });
 
 export class WhatsappHarnessBridge extends TextHarnessBridge {

package/src/channels/whatsapp/whatsapp-runtime.mjs

@@ -246,6 +246,7 @@ export function normalizeWhatsappMessage(message, accountJid, {
     addressed: !group || fromMe || mentioned || replyToSelf,
     selfChat,
     replyTarget: { jid: remoteJid, quoted: message, selfChat },
+    reactionTarget: { jid: remoteJid, key: message.key },
   };
 }
 
@@ -411,6 +412,41 @@ export class WhatsappBotClient {
     }, 'image');
   }
 
+  async addReaction(target, emoji, { signal } = {}) {
+    if (typeof emoji !== 'string' || !emoji.trim()) {
+      throw new TypeError('A WhatsApp reaction emoji is required');
+    }
+    const reactionKey = emoji.trim();
+    await this.#sendReaction(target, reactionKey, signal);
+    return reactionKey;
+  }
+
+  removeReaction(target, _reactionKey, { signal } = {}) {
+    return this.#sendReaction(target, '', signal);
+  }
+
+  async #sendReaction(target, text, signal) {
+    if (typeof target?.jid !== 'string' || !target.jid || !target.key?.id) {
+      throw new TypeError('A WhatsApp reaction target is required');
+    }
+    const operationSignal = signal ?? this.#signal;
+    operationSignal?.throwIfAborted();
+    const messageId = randomBytes(10).toString('hex').toUpperCase();
+    if (typeof this.#outboundIds.reserve === 'function') {
+      this.#outboundIds.reserve(messageId);
+    } else {
+      this.#outboundIds.remember(messageId);
+    }
+    const pending = this.#socket.sendMessage(
+      target.jid,
+      { react: { text, key: target.key } },
+      { messageId },
+    );
+    const result = await waitWithSignal(pending, operationSignal);
+    this.#outboundIds.remember(result?.key?.id);
+    return result;
+  }
+
   async #sendArtifact(target, file, content, presentation) {
     this.#signal?.throwIfAborted();
     await this.#stopTyping(target.jid);