@xmanrui/dsh-im 4.35.0 → 4.36.0

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

@@ -1647,6 +1647,12 @@ export class DingtalkHarnessBridge {
     }
   }
 
+  async presentSessionSyncApproval(interaction, context, options = {}) {
+    return this.#approvals.handleSessionSyncRequested(interaction, context, {
+      ...options, runtimeSignal: this.#signal, accessPolicy: this.#accessPolicy,
+    });
+  }
+
   async #handleInteraction(interaction, {
     key,
     actor,

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

@@ -442,6 +442,20 @@ export class DingtalkController {
     });
   }
 
+  async presentSessionSyncApproval(botId, target, interaction, options = {}) {
+    const config = this.#configStore.get(botId);
+    if (!config) throw new Error('Unknown DingTalk bot');
+    return this.#withBotTransition(botId, async () => {
+      const runtime = this.#runtimes.get(botId);
+      if (!runtime?.status?.ready || typeof runtime.presentSessionSyncApproval !== 'function') {
+        const error = new Error(t('钉钉消息连接当前离线'));
+        error.code = 'bot-not-connected';
+        throw error;
+      }
+      return runtime.presentSessionSyncApproval(target, interaction, options);
+    });
+  }
+
   /** Removes one bot, its secret, runtime, and local conversation state. */
   async deleteBot(botId) {
     const warnings = [];

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

@@ -432,6 +432,16 @@ export class DingtalkRuntime {
     });
   }
 
+  async presentSessionSyncApproval(target, interaction, options = {}) {
+    if (!this.#status.ready || !this.#bridge) return false;
+    const actor = typeof target?.route?.userId === 'string' ? target.route.userId.trim() : '';
+    if (!actor) return false;
+    return this.#bridge.presentSessionSyncApproval(interaction, {
+      key: options.key, actor, validate: options.validate,
+      send: (text) => this.sendProactiveText(target, text),
+    }, options);
+  }
+
   async sendProactiveText(target, text, { signal } = {}) {
     const userId = typeof target?.route?.userId === 'string'
       ? target.route.userId.trim() : '';

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

@@ -605,6 +605,19 @@ export class DiscordRuntime {
     return this.#bridge.sendConnectionTest(text);
   }
 
+  async presentSessionSyncApproval(target, interaction, options = {}) {
+    if (!this.#status.ready || !this.#bridge) return false;
+    const channelId = target?.route?.channelId;
+    const channel = await this.#api.getChannel({ channelId, signal: options.signal });
+    const actor = channel?.type === 1 && channel.recipients?.length === 1
+      ? channel.recipients[0]?.id : '';
+    if (!actor) return false;
+    return this.#bridge.presentSessionSyncApproval(interaction, {
+      key: options.key, actor, validate: options.validate,
+      send: (text) => this.sendProactiveText(target, text),
+    }, options);
+  }
+
   async sendProactiveText(target, text, options = {}) {
     if (!this.#status.ready || !this.#bridge) {
       const error = new Error('Discord bot is not connected');

package/src/channels/feishu/bridge.mjs

@@ -3161,6 +3161,7 @@ export class FeishuHarnessBridge {
       }
       const sentId = nonEmptyString(response?.data?.message_id);
       if (!sentId) throw new Error('Feishu card send returned no message_id');
+      this.#rememberCardRoute(sentId, response?.data?.chat_id ?? chatId, options);
       return sentId;
     }
 
@@ -6043,20 +6044,16 @@ export class FeishuHarnessBridge {
     }
   }
 
-  async #handleInteraction(interaction, {
-    key,
-    actor,
-    chatId,
-    requiresMention,
-    replyToMessageId,
-  }) {
+  #approvalContext({ key, actor, chatId, requiresMention, replyToMessageId, receiveIdType,
+    validate, send = (text) => this.#send(chatId, text, { replyTo: replyToMessageId }) }) {
     let approvalCardMessageId = null;
     let approvalCardData = null;
-    if (await this.#approvals.handleRequested(interaction, {
+    return {
       key,
       actor,
       requiresMention,
-      send: (text) => this.#send(chatId, text, { replyTo: replyToMessageId }),
+      send,
+      validate,
       // Approvals render as interactive cards with approve/reject buttons by
       // default. Set the bridge `interactionCards` option (or
       // DSH_IM_INTERACTION_CARDS=0) to keep the plain-text reply flow.
@@ -6073,27 +6070,47 @@ export class FeishuHarnessBridge {
               approvalCardMessageId = await this.#sendCard(
                 chatId,
                 approvalCard(approvalCardData),
-                { key, replyTo: replyToMessageId },
+                { key, replyTo: replyToMessageId, receiveIdType },
               ).catch(async () => {
                 // Fall back to the plain-text approval if the card cannot be
                 // sent. If the text send also fails, let the error propagate so
                 // the pending approval is not marked as presented and the
                 // existing retry/reconnect logic can run.
-                await this.#send(chatId, pending.text, { replyTo: replyToMessageId });
+                await send(pending.text);
                 return null;
               });
             },
             onResolved: async (resolvedText) => {
               if (!approvalCardMessageId) return;
-              await this.#patchCardMessage(
+              const patched = await this.#patchCardMessage(
                 chatId,
                 approvalCardMessageId,
                 approvalCard({ ...approvalCardData, resolvedText }),
               );
+              if (!patched) throw new Error('Approval card update failed');
             },
           }
         : {}),
-    })) return;
+    };
+
+  }
+
+  async presentSessionSyncApproval(interaction, context, options = {}) {
+    return this.#approvals.handleSessionSyncRequested(interaction, this.#approvalContext(context), {
+      ...options, runtimeSignal: this.#signal, accessPolicy: this.#accessPolicy,
+    });
+  }
+
+  async #handleInteraction(interaction, {
+    key,
+    actor,
+    chatId,
+    requiresMention,
+    replyToMessageId,
+  }) {
+    if (await this.#approvals.handleRequested(interaction, this.#approvalContext({
+      key, actor, chatId, requiresMention, replyToMessageId,
+    }))) return;
 
     // Approval requests return above; the existing question state machine stays unchanged.
     if (interaction?.kind !== 'question') return;

package/src/channels/feishu/external-consumer.mjs

@@ -0,0 +1,118 @@
+function refusal(code) {
+  const error = new Error(code);
+  error.code = code;
+  return error;
+}
+
+function identifier(value) {
+  return typeof value === 'string' && value.length > 0 && value.length <= 512 ? value : undefined;
+}
+
+export function normalizeExternalText(event, { botId, appId, botOpenId, fingerprint }) {
+  const message = event?.message;
+  const actorId = identifier(event?.sender?.sender_id?.open_id);
+  const messageId = identifier(message?.message_id);
+  const conversationId = identifier(message?.chat_id);
+  const eventId = identifier(event?.event_id ?? event?.header?.event_id);
+  const eventApp = event?.app_id ?? event?.header?.app_id;
+  if (eventApp !== undefined && eventApp !== appId) throw refusal('account-changed');
+  if (event?.sender?.sender_type === 'app' || event?.sender?.sender_type === 'bot') return null;
+  if (event?.sender?.sender_type !== 'user'
+    || !['p2p', 'group'].includes(message?.chat_type) || message?.message_type !== 'text') return null;
+  if (message.chat_type === 'group' && !identifier(botOpenId)) throw refusal('account-unverified');
+  if (message.mentions !== undefined && (!Array.isArray(message.mentions) || message.mentions.length > 100))
+    throw refusal('invalid-inbound');
+  const mentions = Object.freeze((message.mentions ?? []).map(mention => {
+    const id = identifier(mention?.id?.open_id ?? mention?.open_id);
+    const key = identifier(mention?.key);
+    if (!id || !key) throw refusal('invalid-inbound');
+    return Object.freeze({ id, key, ...(identifier(mention.name) ? { name: mention.name } : {}) });
+  }));
+  if (!actorId || !messageId || !conversationId || !eventId
+    || !/^[a-f0-9]{64}$/.test(fingerprint ?? '')) throw refusal('invalid-inbound');
+  let text;
+  try { text = JSON.parse(message.content)?.text; } catch { throw refusal('invalid-inbound'); }
+  if (typeof text !== 'string' || !text.trim() || text.length > 16000) throw refusal('invalid-inbound');
+  const milliseconds = Number(message.create_time);
+  const timestamp = new Date(milliseconds);
+  if (!Number.isFinite(milliseconds) || milliseconds <= 0 || !Number.isFinite(timestamp.getTime()))
+    throw refusal('invalid-inbound');
+  const route = Object.freeze({
+    messageId, conversationId, actorId,
+    ...(identifier(message.thread_id) ? { threadId: message.thread_id } : {}),
+    ...(identifier(message.root_id) ? { rootId: message.root_id } : {}),
+    ...(identifier(message.parent_id) ? { parentId: message.parent_id } : {}),
+  });
+  return Object.freeze({
+    version: 1, channel: 'feishu', botId, fingerprint, eventId, messageId,
+    actor: Object.freeze({ kind: 'user', id: actorId,
+      ...(identifier(event.sender.sender_name) ? { name: event.sender.sender_name } : {}) }),
+    conversation: Object.freeze({ kind: message.chat_type === 'group' ? 'group' : 'dm', id: conversationId }),
+    mentions, mentionedAccount: mentions.some(mention => mention.id === botOpenId),
+    at: timestamp.toISOString(), text, reply: route,
+    replay: Object.freeze({ kind: 'provider-redelivery', resumeCursor: false, gapPossible: true }),
+  });
+}
+
+export class ExclusiveInboundConsumers {
+  #entries = new Map();
+
+  register(botId, { fingerprint, onEvent, signal }) {
+    if (this.#entries.has(botId)) throw refusal('consumer-conflict');
+    if (!/^[a-f0-9]{64}$/.test(fingerprint ?? '') || typeof onEvent !== 'function')
+      throw refusal('bad-request');
+    signal?.throwIfAborted();
+    const controller = new AbortController();
+    const entry = { fingerprint, onEvent, controller, dispose: undefined };
+    const dispose = () => {
+      if (this.#entries.get(botId) === entry) this.#entries.delete(botId);
+      controller.abort(refusal('consumer-unavailable'));
+      signal?.removeEventListener('abort', dispose);
+    };
+    entry.dispose = dispose;
+    this.#entries.set(botId, entry);
+    signal?.addEventListener('abort', dispose, { once: true });
+    return dispose;
+  }
+
+  async accept(botId, evidence, signal) {
+    const entry = this.#entries.get(botId);
+    if (!entry) throw refusal('consumer-unavailable');
+    if (entry.fingerprint !== evidence.fingerprint) throw refusal('account-changed');
+    const deliverySignal = signal
+      ? AbortSignal.any([signal, entry.controller.signal]) : entry.controller.signal;
+    deliverySignal.throwIfAborted();
+    let abort;
+    const interrupted = new Promise((_, reject) => {
+      abort = () => reject(deliverySignal.reason);
+      deliverySignal.addEventListener('abort', abort, { once: true });
+      if (deliverySignal.aborted) abort();
+    });
+    let result;
+    try {
+      result = await Promise.race([entry.onEvent(evidence, { signal: deliverySignal }), interrupted]);
+    } finally {
+      deliverySignal.removeEventListener('abort', abort);
+    }
+    deliverySignal.throwIfAborted();
+    if (this.#entries.get(botId) !== entry) throw refusal('consumer-unavailable');
+    if (result?.accepted !== true) throw refusal('ingress-not-accepted');
+    return { accepted: true };
+  }
+
+  signalFor(botId, fingerprint) {
+    const entry = this.#entries.get(botId);
+    if (!entry) throw refusal('consumer-unavailable');
+    if (entry.fingerprint !== fingerprint) throw refusal('account-changed');
+    return entry.controller.signal;
+  }
+
+  remove(botId) {
+    const entry = this.#entries.get(botId);
+    entry?.dispose();
+  }
+
+  close() {
+    for (const botId of this.#entries.keys()) this.remove(botId);
+  }
+}

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

@@ -1,4 +1,5 @@
 import { createConnectionDiagnostics, atConnectionStage } from '../shared/connection-error.mjs';
+import { readExternalHistory } from './history-reader.mjs';
 import { randomUUID } from 'node:crypto';
 import { FeishuHarnessBridge } from './bridge.mjs';
 import { cardActionProbeCard } from './feishu-cards.mjs';
@@ -134,6 +135,8 @@ export class FeishuRuntime {
   #repair;
   #client = null;
   #bridge = null;
+  #consumerMode;
+  #acceptExternal;
   #wsClient = null;
   #starting = null;
   #stopping = null;
@@ -157,6 +160,8 @@ export class FeishuRuntime {
 
   constructor({
     lark,
+    consumerMode = 'standalone',
+    acceptExternal,
     botId,
     appId,
     appSecret,
@@ -197,6 +202,8 @@ export class FeishuRuntime {
       throw new TypeError('FeishuRuntime requestTimeoutMs must be a positive number');
     }
 
+    this.#consumerMode = consumerMode;
+    this.#acceptExternal = acceptExternal;
     this.#lark = lark;
     this.#botId = nonEmptyString(botId);
     this.#appId = appId;
@@ -224,7 +231,7 @@ export class FeishuRuntime {
     this.#replyTimeoutMs = replyTimeoutMs;
     this.#connectTimeoutMs = connectTimeoutMs;
     this.#requestTimeoutMs = requestTimeoutMs;
-    this.#slashCommands = Boolean(slashCommands);
+    this.#slashCommands = consumerMode !== 'external-consumer' && Boolean(slashCommands);
     this.#slashPanel = normalizeSlashPanelConfig(slashPanel);
     this.#wsAgent = wsAgent;
     this.#logger = logger; this.#diagnostics = createConnectionDiagnostics({ channel: 'feishu', logger });
@@ -348,7 +355,7 @@ export class FeishuRuntime {
         client,
         initialText: t('已连接 DeepSeek Harness，正在思考…'),
       });
-      const bridge = new FeishuHarnessBridge({
+      const bridge = this.#consumerMode === 'external-consumer' ? null : new FeishuHarnessBridge({
         client,
         channel,
         harness: this.#harness,
@@ -381,6 +388,12 @@ export class FeishuRuntime {
 
       const dispatcher = new this.#lark.EventDispatcher({}).register({
         'im.message.receive_v1': (event) => {
+          if (this.#consumerMode === 'external-consumer') {
+            assertCurrentStart();
+            if (typeof this.#acceptExternal !== 'function')
+              throw Object.assign(new Error('consumer-unavailable'), { code: 'consumer-unavailable' });
+            return this.#acceptExternal(event, { signal });
+          }
           if (isCurrentStart()) void bridge.accept(event);
         },
         'im.message.reaction.created_v1': () => undefined,
@@ -389,7 +402,7 @@ export class FeishuRuntime {
         // subscribes card.action.trigger; the number-reply fallback covers
         // apps that do not).
         'card.action.trigger': (event) => {
-          if (!isCurrentStart()) return;
+          if (!isCurrentStart() || this.#consumerMode === 'external-consumer') return;
           this.#status.cardActionsReceived += 1;
           this.#status.lastCardActionAt = new Date().toISOString();
           if (!this.#consumeCardActionProbe(event)) void bridge.onCardAction(event);
@@ -675,6 +688,17 @@ export class FeishuRuntime {
     });
   }
 
+  async presentSessionSyncApproval(target, interaction, options = {}) {
+    if (!this.#status.ready || !this.#bridge) return false;
+    const actor = typeof target?.route?.openId === 'string' ? target.route.openId.trim() : '';
+    if (!actor) return false;
+    return this.#bridge.presentSessionSyncApproval(interaction, {
+      key: options.key, actor, validate: options.validate,
+      chatId: actor, receiveIdType: 'open_id',
+      send: (text) => this.sendProactiveText(target, text),
+    }, options);
+  }
+
   async sendProactiveText(target, text, { signal, format = 'plain', receipt = false } = {}) {
     if (!this.#status.ready || !this.#client) {
       const error = new Error('飞书机器人尚未连接');
@@ -734,6 +758,51 @@ export class FeishuRuntime {
     return { sent: true, receipt: { version: 1, messageId, conversationId } };
   }
 
+  async historyChecked(identity, route, query, { signal } = {}) {
+    const client = this.#client;
+    if (!client || this.#consumerMode !== 'external-consumer')
+      throw Object.assign(new Error('bot-not-connected'), { code: 'bot-not-connected' });
+    const result = await readExternalHistory(client, identity, route, query, signal);
+    signal?.throwIfAborted();
+    if (this.#client !== client)
+      throw Object.assign(new Error('bot-not-connected'), { code: 'bot-not-connected' });
+    return result;
+  }
+
+  async replyChecked(route, text, { signal } = {}) {
+    if (!route || typeof route.messageId !== 'string' || typeof route.conversationId !== 'string'
+      || typeof route.actorId !== 'string' || typeof text !== 'string' || !text.trim() || text.length > 4000)
+      throw Object.assign(new Error('bad-request'), { code: 'bad-request' });
+    const client = this.#client;
+    if (!client || this.#consumerMode !== 'external-consumer')
+      throw Object.assign(new Error('bot-not-connected'), { code: 'bot-not-connected' });
+    signal?.throwIfAborted();
+    const current = await client.im.v1.message.get({ path: { message_id: route.messageId } });
+    const source = current?.data?.items?.find(item => item.message_id === route.messageId);
+    if (current?.code || !source || source.deleted === true || source.chat_id !== route.conversationId
+      || source.sender?.sender_type !== 'user' || source.sender?.id_type !== 'open_id'
+      || source.sender?.id !== route.actorId || (source.thread_id || undefined) !== route.threadId
+      || (source.root_id || undefined) !== route.rootId || (source.parent_id || undefined) !== route.parentId)
+      throw Object.assign(new Error('stale-route'), { code: 'stale-route' });
+    signal?.throwIfAborted();
+    if (this.#client !== client) throw Object.assign(new Error('bot-not-connected'), { code: 'bot-not-connected' });
+    let response;
+    try {
+      response = await client.im.v1.message.reply({
+        path: { message_id: route.messageId },
+        data: { msg_type: 'text', content: JSON.stringify({ text }), reply_in_thread: Boolean(route.threadId) },
+      });
+    } catch (cause) {
+      // The request may have reached Lark. Do not turn an ambiguous result into
+      // a retryable pre-send failure or send again on the group mainline.
+      throw Object.assign(new Error('reply-result-unknown', { cause }), { code: 'reply-result-unknown' });
+    }
+    const messageId = response?.data?.message_id;
+    if (response?.code || typeof messageId !== 'string' || !messageId)
+      throw Object.assign(new Error('reply-result-unknown'), { code: 'reply-result-unknown' });
+    return { sent: true, messageId };
+  }
+
   /**
    * Queue one panel sync for the current config.
    *

package/src/channels/feishu/history-reader.mjs

@@ -0,0 +1,92 @@
+import { readNearbyHistory } from './nearby-history.mjs';
+import { normalizeExternalText } from './external-consumer.mjs';
+
+function refuse(code) { throw Object.assign(new Error(code), { code }); }
+function identifier(value) {
+  return typeof value === 'string' && value.length > 0 && value.length <= 512;
+}
+
+function check(response) {
+  if ([230027, 99991672, 99991679].includes(response?.code)) refuse('history-permission-denied');
+  if (response?.code) refuse('history-unavailable');
+}
+
+async function checkedSdkRead(operation, signal) {
+  let response;
+  try { response = await operation(); }
+  catch (error) {
+    signal?.throwIfAborted();
+    if (error?.name === 'AbortError') throw error;
+    if (error?.code === 'ABORT_ERR' || error?.code === 'ERR_CANCELED') refuse('cancelled');
+    // The SDK rejects HTTP 403 before returning the provider's JSON payload.
+    // Never expose its raw Axios error (which can contain credential headers).
+    check(error?.response?.data);
+    refuse('history-unavailable');
+  }
+  signal?.throwIfAborted();
+  check(response);
+  return response;
+}
+
+// Application-defined checked read: destination is derived from an authenticated source.
+// Lark has Chat/time-range listing and Thread listing, not a native around-message API.
+export async function readExternalHistory(client, identity, route, query, signal) {
+  if (!route || !identifier(route.messageId) || !identifier(route.conversationId)
+    || !identifier(route.actorId) || ['threadId', 'rootId', 'parentId'].some(key => route[key] !== undefined && !identifier(route[key])) || !['group', 'nearby', 'thread'].includes(query?.scope)
+    || !Number.isInteger(query.limit) || query.limit < 1 || query.limit > 20
+    || (query.cursor !== undefined && (typeof query.cursor !== 'string' || !query.cursor || query.cursor.length > 4096)))
+    refuse('bad-request');
+  if (query.scope === 'nearby' && [query.beforeCount ?? 10, query.afterCount ?? 5]
+    .some(value => !Number.isInteger(value) || value < 0 || value > 20)) refuse('bad-request');
+  signal?.throwIfAborted();
+  const reference = await checkedSdkRead(() => client.im.v1.message.get({ path: { message_id: route.messageId }, params: { with_sender_name: true } }, { signal }), signal);
+  signal?.throwIfAborted();
+  const source = (Array.isArray(reference?.data?.items) ? reference.data.items : []).find(item => item?.message_id === route.messageId);
+  if (!source || source.deleted || source.chat_id !== route.conversationId
+    || source.sender?.sender_type !== 'user' || source.sender?.id_type !== 'open_id'
+    || source.sender?.id !== route.actorId || (source.thread_id || undefined) !== route.threadId
+    || (source.root_id || undefined) !== route.rootId || (source.parent_id || undefined) !== route.parentId)
+    refuse('stale-route');
+  if (query.scope === 'thread' && !route.threadId) refuse('thread-unavailable');
+  signal?.throwIfAborted();
+  const seconds = Math.floor(Number(source.create_time) / 1000);
+  if (!Number.isFinite(seconds) || seconds <= 0) refuse('stale-route');
+  const readPage = async params => {
+    const response = await checkedSdkRead(() => client.im.v1.message.list({ params }, { signal }), signal);
+    signal?.throwIfAborted();
+    const items = response?.data?.items;
+    if (!Array.isArray(items) || items.length > query.limit || typeof response.data.has_more !== 'boolean')
+      refuse('history-unavailable');
+    const events = [];
+    let omitted = 0;
+    for (const item of items) {
+      if (!item || item.chat_id !== route.conversationId
+        || (query.scope === 'thread' && item.thread_id !== route.threadId)) refuse('untrusted-source');
+      if (item.deleted || item.msg_type !== 'text' || item.sender?.sender_type !== 'user'
+        || item.sender?.id_type !== 'open_id') { ++omitted; continue; }
+      if (item.mentions !== undefined && (!Array.isArray(item.mentions) || item.mentions.length > 100)) { ++omitted; continue; }
+      let event;
+      try { event = normalizeExternalText({ event_id: `history:${item.message_id}`,
+        sender: { sender_type: 'user', sender_id: { open_id: item.sender.id }, sender_name: item.sender.sender_name },
+        message: { ...item, chat_type: 'group', message_type: item.msg_type, content: item.body?.content,
+          mentions: (item.mentions ?? []).map(mention => ({ ...mention, id: { open_id: mention?.id } })) },
+      }, identity); } catch (error) {
+        if (error?.code !== 'invalid-inbound') throw error;
+        ++omitted; continue;
+      }
+      if (!event) { ++omitted; continue; }
+      events.push(event);
+    }
+    const nextCursor = response.data.has_more ? response.data.page_token : undefined;
+    if (response.data.has_more && (typeof nextCursor !== 'string' || !nextCursor || nextCursor.length > 4096))
+      refuse('history-unavailable');
+    return {events, omitted, hasMore:response.data.has_more, ...(nextCursor ? {nextCursor} : {})};
+  };
+  if (query.scope === 'nearby') return readNearbyHistory(readPage, route, query, Number(source.create_time));
+  if (query.beforeCount !== undefined || query.afterCount !== undefined) refuse('bad-request');
+  const page = await readPage({container_id_type:query.scope === 'thread' ? 'thread' : 'chat',
+    container_id:query.scope === 'thread' ? route.threadId : route.conversationId,
+    sort_type:'ByCreateTimeDesc', page_size:query.limit, with_sender_name:true,
+    ...(query.cursor === undefined ? {} : {page_token:query.cursor})});
+  return {version:1, scope:query.scope, ...page, coverage:'provider-visible-human-text'};
+}