@xmanrui/dsh-im 4.27.0 → 4.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmanrui/dsh-im",
-  "version": "4.27.0",
+  "version": "4.28.0",
   "description": "把十二种 IM 渠道和公网 AI Office 接入本机 DeepSeek Harness。 Connect twelve IM channels and a public AI Office to a local DeepSeek Harness.",
   "keywords": [
     "deepseek-harness",

package/src/channels/feishu/bridge.mjs

@@ -305,6 +305,32 @@ function isFeishuLocalCommand(text, { hasImages = false, hasFiles = false } = {}
     || ARCHIVED_COMMAND.test(command);
 }
 
+/**
+ * A p2p text message that is nothing but a mention of the bot.
+ *
+ * The mention is stripped before we see the text, so `@bot` arrives as an empty
+ * body — indistinguishable from an empty message unless the message type is
+ * checked. Deliberately narrow:
+ *
+ *   - only `p2p`, where the reader is talking to the bot directly;
+ *   - only `text`, so a voice note, video, sticker or forwarded card keeps its
+ *     own "not supported" notice instead of silently opening a menu;
+ *   - only when nothing else came with it, so `@bot 你好` stays a prompt.
+ *
+ * The caller also treats this as a command for access control, because opening
+ * the menu is `/m` by another route and carries the same information.
+ */
+function isBareMentionMenuRequest(event, text, {
+  hasImages = false,
+  hasFiles = false,
+  hasReply = false,
+} = {}) {
+  if (event?.message?.chat_type !== 'p2p') return false;
+  if (event?.message?.message_type !== 'text') return false;
+  if (hasImages || hasFiles || hasReply) return false;
+  return !String(text ?? '').trim();
+}
+
 /** Canonical workspace/session help advertised by every bridge family. */
 const WORKSPACE_HELP_LINES = [
   '/workspace 工作区序号或绝对路径  切换工作区',
@@ -989,7 +1015,16 @@ export class FeishuHarnessBridge {
         hasImages,
         hasFiles,
       }) || isFeishuLocalCommand(commandText, { hasImages, hasFiles })
-        || (!hasImages && !hasFiles && NUMBER_REPLY.test(commandText) && this.#menus.has(key)),
+        || (!hasImages && !hasFiles && NUMBER_REPLY.test(commandText) && this.#menus.has(key))
+        // Opening the menu on a bare mention is the `/m` command by another
+        // route, so it must clear the same command gate. Treating it as plain
+        // chat let a sender without `canExecuteCommands` receive a menu that
+        // carries workspace paths and other session titles.
+        || isBareMentionMenuRequest(event, commandText, {
+          hasImages,
+          hasFiles,
+          hasReply: hasReplyReference(commandMessage),
+        }),
     });
     if (!access.allowed) {
       this.#acceptedMessageIds.set(messageId, null);
@@ -1468,6 +1503,14 @@ export class FeishuHarnessBridge {
     // accept() 侧已用 nonEmptyString(content) 判定，两侧保持一致。
     const commandText = !hasImages && !hasFiles && text ? text.trim() : null;
     if (!text && !hasImages && !hasFiles && !hasReply) {
+      // An "@bot" with nothing else carries no instruction to parse, and the
+      // menu card is what the reader is reaching for — answer it the way `/m`
+      // does rather than with a "text only" notice. Kept to plain p2p text so a
+      // voice note, video or forwarded card still gets its own notice.
+      if (isBareMentionMenuRequest(event, text, { hasImages, hasFiles, hasReply })) {
+        await this.#sendMenuCard(key, event.message.chat_id, { replyTo: event.message.message_id });
+        return;
+      }
       await this.#send(event.message.chat_id, t('目前支持文字、图片和文件消息。'), { replyTo: event.message.message_id });
       return;
     }
@@ -3755,6 +3798,7 @@ export class FeishuHarnessBridge {
     Object.assign(card, {
       blocks: structuredClone(entry.blocks), cardIds: [...entry.cardIds],
       messageId: entry.cardIds.at(-1), chunkCount: entry.cardIds.length,
+      activeCardStart: 0, renderedCardContents: new Map(),
       answerStart: entry.answerStart ?? null, answerEnd: entry.answerEnd ?? null,
       deliveryViaOpenId: true,
     });
@@ -4266,6 +4310,8 @@ export class FeishuHarnessBridge {
         renderChain: null,
         chunkCount: 1,
         cardIds: [],
+        activeCardStart: 0,
+        renderedCardContents: new Map(),
         answerStart: null,
         answerEnd: null,
         // Answer-integrity tracking: the version bumps every time the draft
@@ -4416,62 +4462,51 @@ export class FeishuHarnessBridge {
     });
   }
 
+  /** Sync only this interaction's cards; earlier interactions remain sealed. */
+  async #syncStepCardChunks(card, chunks, status) {
+    const answerVersion = card.answerVersion ?? 0;
+    const activeIds = card.cardIds.slice(card.activeCardStart);
+    const groups = chunks.length ? [...chunks] : [[]];
+    // Retain the last message as the live card when a rewritten answer shrinks.
+    // Clear stale prefixes without introducing a separate deletion/retry path.
+    while (groups.length < activeIds.length) {
+      groups.unshift([{ kind: 'message', text: t('内容已合并至后续消息。') }]);
+    }
+    // Serialize before the first await: a concurrent draft must not change the
+    // payload halfway through this render or be marked as already delivered.
+    const contents = groups.map((blocks, index) => stepStreamCard(blocks, {
+      status: index === groups.length - 1 ? status : 'sealed',
+    }));
+    for (let index = 0; index < contents.length; index += 1) {
+      let id = activeIds[index];
+      const content = contents[index];
+      if (id) {
+        if (card.renderedCardContents.get(id) !== content) {
+          await this.#patchStepCard(id, content);
+        }
+      } else {
+        id = await this.#sendCard(card.chatId, content, card.deliveryViaOpenId
+          ? { receiveIdType: 'open_id' }
+          : { replyTo: card.replyToMessageId });
+        card.cardIds.push(id);
+        activeIds.push(id);
+      }
+      card.renderedCardContents.set(id, content);
+    }
+    card.messageId = activeIds.at(-1);
+    card.chunkCount = activeIds.length;
+    card.renderedAnswerVersion = answerVersion;
+  }
+
   async #renderStepCardNow(chatId, card) {
     if (card.broken) return;
     const chunks = splitStepStreamCardBlocks(card.blocks);
+    if (!chunks.length && card.messageId === null) return;
     const live = chunks[chunks.length - 1] ?? [];
     try {
-      if (card.messageId === null) {
-        // First render: deliver every chunk. When the turn opens with a long
-        // answer already in memory, chunks.length can exceed one — sending
-        // only the live chunk here would silently drop its prefix, and the
-        // chunkCount bookkeeping below would then rewrite the delivered
-        // message with chunk 0 on the next render.
-        for (let index = 0; index < chunks.length; index += 1) {
-          const isLive = index === chunks.length - 1;
-          const id = await this.#sendCard(
-            chatId,
-            stepStreamCard(chunks[index], { status: isLive ? 'running' : 'sealed' }),
-            card.deliveryViaOpenId
-              ? { receiveIdType: 'open_id' }
-              : { replyTo: card.replyToMessageId },
-          );
-          card.cardIds.push(id);
-          if (isLive) card.messageId = id;
-        }
-        card.chunkCount = chunks.length;
-        await this.#persistMirrorState(card, live, 'running');
-        card.lastRenderAt = this.#stepPushClock.now();
-        card.renderedAnswerVersion = card.answerVersion ?? 0;
-        return;
-      }
-      // Overflow: the accumulated blocks outgrew one card. Seal the current
-      // message (no status line), spill extra chunks, and keep the last one
-      // live. Chunk boundaries are stable because blocks only append.
-      if (chunks.length > card.chunkCount) {
-        await this.#patchStepCard(
-          card.messageId,
-          stepStreamCard(chunks[card.chunkCount - 1], { status: 'sealed' }),
-        );
-        for (let index = card.chunkCount; index < chunks.length; index += 1) {
-          const isLive = index === chunks.length - 1;
-          const id = await this.#sendCard(
-            chatId,
-            stepStreamCard(chunks[index], { status: isLive ? 'running' : 'sealed' }),
-            card.deliveryViaOpenId
-              ? { receiveIdType: 'open_id' }
-              : { replyTo: card.replyToMessageId },
-          );
-          card.cardIds.push(id);
-          if (isLive) card.messageId = id;
-        }
-        card.chunkCount = chunks.length;
-      } else {
-        await this.#patchStepCard(card.messageId, stepStreamCard(live, { status: 'running' }));
-      }
+      await this.#syncStepCardChunks(card, chunks, 'running');
       await this.#persistMirrorState(card, live, 'running');
       card.lastRenderAt = this.#stepPushClock.now();
-      card.renderedAnswerVersion = card.answerVersion ?? 0;
     } catch (error) {
       card.broken = true;
       this.#logger.warn?.(
@@ -4510,52 +4545,8 @@ export class FeishuHarnessBridge {
       this.#writeStepCardAnswer(card, body);
     }
     const chunks = splitStepStreamCardBlocks(card.blocks);
-    const live = chunks[chunks.length - 1] ?? [];
     try {
-      if (card.messageId === null) {
-        // A turn without any queued render (plain Q&A): open the cards
-        // directly with their terminal status; every overflow chunk before
-        // the last one is sealed. An empty turn still opens the status card.
-        const groups = chunks.length > 0 ? chunks : [[]];
-        for (let index = 0; index < groups.length; index += 1) {
-          const isLive = index === groups.length - 1;
-          const id = await this.#sendCard(
-            card.chatId,
-            stepStreamCard(groups[index], { status: isLive ? status : 'sealed' }),
-            card.deliveryViaOpenId
-              ? { receiveIdType: 'open_id' }
-              : { replyTo: card.replyToMessageId },
-          );
-          card.cardIds.push(id);
-        }
-        return { ok: true, cardIds: card.cardIds };
-      }
-      // The live message only ever shows the last chunk; spill every chunk
-      // that has not been delivered yet as sealed cards before patching the
-      // live one, otherwise a long answer finishing on an existing card
-      // would silently drop its prefix.
-      if (chunks.length > card.chunkCount) {
-        await this.#patchStepCard(
-          card.messageId,
-          stepStreamCard(chunks[card.chunkCount - 1], { status: 'sealed' }),
-        );
-        for (let index = card.chunkCount; index < chunks.length; index += 1) {
-          const isLast = index === chunks.length - 1;
-          const id = await this.#sendCard(
-            card.chatId,
-            stepStreamCard(chunks[index], { status: isLast ? status : 'sealed' }),
-            card.deliveryViaOpenId
-              ? { receiveIdType: 'open_id' }
-              : { replyTo: card.replyToMessageId },
-          );
-          card.cardIds.push(id);
-          if (isLast) card.messageId = id;
-        }
-        card.chunkCount = chunks.length;
-      } else {
-        await this.#patchStepCard(card.messageId, stepStreamCard(live, { status }));
-      }
-      card.renderedAnswerVersion = card.answerVersion ?? 0;
+      await this.#syncStepCardChunks(card, chunks, status);
       return { ok: true, cardIds: card.cardIds };
     } catch (error) {
       // Only trust the streamed draft when the LAST SUCCESSFUL render actually
@@ -4606,8 +4597,7 @@ export class FeishuHarnessBridge {
     if (card.messageId === null) return;
     try {
       const chunks = splitStepStreamCardBlocks(card.blocks);
-      const live = chunks[chunks.length - 1] ?? [];
-      await this.#patchStepCard(card.messageId, stepStreamCard(live, { status: 'sealed' }));
+      await this.#syncStepCardChunks(card, chunks, 'sealed');
     } catch (error) {
       this.#logger.warn?.(
         '[dsh-feishu] step streaming card rotate seal failed:',
@@ -4615,6 +4605,8 @@ export class FeishuHarnessBridge {
       );
     }
     // Restart the stream on a fresh card below the interaction message.
+    card.activeCardStart = card.cardIds.length;
+    card.renderedCardContents.clear();
     card.blocks = [];
     card.messageId = null;
     card.chunkCount = 1;

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

@@ -1009,20 +1009,191 @@ export function stepStatusText(status) {
   return t('运行中');
 }
 
+/**
+ * A single card accepts only this many `table` elements. Feishu rejects the
+ * whole write with `230099 / ErrCode 11310 card table number over limit`, which
+ * leaves the card stuck on its previous content, so the reply never appears.
+ *
+ * The boundary was established by the maintainer against a live bot: five
+ * tables in one card succeeded, six failed, and a folded process panel's tables
+ * counted toward the total (3 folded + 2 in the body succeeded, 3 + 3 failed).
+ */
+export const STEP_STREAM_CARD_MAX_TABLES = 5;
+
+function hasClosingBacktickRun(text, start, length) {
+  for (let index = start; index < text.length;) {
+    if (text[index] !== '`') {
+      index += 1;
+      continue;
+    }
+    let end = index + 1;
+    while (text[end] === '`') end += 1;
+    if (end - index === length) return true;
+    index = end;
+  }
+  return false;
+}
+
+function gfmTableCells(line) {
+  const normalized = line.endsWith('\r') ? line.slice(0, -1) : line;
+  if (normalized.startsWith('    ') || normalized.startsWith('\t')) return null;
+  const text = normalized.trim();
+  if (!text) return null;
+
+  const cells = [];
+  let cell = '';
+  let separators = 0;
+  let codeRun = 0;
+  for (let index = 0; index < text.length;) {
+    const character = text[index];
+    if (character === '\\' && index + 1 < text.length) {
+      cell += text.slice(index, index + 2);
+      index += 2;
+      continue;
+    }
+    if (character === '`') {
+      let end = index + 1;
+      while (text[end] === '`') end += 1;
+      const length = end - index;
+      if (codeRun === length) {
+        codeRun = 0;
+      } else if (codeRun === 0 && hasClosingBacktickRun(text, end, length)) {
+        codeRun = length;
+      }
+      cell += text.slice(index, end);
+      index = end;
+      continue;
+    }
+    if (character === '|' && codeRun === 0) {
+      cells.push(cell);
+      cell = '';
+      separators += 1;
+      index += 1;
+      continue;
+    }
+    cell += character;
+    index += 1;
+  }
+  if (separators === 0) return null;
+  cells.push(cell);
+  if (cells[0].trim() === '') cells.shift();
+  if (cells.at(-1)?.trim() === '') cells.pop();
+  return cells.length > 0 ? cells : null;
+}
+
+/** Locate table headers once for both counting and splitting. */
+function markdownTableStarts(text) {
+  if (typeof text !== 'string' || !text) return [];
+  const lines = text.split('\n');
+  const offsets = [];
+  let offset = 0;
+  for (const line of lines) {
+    offsets.push(offset);
+    offset += line.length + 1;
+  }
+  const starts = [];
+  let fence = null;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index].replace(/\r$/, '');
+    if (fence) {
+      const close = /^ {0,3}(`{3,}|~{3,})[ \t]*$/.exec(line);
+      if (close && close[1][0] === fence[0] && close[1].length >= fence.length) fence = null;
+      continue;
+    }
+    const opening = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+    if (opening && (opening[1][0] !== '`' || !opening[2].includes('`'))) {
+      fence = opening[1];
+      continue;
+    }
+    const header = gfmTableCells(line);
+    const delimiter = gfmTableCells(lines[index + 1] ?? '');
+    if (!header || !delimiter || header.length !== delimiter.length
+      || !delimiter.every((cell) => /^\s*:?-+:?\s*$/.test(cell))) continue;
+    starts.push(offsets[index]);
+    index += 1;
+    // A delimiter-looking data row is part of this table, not another header.
+    while (index + 1 < lines.length && gfmTableCells(lines[index + 1])) index += 1;
+  }
+  return starts;
+}
+
+export function countMarkdownTables(text) {
+  return markdownTableStarts(text).length;
+}
+
+function splitMarkdownByTableLimit(text, maxTables) {
+  const starts = markdownTableStarts(text);
+  const parts = [];
+  let from = 0;
+  for (let index = maxTables; index < starts.length; index += maxTables) {
+    parts.push(text.slice(from, starts[index]));
+    from = starts[index];
+  }
+  parts.push(text.slice(from));
+  return parts;
+}
+
+/** Count the Markdown that stepStreamCard actually renders. */
+function stepStreamCardTableCount(blocks) {
+  return blocks.reduce((sum, block) => {
+    const text = block?.kind === 'notes' || block?.kind === 'tools'
+      ? (block.lines ?? []).filter((line) => typeof line === 'string' && line.trim()).join('\n')
+      : block?.text;
+    return sum + countMarkdownTables(text);
+  }, 0);
+}
+
+/** Split display copies; the bridge's logical blocks and answer indices stay intact. */
+export function splitBlockByTableLimit(block, maxTables = STEP_STREAM_CARD_MAX_TABLES) {
+  if (!block || typeof block !== 'object' || !Number.isInteger(maxTables) || maxTables < 1) return [block];
+  if (block.kind === 'notes' || block.kind === 'tools') {
+    const lines = (block.lines ?? []).filter((line) => typeof line === 'string' && line.trim());
+    if (countMarkdownTables(lines.join('\n')) <= maxTables) return [block];
+    const groups = [];
+    let current = [];
+    for (const line of lines) {
+      for (const part of splitMarkdownByTableLimit(line, maxTables)) {
+        if (current.length && countMarkdownTables([...current, part].join('\n')) > maxTables) {
+          groups.push(current);
+          current = [];
+        }
+        current.push(part);
+      }
+    }
+    if (current.length) groups.push(current);
+    return groups.map((lines, index) => ({ ...block, lines, omitted: index === 0 ? block.omitted : 0 }));
+  }
+  if (typeof block.text !== 'string' || countMarkdownTables(block.text) <= maxTables) return [block];
+  return splitMarkdownByTableLimit(block.text, maxTables).map((text) => ({ ...block, text }));
+}
+
 /**
  * Split accumulated blocks into card-sized chunks at block boundaries,
- * budgeted by the encoded running-status card (the largest render). Every
- * chunk keeps at least one block so progress is never dropped. The caller
- * renders all but the last chunk as `sealed` and the last one live.
+ * budgeted by the encoded running-status card (the largest render) **and** by
+ * the table count, because a card accepts only a handful of tables no matter
+ * how small it is. Every chunk keeps at least one block so progress is never
+ * dropped. The caller renders all but the last chunk as `sealed` and the last
+ * one live.
  */
-export function splitStepStreamCardBlocks(blocks, limit = STEP_STREAM_CARD_MAX_BYTES) {
-  const list = (Array.isArray(blocks) ? blocks : []).filter(Boolean);
+export function splitStepStreamCardBlocks(
+  blocks,
+  limit = STEP_STREAM_CARD_MAX_BYTES,
+  maxTables = STEP_STREAM_CARD_MAX_TABLES,
+) {
+  // A single block can carry more tables than a card accepts — one short answer
+  // with six small tables — and splitting only between blocks cannot help. Each
+  // block is broken at table boundaries first, so the walk below sees pieces it
+  // can actually distribute.
+  const list = (Array.isArray(blocks) ? blocks : [])
+    .filter(Boolean)
+    .flatMap((block) => splitBlockByTableLimit(block, maxTables));
   if (list.length === 0) return [];
   const chunks = [];
   let current = [];
   for (const block of list) {
-    if (current.length > 0
-      && Buffer.byteLength(stepStreamCard([...current, block]), 'utf8') > limit) {
+    const tooLarge = Buffer.byteLength(stepStreamCard([...current, block]), 'utf8') > limit;
+    const tooManyTables = stepStreamCardTableCount([...current, block]) > maxTables;
+    if (current.length > 0 && (tooLarge || tooManyTables)) {
       chunks.push(current);
       current = [block];
     } else {

package/src/channels/feishu/message-utils.mjs

@@ -534,8 +534,17 @@ export function extractInboundMessage(event, client) {
   const imageKeys = standaloneImageKey ? [standaloneImageKey] : post?.imageKeys ?? [];
   const file = messageType === 'file' ? feishuFileSource(event, client, parsed) : null;
   const replyTo = feishuReplyReference(event, client);
+  // A forwarded card arrives as `interactive`. Without this branch its text was
+  // dropped entirely, so the message looked empty and the reader got the
+  // "text, image and file only" notice — even though the same extraction is
+  // already trusted for quoted cards (`feishuReplyReference`).
+  const cardText = messageType === 'interactive' ? interactiveCardText(parsed) : '';
   return {
-    content: messageType === 'text' ? extractText(event) ?? '' : post?.text ?? '',
+    content: messageType === 'text'
+      ? extractText(event) ?? ''
+      : messageType === 'interactive'
+        ? cardText
+        : post?.text ?? '',
     images: imageKeys.map((key) => feishuImageSource(event, client, key)),
     files: file ? [file] : [],
     ...(replyTo ? { replyTo } : {}),

package/src/channels/shared/i18n-en/feishu.mjs

@@ -1,5 +1,6 @@
 // English translations (feishu area). Keys are exact Chinese literals passed to t().
 export default {
+  '内容已合并至后续消息。': 'Content has been consolidated into the following messages.',
   // feishu/bridge.mjs — welcome / help
   '北汇星河 AIOS 已连接 DeepSeek Harness。':
     'BeiHui XingHe AIOS is connected to DeepSeek Harness.',