@xmanrui/dsh-im 4.37.0 → 4.38.1

package/src/channels/feishu/bridge.mjs

@@ -1,6 +1,7 @@
 import { BusyMessageDispatcher, canAutomaticallySteer } from '../shared/busy-message-dispatcher.mjs';
 import { isPermissionCommand, runPermissionCommand } from '../shared/permission-command.mjs';
 import { randomUUID } from 'node:crypto';
+import { chunkMarkdownText } from '../shared/markdown-chunks.mjs';
 import QRCode from 'qrcode';
 import { waitForFeishuOperation } from './feishu-channel.mjs';
 import {
@@ -122,6 +123,7 @@ import {
 import {
   FEISHU_STEP_PUSH_MODES,
   normalizeFeishuStepPushMode,
+  normalizeFeishuStepCardPanels,
 } from './step-push-mode.mjs';
 import { FeishuLiveCot } from './live-cot.mjs';
 
@@ -680,6 +682,7 @@ export class FeishuHarnessBridge {
   #stepPush = false;
   /** Step push presentation: discrete posts, a CardKit card, or native live CoT. */
   #stepPushMode = FEISHU_STEP_PUSH_MODES.POST;
+  #stepCardPanels;
   /** Per-conversation step push state: key → { lastSentAt, count, breakerLogged }. */
   #stepPushSendState = new Map();
   /** Live streaming step cards: key → per-turn card state (streaming_card mode). */
@@ -745,6 +748,7 @@ export class FeishuHarnessBridge {
     mentionTopicReply = true,
     stepPush = false,
     stepPushMode = FEISHU_STEP_PUSH_MODES.POST,
+    stepCardPanels,
     stepPushClock = null,
     repair,
     repairPollIntervalMs = REPAIR_POLL_INTERVAL_MS,
@@ -805,6 +809,7 @@ export class FeishuHarnessBridge {
     this.#mentionTopicReply = mentionTopicReply !== false;
     this.#stepPush = stepPush === true;
     this.#stepPushMode = normalizeFeishuStepPushMode(stepPushMode);
+    this.#stepCardPanels = normalizeFeishuStepCardPanels(stepCardPanels);
     this.#stepPushClock = stepPushClock ?? DEFAULT_STEP_PUSH_CLOCK;
     this.#voice = voice ?? null;
     this.#repair = repair ?? null;
@@ -901,6 +906,10 @@ export class FeishuHarnessBridge {
     this.#stepPushMode = normalizeFeishuStepPushMode(value);
   }
 
+  setStepCardPanels(value) {
+    this.#stepCardPanels = normalizeFeishuStepCardPanels(value);
+  }
+
   setVoice(voice) {
     this.#voice = voice ?? null;
   }
@@ -4782,7 +4791,13 @@ export class FeishuHarnessBridge {
 
   /** Replace the draft interval with `text` chunked into splitter-safe blocks. */
   #writeStepCardAnswer(card, text) {
-    const blocks = splitStepPostMarkdown(text, STEP_STREAM_ANSWER_CHUNK_MAX_BYTES)
+    // JSON can expand one UTF-16 unit to six bytes (for example a control
+    // character). Leave room for the element wrapper, and let the existing
+    // Markdown splitter reopen fences in each independently rendered block.
+    const chunks = Buffer.byteLength(JSON.stringify(text), 'utf8') + 128 <= STEP_STREAM_ANSWER_CHUNK_MAX_BYTES
+      ? [text]
+      : chunkMarkdownText(text, Math.floor((STEP_STREAM_ANSWER_CHUNK_MAX_BYTES - 128) / 6));
+    const blocks = chunks
       .map((chunk) => ({ kind: 'message', text: chunk }));
     if (card.answerStart !== null) {
       card.blocks.splice(card.answerStart, card.answerEnd - card.answerStart + 1, ...blocks);
@@ -4845,7 +4860,7 @@ export class FeishuHarnessBridge {
    * their lifecycle is owned by the ask path, not the mirror recovery.
    * lastContent keeps stepStreamCard's raw JSON string (single-encoded).
    */
-  async #persistMirrorState(card, liveBlocks, status) {
+  async #persistMirrorState(card, liveBlocks, status, stepCardPanels) {
     const sessionId = card.sessionSyncSessionId;
     if (!sessionId || typeof this.#state.setMirror !== 'function') return;
     await this.#state.setMirror(card.sessionSyncKey, {
@@ -4853,7 +4868,7 @@ export class FeishuHarnessBridge {
       chatId: card.chatId,
       cardIds: [...card.cardIds],
       claimedAt: Date.now(),
-      lastContent: stepStreamCard(liveBlocks, { status }),
+      lastContent: stepStreamCard(liveBlocks, { status, stepCardPanels }),
       blocks: structuredClone(card.blocks), answerStart: card.answerStart, answerEnd: card.answerEnd,
       lastSeq: this.#sessionSyncTurns.get(card.sessionSyncKey)?.lastSeq ?? -1,
       pendingStep: this.#sessionSyncTurns.get(card.sessionSyncKey)?.pendingStep ?? null,
@@ -4861,7 +4876,7 @@ export class FeishuHarnessBridge {
   }
 
   /** Sync only this interaction's cards; earlier interactions remain sealed. */
-  async #syncStepCardChunks(card, chunks, status) {
+  async #syncStepCardChunks(card, chunks, status, stepCardPanels) {
     const answerVersion = card.answerVersion ?? 0;
     const activeIds = card.cardIds.slice(card.activeCardStart);
     const groups = chunks.length ? [...chunks] : [[]];
@@ -4874,6 +4889,7 @@ export class FeishuHarnessBridge {
     // 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',
+      stepCardPanels,
     }));
     for (let index = 0; index < contents.length; index += 1) {
       let id = activeIds[index];
@@ -4898,12 +4914,13 @@ export class FeishuHarnessBridge {
 
   async #renderStepCardNow(chatId, card) {
     if (card.broken) return;
-    const chunks = splitStepStreamCardBlocks(card.blocks);
+    const stepCardPanels = this.#stepCardPanels;
+    const chunks = splitStepStreamCardBlocks(card.blocks, undefined, undefined, stepCardPanels);
     if (!chunks.length && card.messageId === null) return;
     const live = chunks[chunks.length - 1] ?? [];
     try {
-      await this.#syncStepCardChunks(card, chunks, 'running');
-      await this.#persistMirrorState(card, live, 'running');
+      await this.#syncStepCardChunks(card, chunks, 'running', stepCardPanels);
+      await this.#persistMirrorState(card, live, 'running', stepCardPanels);
       card.lastRenderAt = this.#stepPushClock.now();
     } catch (error) {
       card.broken = true;
@@ -4943,9 +4960,10 @@ export class FeishuHarnessBridge {
     if (body.trim()) {
       this.#writeStepCardAnswer(card, body);
     }
-    const chunks = splitStepStreamCardBlocks(card.blocks);
+    const stepCardPanels = this.#stepCardPanels;
+    const chunks = splitStepStreamCardBlocks(card.blocks, undefined, undefined, stepCardPanels);
     try {
-      await this.#syncStepCardChunks(card, chunks, status);
+      await this.#syncStepCardChunks(card, chunks, status, stepCardPanels);
       return { ok: true, cardIds: card.cardIds };
     } catch (error) {
       // Only trust the streamed draft when the LAST SUCCESSFUL render actually
@@ -4996,8 +5014,9 @@ export class FeishuHarnessBridge {
     if (card.broken) return;
     if (card.messageId === null) return;
     try {
-      const chunks = splitStepStreamCardBlocks(card.blocks);
-      await this.#syncStepCardChunks(card, chunks, 'sealed');
+      const stepCardPanels = this.#stepCardPanels;
+      const chunks = splitStepStreamCardBlocks(card.blocks, undefined, undefined, stepCardPanels);
+      await this.#syncStepCardChunks(card, chunks, 'sealed', stepCardPanels);
     } catch (error) {
       this.#logger.warn?.(
         '[dsh-feishu] step streaming card rotate seal failed:',

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

@@ -16,6 +16,7 @@
 
 import { posix, win32 } from 'node:path';
 import { t } from '../shared/i18n.mjs';
+import { normalizeFeishuStepCardPanels } from './step-push-mode.mjs';
 
 export const MENU_PAGE_SIZE = 10;
 
@@ -1000,15 +1001,16 @@ export const STEP_STREAM_CARD_MAX_BYTES = 24_000;
  * Build one streaming step card from the accumulated process blocks:
  *   { kind: 'message', text }         — interim note / warning / context line
  *   { kind: 'tools', lines: string[] } — tool-call summary panel
- * `status`: 'running' keeps panels expanded and ends with an italic status
+ * `status`: 'running' uses the configured panel expansion and ends with an italic status
  * line; 'completed' / 'stopped' collapse the panels and swap the status text;
  * 'sealed' is an overflow spill chunk with no status line at all. Finished
  * turns (and sealed spill chunks) merge every tool/thinking panel into one
  * collapsed "process details" panel so the sealed card stays compact.
  */
 
-export function stepStreamCard(rawBlocks, { status = 'running' } = {}) {
+export function stepStreamCard(rawBlocks, { status = 'running', stepCardPanels } = {}) {
   const running = status === 'running';
+  const panels = normalizeFeishuStepCardPanels(stepCardPanels);
   const elements = [];
   const panelElements = [];
   for (const block of Array.isArray(rawBlocks) ? rawBlocks : []) {
@@ -1021,10 +1023,8 @@ export function stepStreamCard(rawBlocks, { status = 'running' } = {}) {
         title: block.kind === 'tools'
           ? t('🛠️ 工具摘要（{count}）', { count })
           : t('💭 思考过程（{count}）', { count }),
-        // Tool summaries stay visible while the turn runs; thinking notes
-        // remain folded at all times. Finished turns keep both panels but
-        // tuck them inside one collapsed "process details" wrapper.
-        expanded: block.kind === 'tools' && running,
+        // Finished turns keep both panels inside the collapsed details wrapper.
+        expanded: running && (block.kind === 'tools' ? panels.toolsExpanded : panels.thinkingExpanded),
       });
       if (running) elements.push(panel);
       else panelElements.push(panel);
@@ -1265,6 +1265,7 @@ export function splitStepStreamCardBlocks(
   blocks,
   limit = STEP_STREAM_CARD_MAX_BYTES,
   maxTables = STEP_STREAM_CARD_MAX_TABLES,
+  stepCardPanels,
 ) {
   // 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
@@ -1277,7 +1278,7 @@ export function splitStepStreamCardBlocks(
   const chunks = [];
   let current = [];
   for (const block of list) {
-    const tooLarge = Buffer.byteLength(stepStreamCard([...current, block]), 'utf8') > limit;
+    const tooLarge = Buffer.byteLength(stepStreamCard([...current, block], { stepCardPanels }), 'utf8') > limit;
     const tooManyTables = stepStreamCardTableCount([...current, block]) > maxTables;
     if (current.length > 0 && (tooLarge || tooManyTables)) {
       chunks.push(current);

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

@@ -5,7 +5,7 @@ import { FeishuHarnessBridge } from './bridge.mjs';
 import { cardActionProbeCard } from './feishu-cards.mjs';
 import { VerifiedFeishuChannel, waitForFeishuOperation } from './feishu-channel.mjs';
 import { normalizeFeishuGroupResponseMode } from './group-response-mode.mjs';
-import { normalizeFeishuStepPushMode } from './step-push-mode.mjs';
+import { normalizeFeishuStepPushMode, normalizeFeishuStepCardPanels } from './step-push-mode.mjs';
 import { createVoice } from './voice.mjs';
 import {
   syncSlashCommands,
@@ -119,6 +119,7 @@ export class FeishuRuntime {
   #mentionTopicReply;
   #stepPush;
   #stepPushMode;
+  #stepCardPanels;
   #voice = null;
   #sessionSyncTargetsFor;
   #ownerOpenIds;
@@ -171,6 +172,7 @@ export class FeishuRuntime {
     mentionTopicReply = true,
     stepPush = false,
     stepPushMode = 'post',
+    stepCardPanels,
     voice = null,
     sessionSyncTargetsFor = null,
     ownerOpenId,
@@ -214,6 +216,7 @@ export class FeishuRuntime {
     this.#mentionTopicReply = mentionTopicReply !== false;
     this.#stepPush = stepPush === true;
     this.#stepPushMode = normalizeFeishuStepPushMode(stepPushMode);
+    this.#stepCardPanels = normalizeFeishuStepCardPanels(stepCardPanels);
     // voice 为 { config, secret } 来源;凭据缺失时 createVoice 返回禁用对象,
     // 桥接层完全跳过语音路径,不影响连接。
     this.#voice = voice == null
@@ -262,6 +265,11 @@ export class FeishuRuntime {
     this.#bridge?.setStepPushMode(this.#stepPushMode);
   }
 
+  setStepCardPanels(value) {
+    this.#stepCardPanels = normalizeFeishuStepCardPanels(value);
+    this.#bridge?.setStepCardPanels(this.#stepCardPanels);
+  }
+
   setVoice(source) {
     this.#voice = source == null
       ? null
@@ -371,6 +379,7 @@ export class FeishuRuntime {
         mentionTopicReply: this.#mentionTopicReply,
         stepPush: this.#stepPush,
         stepPushMode: this.#stepPushMode,
+        stepCardPanels: this.#stepCardPanels,
         voice: this.#voice,
         sessionSyncTargetsFor: this.#sessionSyncTargetsFor,
         repair: this.#repair,

package/src/channels/feishu/multi-bot-controller.mjs

@@ -21,6 +21,8 @@ import {
   DEFAULT_FEISHU_STEP_PUSH_MODE,
   isFeishuStepPushMode,
   normalizeFeishuStepPushMode,
+  isFeishuStepCardPanels,
+  normalizeFeishuStepCardPanels,
 } from './step-push-mode.mjs';
 import { normalizeFeishuVoiceConfig } from './voice-config.mjs';
 import {
@@ -106,6 +108,7 @@ function configuredBotFingerprint(config) {
     mentionTopicReply: config.mentionTopicReply !== false,
     stepPush: config.stepPush === true,
     stepPushMode: normalizeFeishuStepPushMode(config.stepPushMode),
+    stepCardPanels: normalizeFeishuStepCardPanels(config.stepCardPanels),
     voice: config.voice,
     slashPanel: normalizeSlashPanelConfig(config.slashPanel),
     groupMessagePermissionGranted: config.groupMessagePermissionGranted === true,
@@ -816,6 +819,20 @@ export class MultiBotDshFeishuController {
     }));
   }
 
+  async updateStepCardPanels(botId, stepCardPanels) {
+    this.#assertOpen();
+    if (!isFeishuStepCardPanels(stepCardPanels)) {
+      throw new TypeError('Invalid Feishu step card panels');
+    }
+    return this.#serializeConfig(() => this.#withBotTransition(botId, async () => {
+      const config = this.#requireBot(botId);
+      const saved = await this.#configStore.saveBot({ ...config, stepCardPanels });
+      this.#runtimes.get(botId)?.setStepCardPanels?.(saved.stepCardPanels);
+      this.#touch();
+      return this.status(botId);
+    }));
+  }
+
   async updateVoice(botId, voice) {
     this.#assertOpen();
     if (voice !== null && (typeof voice !== 'object' || Array.isArray(voice))) {
@@ -901,6 +918,7 @@ export class MultiBotDshFeishuController {
         mentionTopicReply: config.mentionTopicReply !== false,
         stepPush: config.stepPush === true,
         stepPushMode: normalizeFeishuStepPushMode(config.stepPushMode),
+        stepCardPanels: normalizeFeishuStepCardPanels(config.stepCardPanels),
         voice: normalizeFeishuVoiceConfig(config.voice),
         slashPanel: normalizeSlashPanelConfig(config.slashPanel),
         groupMessagePermissionGranted: config.groupMessagePermissionGranted === true,

package/src/channels/feishu/plugin-config-store.mjs

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { normalizeFeishuGroupResponseMode } from './group-response-mode.mjs';
-import { normalizeFeishuStepPushMode } from './step-push-mode.mjs';
+import { normalizeFeishuStepPushMode, normalizeFeishuStepCardPanels } from './step-push-mode.mjs';
 import { normalizeFeishuVoiceConfig } from './voice-config.mjs';
 import { normalizeSlashPanelConfig } from './slash-command-panel.mjs';
 
@@ -52,6 +52,7 @@ function normalizeBot(value, { legacy = false } = {}) {
     mentionTopicReply: value.mentionTopicReply !== false,
     stepPush: value.stepPush === true,
     stepPushMode: normalizeFeishuStepPushMode(value.stepPushMode),
+    stepCardPanels: normalizeFeishuStepCardPanels(value.stepCardPanels),
     voice: normalizeFeishuVoiceConfig(value.voice),
     slashPanel: normalizeSlashPanelConfig(value.slashPanel),
     groupMessagePermissionGranted: value.groupMessagePermissionGranted === true,

package/src/channels/feishu/step-push-mode.mjs

@@ -7,6 +7,27 @@ export const FEISHU_STEP_PUSH_MODES = Object.freeze({
 /** New connections explicitly opt into the process-card presentation. */
 export const DEFAULT_FEISHU_STEP_PUSH_MODE = FEISHU_STEP_PUSH_MODES.STREAMING_CARD;
 
+export const DEFAULT_FEISHU_STEP_CARD_PANELS = Object.freeze({
+  thinkingExpanded: false,
+  toolsExpanded: true,
+});
+
+export function normalizeFeishuStepCardPanels(value) {
+  return Object.freeze({
+    thinkingExpanded: typeof value?.thinkingExpanded === 'boolean'
+      ? value.thinkingExpanded : DEFAULT_FEISHU_STEP_CARD_PANELS.thinkingExpanded,
+    toolsExpanded: typeof value?.toolsExpanded === 'boolean'
+      ? value.toolsExpanded : DEFAULT_FEISHU_STEP_CARD_PANELS.toolsExpanded,
+  });
+}
+
+export function isFeishuStepCardPanels(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    && Object.keys(value).every((key) => key === 'thinkingExpanded' || key === 'toolsExpanded')
+    && typeof value.thinkingExpanded === 'boolean'
+    && typeof value.toolsExpanded === 'boolean';
+}
+
 export function normalizeFeishuStepPushMode(value) {
   // Bots created before modes existed used posts when step push was enabled.
   if (value === FEISHU_STEP_PUSH_MODES.STREAMING_CARD) {

package/src/channels/matrix/matrix-crypto.mjs

@@ -97,6 +97,7 @@ export class MatrixCryptoEngine {
   #seenIndex = new Map();
   #pendingEvents = new Map();
   #requestState = new Map();
+  #pendingTasks = new Set();
   #lastKeyMaintenanceAt = 0;
   #stats = {
     undecryptable: 0,
@@ -239,6 +240,12 @@ export class MatrixCryptoEngine {
   }
 
   async stop() {
+    this.#ready = false;
+    // A key request can enqueue persistence after shutdown starts. Drain both
+    // before releasing sessions or allowing the caller to remove the store.
+    while (this.#pendingTasks.size > 0) {
+      await Promise.allSettled([...this.#pendingTasks]);
+    }
     for (const entry of this.#inbound.values()) entry.session.free?.();
     for (const entry of this.#outbound.values()) entry.session.free?.();
     this.#inbound.clear();
@@ -247,7 +254,12 @@ export class MatrixCryptoEngine {
     this.#memberCache.clear();
     this.#pendingEvents.clear();
     this.#seenIndex.clear();
-    this.#ready = false;
+  }
+
+  #trackTask(task) {
+    const tracked = task.finally(() => this.#pendingTasks.delete(tracked));
+    this.#pendingTasks.add(tracked);
+    return tracked;
   }
 
   async maintain() {
@@ -717,7 +729,9 @@ export class MatrixCryptoEngine {
     if (!entry) {
       this.#stats.undecryptable += 1;
       this.#pendingEvents.set(`${key}|${event?.event_id ?? 'x'}`, { roomId, event, at: this.#now() });
-      void this.#requestRoomKey(roomId, event);
+      void this.#trackTask(this.#requestRoomKey(roomId, event).catch((error) => {
+        this.#logger.warn?.('[dsh-im:matrix] a room key request failed:', error?.message ?? error);
+      }));
       return null;
     }
     const seen = this.#seenIndexes(key);
@@ -908,7 +922,7 @@ export class MatrixCryptoEngine {
     } catch {
       return Promise.resolve();
     }
-    return this.#store.apply({ groupOutbound }).catch(() => undefined);
+    return this.#trackTask(this.#store.apply({ groupOutbound }).catch(() => undefined));
   }
 
   #persistInbound(key) {
@@ -936,7 +950,7 @@ export class MatrixCryptoEngine {
         lastUsedAt: entry.lastUsedAt,
       },
     ].slice(-900);
-    return this.#store.apply({ groupInbound }).catch(() => undefined);
+    return this.#trackTask(this.#store.apply({ groupInbound }).catch(() => undefined));
   }
 
   #persistRequestState() {
@@ -944,7 +958,7 @@ export class MatrixCryptoEngine {
     if (!snapshot) return Promise.resolve();
     const requestState = {};
     for (const [key, state] of [...this.#requestState].slice(-200)) requestState[key] = { ...state };
-    return this.#store.apply({ requestState }).catch(() => undefined);
+    return this.#trackTask(this.#store.apply({ requestState }).catch(() => undefined));
   }
 
   // ---- key registration ---------------------------------------------------

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

@@ -36,6 +36,7 @@ import {
   extractOutboundMentions,
   hasRoomMention,
 } from './matrix-rich-text.mjs';
+import { chunkMarkdownParts } from '../shared/markdown-chunks.mjs';
 
 const RECONNECT_DELAYS_MS = Object.freeze([1_000, 3_000, 5_000, 10_000, 30_000]);
 const SYNC_LONG_POLL_MS = 30_000;
@@ -917,14 +918,23 @@ export class MatrixRuntime {
       ? target.threadId : null;
     const replyToEventId = typeof target?.replyToEventId === 'string' && isMatrixEventId(target.replyToEventId)
       ? target.replyToEventId : null;
-    const chunks = splitMessageText(text, this.#config.maxMessageLength);
+    const chunks = options.format === 'markdown'
+      ? chunkMarkdownParts(text, this.#config.maxMessageLength)
+      : splitMessageText(text, this.#config.maxMessageLength).map(plain => ({ markdown: plain, plain }));
     const providerMessageIds = [];
     for (const chunk of chunks) {
-      const content = buildMatrixTextContent({
-        text: chunk,
-        mentionUserIds: extractOutboundMentions(chunk),
-        roomMention: this.#config.allowRoomMentions && hasRoomMention(chunk),
-      });
+      let content;
+      try {
+        content = buildMatrixTextContent({
+          text: chunk.markdown,
+          mentionUserIds: extractOutboundMentions(chunk.markdown),
+          roomMention: this.#config.allowRoomMentions && hasRoomMention(chunk.markdown),
+        });
+      } catch {
+        this.#logger.warn?.('[dsh-im:matrix] Rich text could not be prepared; sending plain text');
+        if (!chunk.plain) continue;
+        content = { msgtype: 'm.text', body: chunk.plain };
+      }
       applyMatrixRelations(content, { threadId, replyToEventId });
       const result = await this.#sendRoomEvent(roomId, 'm.room.message', content, {
         ...(options.signal ? { signal: options.signal } : {}),