@xmanrui/dsh-im 4.8.0 → 4.9.1

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

@@ -12,6 +12,11 @@ import {
 } from '../shared/connection-test.mjs';
 import { t } from '../shared/i18n.mjs';
 import { publicMessageFailure } from '../shared/message-failure.mjs';
+import {
+  describeDingtalkConnectionFailure,
+  dingtalkPublicConnectionError,
+  dingtalkRuntimeStartError,
+} from './connection-error.mjs';
 
 const ACTIVE_ATTEMPT_STATES = new Set(['starting', 'pending', 'connecting']);
 const TERMINAL_ATTEMPT_STATES = new Set(['connected', 'expired', 'failed', 'cancelled']);
@@ -216,12 +221,14 @@ export class DingtalkController {
         try {
           await this.#startRuntime(latest, clientSecret);
           this.#errors.delete(latest.botId);
-        } catch {
-          this.#errors.set(
-            latest.botId,
-            safeError('connection-failed', t('钉钉连接未就绪，请稍后重试。')),
-          );
-          this.#logger.warn?.(`[dsh-dingtalk] bot ${latest.botId} failed to initialize`);
+        } catch (error) {
+          this.#rememberConnectionFailure({
+            config: latest,
+            clientSecret,
+            error,
+            fallbackMessage: '钉钉连接未就绪，请稍后重试。',
+            context: `bot ${latest.botId} failed to initialize`,
+          });
         }
         this.#touch();
       });
@@ -318,12 +325,14 @@ export class DingtalkController {
       try {
         await this.#startRuntime(config, normalizedSecret);
         this.#errors.delete(identity.botId);
-      } catch {
-        this.#errors.set(
-          identity.botId,
-          safeError('connection-failed', t('钉钉已接入，但消息连接暂未就绪，请稍后重试。')),
-        );
-        this.#logger.warn?.('[dsh-dingtalk] credential-bound bot saved but its connection is not ready');
+      } catch (error) {
+        this.#rememberConnectionFailure({
+          config,
+          clientSecret: normalizedSecret,
+          error,
+          fallbackMessage: '钉钉已接入，但消息连接暂未就绪，请稍后重试。',
+          context: `credential-bound bot ${identity.botId} is not ready`,
+        });
       }
       this.#touch();
     });
@@ -380,11 +389,14 @@ export class DingtalkController {
         await this.#startRuntime(config, clientSecret);
         this.#errors.delete(botId);
       } catch (error) {
-        this.#errors.set(
-          botId,
-          safeError('connection-failed', t('钉钉连接仍未就绪，请稍后重试。')),
-        );
-        throw error;
+        const publicError = this.#rememberConnectionFailure({
+          config,
+          clientSecret,
+          error,
+          fallbackMessage: '钉钉连接仍未就绪，请稍后重试。',
+          context: `bot ${botId} failed to reconnect`,
+        });
+        throw dingtalkPublicConnectionError(publicError, error);
       } finally {
         this.#touch();
       }
@@ -675,11 +687,13 @@ export class DingtalkController {
           await rollback();
           throw abortError();
         }
-        this.#errors.set(
-          identity.botId,
-          safeError('connection-failed', t('钉钉已接入，但消息连接暂未就绪，请稍后重试。')),
-        );
-        this.#logger.warn?.('[dsh-dingtalk] authorized bot saved but its connection is not ready');
+        this.#rememberConnectionFailure({
+          config,
+          clientSecret,
+          error,
+          fallbackMessage: '钉钉已接入，但消息连接暂未就绪，请稍后重试。',
+          context: `authorized bot ${identity.botId} is not ready`,
+        });
       }
       return { botId: identity.botId, alreadyConnected: Boolean(previousConfig) };
     });
@@ -696,11 +710,14 @@ export class DingtalkController {
       } catch (error) {
         await this.#configStore.save(previousConfig).catch(() => undefined);
         await this.#startRuntime(previousConfig, clientSecret).catch(() => undefined);
-        this.#errors.set(
-          previousConfig.botId,
-          safeError('connection-failed', t('钉钉连接未就绪，请稍后重试。')),
-        );
-        throw error;
+        const publicError = this.#rememberConnectionFailure({
+          config: previousConfig,
+          clientSecret,
+          error,
+          fallbackMessage: '钉钉连接未就绪，请稍后重试。',
+          context: `bot ${previousConfig.botId} failed to apply updated settings`,
+        });
+        throw dingtalkPublicConnectionError(publicError, error);
       } finally {
         this.#touch();
       }
@@ -711,13 +728,21 @@ export class DingtalkController {
     if (this.#closed) throw abortError();
     await this.#stopRuntime(config.botId);
     if (this.#closed) throw abortError();
-    const runtime = await this.#createRuntime({
-      botId: config.botId,
-      config: structuredClone(config),
-      clientSecret,
-    });
+    let runtime;
+    try {
+      runtime = await this.#createRuntime({
+        botId: config.botId,
+        config: structuredClone(config),
+        clientSecret,
+      });
+    } catch (error) {
+      throw dingtalkRuntimeStartError('dingtalk-runtime-prepare-failed', error);
+    }
     if (!runtime || typeof runtime.start !== 'function' || typeof runtime.stop !== 'function') {
-      throw new TypeError('createRuntime returned an invalid DingTalk runtime');
+      throw dingtalkRuntimeStartError(
+        'dingtalk-runtime-prepare-failed',
+        new TypeError('createRuntime returned an invalid DingTalk runtime'),
+      );
     }
     if (this.#closed) {
       await runtime.stop().catch(() => undefined);
@@ -733,10 +758,30 @@ export class DingtalkController {
     } catch (error) {
       if (this.#runtimes.get(config.botId) === runtime) this.#runtimes.delete(config.botId);
       await runtime.stop().catch(() => undefined);
-      throw error;
+      throw dingtalkRuntimeStartError('dingtalk-stream-connect-failed', error);
     }
   }
 
+  #rememberConnectionFailure({
+    config,
+    clientSecret,
+    error,
+    fallbackMessage,
+    context,
+  }) {
+    const failure = describeDingtalkConnectionFailure(error, {
+      fallbackMessage,
+      clientId: config.clientId,
+      clientSecret,
+    });
+    this.#errors.set(config.botId, failure.publicError);
+    this.#logger.error?.(
+      `[dsh-dingtalk] ${context} [${failure.publicError.referenceId}]`,
+      failure.diagnostic,
+    );
+    return failure.publicError;
+  }
+
   async #stopRuntime(botId) {
     const runtime = this.#runtimes.get(botId);
     this.#runtimes.delete(botId);

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

@@ -6,6 +6,7 @@ import {
 import { sendRememberedConnectionTest } from '../shared/connection-test.mjs';
 import { t } from '../shared/i18n.mjs';
 import { captureContextEnhancement } from '../shared/context-enhancement.mjs';
+import { dingtalkRuntimeStartError } from './connection-error.mjs';
 
 function nonEmptyString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
@@ -223,10 +224,12 @@ export class DingtalkRuntime {
     this.#status.startedAt = new Date().toISOString();
     this.#status.dingtalkStreamState = 'connecting';
     this.#status.lastError = null;
+    let startStage = 'dingtalk-harness-connect-failed';
 
     try {
       await this.#harness.ensureRunning({ signal });
       this.#status.harnessReachable = true;
+      startStage = 'dingtalk-runtime-prepare-failed';
       if (typeof this.#state.removePendingSenderByStaffId === 'function') {
         for (const staffId of approvedSenderIds(this.#config)) {
           await this.#state.removePendingSenderByStaffId(staffId);
@@ -249,6 +252,7 @@ export class DingtalkRuntime {
         signal,
       });
 
+      startStage = 'dingtalk-stream-client-load-failed';
       const created = await this.#streamFactory({
         clientId: this.#config.clientId,
         clientSecret: this.#clientSecret,
@@ -266,6 +270,7 @@ export class DingtalkRuntime {
 
       const client = this.#client;
       const bridge = this.#bridge;
+      startStage = 'dingtalk-stream-listener-failed';
       client.registerCallbackListener(this.#topic, (response) => {
         if (this.#client !== client || this.#bridge !== bridge) return;
         const callbackMessageId = nonEmptyString(response?.headers?.messageId);
@@ -314,6 +319,7 @@ export class DingtalkRuntime {
         this.#callbackTasks.add(task);
       });
 
+      startStage = 'dingtalk-stream-connect-failed';
       await connectStream(
         client,
         this.#connectTimeoutMs,
@@ -336,11 +342,12 @@ export class DingtalkRuntime {
       return this.status;
     } catch (error) {
       const aborted = signal.aborted;
+      const failure = aborted ? error : dingtalkRuntimeStartError(startStage, error);
       this.#status.ready = false;
       this.#status.dingtalkStreamState = aborted ? 'idle' : 'failed';
-      this.#status.lastError = aborted ? null : (error?.message ?? String(error));
+      this.#status.lastError = aborted ? null : (failure?.message ?? String(failure));
       await this.stop({ preserveError: !aborted });
-      throw error;
+      throw failure;
     }
   }
 

package/src/channels/feishu/bridge.mjs

@@ -76,6 +76,7 @@ import {
   MENU_PAGE_SIZE,
   PRESET_FOLLOW_DEFAULT_SENTINEL,
   STEER_CUSTOM_SENTINEL,
+  approvalCard,
   completionCard,
   customSteerCard,
   helpCard,
@@ -83,6 +84,7 @@ import {
   menuHelpText,
   modelCard,
   presetCard,
+  questionCard,
   sessionListCard,
   statusCard,
   steerCard,
@@ -107,7 +109,7 @@ const WATCH_COMMAND = /^\/watch(?:\s+([^\s]+))?$/i;
 const UNWATCH_COMMAND = /^\/unwatch(?:\s+([^\s]+))?$/i;
 const WATCHLIST_COMMAND = /^\/watchlist$/i;
 const SESSION_LIST_PREFIX = /^\/(?:sessionlist|sessions)(?:\s|$)/i;
-const WORKSPACE_LIST_COMMAND = /^\/workspacelist$/i;
+const WORKSPACE_LIST_COMMAND = /^\/(?:workspacelist|workspaces|wsl)$/i;
 const NUMBER_REPLY = /^\d{1,2}$/;
 /** A displayed menu stays number-tappable for this long. */
 const MENU_TTL_MS = 10 * 60_000;
@@ -146,7 +148,34 @@ const REPAIR_URL_HOSTS = new Set([
 
 const ARCHIVED_COMMAND = /^\/archived(?:\s+(on|off))?$/i;
 /** Matches fast card commands that should not be queued behind a running task. */
-const CARD_COMMAND = /^\/(?:m(?:enu)?|new|help|status|compact|(?:sessionlist|sessions)(?:\s|$)|workspacelist|watchlist|archived(?:\s+(on|off))?)$/i;
+const CARD_COMMAND = /^\/(?:m(?:enu)?|new|help|status|compact|(?:sessionlist|sessions)(?:\s|$)|workspacelist|workspaces|wsl|watchlist|archived(?:\s+(on|off))?)$/i;
+
+/** Pretty-print a tool call's arguments for an approval card. */
+function operationArguments(toolCall) {
+  const source = toolCall?.arguments;
+  if (source !== null && typeof source === 'object') {
+    try {
+      return JSON.stringify(source, null, 2);
+    } catch {
+      return null;
+    }
+  }
+  if (typeof source !== 'string') return null;
+  const raw = printableText(source);
+  // Harness treats an empty tool argument string as an empty object.
+  if (!raw) return source === '' ? '{}' : null;
+  try {
+    return JSON.stringify(JSON.parse(raw), null, 2);
+  } catch {
+    return raw;
+  }
+}
+
+/** Strip control characters so the approval card text stays clean. */
+function printableText(value) {
+  return String(value ?? '')
+    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, '');
+}
 
 function isFeishuLocalCommand(text, { hasImages = false, hasFiles = false } = {}) {
   if (hasImages || hasFiles || typeof text !== 'string') return false;
@@ -471,6 +500,8 @@ export class FeishuHarnessBridge {
   /** Earliest completion that still needs delivery for each watch. */
   #failedWatchSeqs = new Map();
   #cardDataTimeoutMs;
+  /** When true, approval/question interactions render as Feishu cards (buttons). */
+  #interactionCards = true;
 
   constructor({
     client,
@@ -490,6 +521,7 @@ export class FeishuHarnessBridge {
     repairLinkWaitMs = REPAIR_LINK_WAIT_MS,
     cardDataTimeoutMs = CARD_DATA_TIMEOUT_MS,
     replyTimeoutMs = 600_000,
+    interactionCards = true,
     logger = console,
     signal,
   }) {
@@ -528,6 +560,7 @@ export class FeishuHarnessBridge {
     this.#repairLinkWaitMs = repairLinkWaitMs;
     this.#cardDataTimeoutMs = cardDataTimeoutMs;
     this.#replyTimeoutMs = replyTimeoutMs;
+    this.#interactionCards = interactionCards === true;
     this.#logger = logger;
     this.#approvals = new HarnessApprovalQueue({ label: 'Feishu', logger });
     this.#signal = signal;
@@ -1644,10 +1677,15 @@ export class FeishuHarnessBridge {
     }
     const conversationType = route.key.startsWith('p2p:') ? 'direct'
       : route.key.startsWith('group:') ? 'group' : null;
+    const isInteractionResponse = resolvedAction.startsWith('approve:')
+      || resolvedAction.startsWith('reject:')
+      || resolvedAction.startsWith('answer:');
     const access = evaluateInboundAccess(this.#accessPolicy, {
       conversationType,
       senderIds: operatorOpenId,
-      isCommand: true,
+      // These buttons are the card equivalent of an ordinary approval or
+      // question reply. Every other card action remains command-gated.
+      isCommand: !isInteractionResponse,
     });
     if (!access.allowed) {
       if (access.reason === 'command-not-allowed') {
@@ -1710,7 +1748,7 @@ export class FeishuHarnessBridge {
           return;
         }
       }
-      await this.#handleCardAction(resolvedAction, entry);
+      await this.#handleCardAction(resolvedAction, { ...entry, actor: entry.operatorOpenId });
     }, {
       lane: isStop || isRealSteer ? 'control' : 'regular',
       coalesceStop: isStop,
@@ -1868,10 +1906,49 @@ export class FeishuHarnessBridge {
     sessionPage = 0,
     sessionLimit = null,
     selections = [],
+    actor = null,
   }) {
     // Confirmations triggered by a card interaction stay anchored to the
     // card's message so they land inside the same Feishu topic.
     const reply = (text) => this.#send(chatId, text, { replyTo: messageId });
+    // Approval card buttons: approve:<approvalId> / reject:<approvalId>
+    if (action.startsWith('approve:') || action.startsWith('reject:')) {
+      const sep = action.indexOf(':');
+      const approvalId = action.slice(sep + 1);
+      const outcome = action.startsWith('approve:') ? 'allowed-once' : 'rejected';
+      // Bind the decision to the operator so another allowed group member
+      // cannot decide someone else's approval.
+      const submitted = await this.#approvals.submitByApprovalId(approvalId, outcome, { actor });
+      if (!submitted) {
+        await reply(t('该审批已处理或不存在，无需重复操作。')).catch(() => undefined);
+      }
+      return;
+    }
+    // Question option buttons: answer:<interactionId>:<index>:<optionLabel>
+    if (action.startsWith('answer:')) {
+      const rest = action.slice('answer:'.length);
+      const firstSep = rest.indexOf(':');
+      if (firstSep !== -1) {
+        const interactionId = rest.slice(0, firstSep);
+        const afterId = rest.slice(firstSep + 1);
+        const indexSep = afterId.indexOf(':');
+        const indexText = indexSep === -1 ? afterId : afterId.slice(0, indexSep);
+        const optionLabel = indexSep === -1 ? '' : afterId.slice(indexSep + 1);
+        const qKey = this.#interactionKeys.get(interactionId);
+        const pending = qKey ? this.#pendingInteractions.get(qKey) : null;
+        // Only the actor who started the interaction may answer it, and the
+        // card must still target the current question (a stale card from an
+        // earlier question in a multi-question interaction must not submit).
+        if (pending && pending.kind === 'question' && !pending.submitting
+          && pending.actor === actor
+          && Number(indexText) === pending.index) {
+          await this.#submitQuestionAnswer(pending, optionLabel, { chatId });
+        } else {
+          await reply(INTERACTION_RESOLVED_TEXT()).catch(() => undefined);
+        }
+      }
+      return;
+    }
     if (action === 'sessions' || /^sessions:\d+$/.test(action)) {
       const page = action === 'sessions' ? 0 : Number(action.slice('sessions:'.length));
       await this.#showSessions(
@@ -3585,7 +3662,18 @@ export class FeishuHarnessBridge {
     const question = pending.questions[pending.index];
     if (!question) return;
 
-    pending.answers.push(harnessAnswerForQuestion(question, text));
+    await this.#submitQuestionAnswer(pending, text, {
+      chatId: event.message.chat_id,
+      messageId,
+    });
+  }
+
+  async #submitQuestionAnswer(pending, answerText, { chatId, messageId } = {}) {
+    const question = pending.questions[pending.index];
+    if (!question) return;
+    pending.chatId = chatId ?? pending.chatId;
+
+    pending.answers.push(harnessAnswerForQuestion(question, answerText));
     pending.index += 1;
     if (pending.index < pending.questions.length) {
       if (pending.claimedReplyMessageId === messageId) {
@@ -3603,6 +3691,7 @@ export class FeishuHarnessBridge {
     }
 
     pending.submitting = true;
+    const key = pending.key;
     try {
       await pending.interaction.respond({
         ok: true,
@@ -3620,7 +3709,9 @@ export class FeishuHarnessBridge {
       if (error?.code === 'interaction-not-pending') {
         this.#rememberResolvedInteraction(key, pending);
         this.#clearPendingInteraction(key, pending.interactionId);
-        await this.#send(event.message.chat_id, INTERACTION_RESOLVED_TEXT(), { replyTo: event.message.message_id }).catch(() => undefined);
+        if (chatId && messageId) {
+          await this.#send(chatId, INTERACTION_RESOLVED_TEXT(), { replyTo: messageId }).catch(() => undefined);
+        }
         return;
       }
       pending.submitting = false;
@@ -3628,8 +3719,10 @@ export class FeishuHarnessBridge {
       pending.index -= 1;
       this.#status.lastError = '回答提交失败。';
       this.#logger.error?.('[dsh-feishu] failed to answer a Harness interaction');
-      await this.#send(event.message.chat_id, t('回答提交失败，请重新发送当前问题的答案。'))
-        .catch(() => undefined);
+      if (chatId) {
+        await this.#send(chatId, t('回答提交失败，请重新发送当前问题的答案。'))
+          .catch(() => undefined);
+      }
     }
   }
 
@@ -3645,6 +3738,32 @@ export class FeishuHarnessBridge {
       actor,
       requiresMention,
       send: (text) => this.#send(chatId, text, { replyTo: replyToMessageId }),
+      // 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.
+      ...(this.#interactionCards
+        ? {
+            render: async (pending) => {
+              // Show the approval as an interactive card with approve/reject buttons.
+              await this.#sendCard(
+                chatId,
+                approvalCard({
+                  toolName: pending.toolCall?.name ?? pending.payload?.toolName,
+                  operation: operationArguments(pending.toolCall),
+                  reason: pending.payload?.reason,
+                  approvalId: pending.approvalId,
+                }),
+                { key, replyTo: replyToMessageId },
+              ).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 });
+              });
+            },
+          }
+        : {}),
     })) return;
 
     // Approval requests return above; the existing question state machine stays unchanged.
@@ -3738,18 +3857,53 @@ export class FeishuHarnessBridge {
   async #presentInteraction(pending) {
     const question = pending.questions[pending.index];
     if (!question) return;
-    const messageId = await this.#send(
-      pending.chatId,
-      harnessQuestionText(
-        question,
-        pending.index,
-        pending.questions.length,
-        { requiresMention: pending.requiresMention },
-      ),
-      // Reply to the message that started the turn so the question lands in
-      // the same Feishu thread/topic instead of the group's default area.
-      { replyTo: pending.replyToMessageId },
-    );
+    const options = Array.isArray(question?.options) ? question.options : [];
+    // Single-choice questions with options render as interactive cards by
+    // default. Multi-select or free-text questions and the text reply flow
+    // remain when `interactionCards` is disabled (or DSH_IM_INTERACTION_CARDS=0).
+    const interactive = this.#interactionCards
+      && options.length > 0
+      && question.multiSelect !== true;
+    let messageId;
+    if (interactive) {
+      // Single-choice question with options: render each option as a button.
+      messageId = await this.#sendCard(
+        pending.chatId,
+        questionCard({
+          interactionId: pending.interactionId,
+          header: question.header,
+          question: question.question,
+          detail: question.detail,
+          options,
+          index: pending.index,
+          total: pending.questions.length,
+        }),
+        { key: pending.key, replyTo: pending.replyToMessageId },
+      ).catch(async () => {
+        // Fall back to the plain-text question if the card cannot be sent.
+        // If the text send also fails, let the error propagate so the pending
+        // question is not marked as presented and the existing retry logic runs.
+        return this.#send(
+          pending.chatId,
+          harnessQuestionText(question, pending.index, pending.questions.length, {
+            requiresMention: pending.requiresMention,
+          }),
+          { replyTo: pending.replyToMessageId },
+        );
+      });
+    } else {
+      // Multi-select or free-text questions keep the plain-text reply flow.
+      messageId = await this.#send(
+        pending.chatId,
+        harnessQuestionText(
+          question,
+          pending.index,
+          pending.questions.length,
+          { requiresMention: pending.requiresMention },
+        ),
+        { replyTo: pending.replyToMessageId },
+      );
+    }
     if (messageId) {
       pending.questionMessageIds.add(messageId);
       if (pending.inactive) this.#rememberResolvedInteraction(pending.key, pending);

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

@@ -492,6 +492,7 @@ export function menuHelpText() {
     '/session ID  绑定已有会话',
     '/workspacelist  列出工作区',
     '/workspace 工作区序号或绝对路径  切换工作区',
+    '/ws、/wsl、/workspaces  工作区命令别名',
     '/new  开启全新会话',
     '',
     '📊 状态 / 压缩',
@@ -595,6 +596,7 @@ export function helpCard(extraTextLines = []) {
     { tag: 'hr' },
     { tag: 'div', text: markdown([
       t(HELP_TEXT_COMMANDS),
+      t('/ws、/wsl、/workspaces  工作区命令别名'),
       t('`/version` — 查看插件版本'),
       t('/history [数量]  查看最近历史消息（默认 3 条，最多 5 条）'),
     ].join('\n') + extraText) },
@@ -867,3 +869,70 @@ export function customSteerCard() {
   ];
   return cardWith(t('➕ 自定义指令'), elements);
 }
+
+/**
+ * Interactive approval card with approve / reject buttons. Action values carry
+ * the approvalId so the card callback can submit the decision:
+ *   approve:<approvalId>  /  reject:<approvalId>
+ * `requiresMention` is advisory; a button click is itself the operator's
+ * explicit intent, so it does not need an @ mention in groups.
+ */
+export function approvalCard({ toolName, operation, reason, approvalId }) {
+  const elements = [];
+  if (toolName) {
+    elements.push({ tag: 'div', text: markdown(t('工具：{tool}', { tool: String(toolName) })) });
+  }
+  if (operation) {
+    // Cap the operation text so an oversized argument list cannot overflow the
+    // card (the plain-text path rejects >6000 chars; here we truncate so the
+    // approve/reject buttons still render).
+    const MAX_OPERATION_CHARS = 6_000;
+    const op = String(operation);
+    const shown = op.length > MAX_OPERATION_CHARS
+      ? `${op.slice(0, MAX_OPERATION_CHARS)}\n…（操作参数过长，已截断）`
+      : op;
+    elements.push({ tag: 'div', text: markdown(t('操作参数：\n{operation}', { operation: shown })) });
+  }
+  if (reason) {
+    elements.push({ tag: 'div', text: markdown(t('原因：{reason}', { reason: String(reason) })) });
+  }
+  elements.push(
+    { tag: 'hr' },
+    buttonPair(t('✅ 批准'), `approve:${approvalId}`, t('❌ 拒绝'), `reject:${approvalId}`),
+  );
+  return cardWith(t('🔐 工具审批'), elements);
+}
+
+/**
+ * Interactive question card. When the question carries options, each option is
+ * rendered as its own button; the selected option label is submitted via a
+ * card callback. Multi-select questions fall back to the plain-text flow (the
+ * caller decides), because a multi-select needs a confirm step.
+ * Action: answer:<interactionId>:<optionLabel>
+ */
+export function questionCard({ interactionId, header, question, detail, options, index, total }) {
+  const elements = [];
+  const progress = total > 1 ? `（${index + 1}/${total}）` : '';
+  if (header) elements.push({ tag: 'div', text: markdown(String(header)) });
+  const qText = typeof question === 'string' && question.trim() ? question : t('请输入你的回答。');
+  elements.push({ tag: 'div', text: markdown(String(qText)) });
+  if (detail) elements.push({ tag: 'div', text: markdown(String(detail)) });
+
+  if (Array.isArray(options) && options.length > 0) {
+    elements.push({ tag: 'hr' });
+    for (const option of options) {
+      const label = typeof option?.label === 'string' ? option.label : '';
+      if (!label) continue;
+      const description = typeof option?.description === 'string' && option.description.trim()
+        ? option.description.trim()
+        : '';
+      // Include the option description in the button so the user sees the full
+      // meaning (mirrors the text form "1. label — description").
+      const buttonText = description ? `${label}\n${description}` : label;
+      // Action carries the question index so a stale card from a previous
+      // question cannot be applied to the current one: answer:<interactionId>:<index>:<label>
+      elements.push(button(buttonText, `answer:${interactionId}:${index}:${label}`));
+    }
+  }
+  return cardWith(t('❓ 请补充信息{progress}', { progress }), elements);
+}

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

@@ -288,6 +288,11 @@ export class FeishuRuntime {
         groupResponseMode: this.#groupResponseMode,
         repair: this.#repair,
         replyTimeoutMs: this.#replyTimeoutMs,
+        // Interaction cards (approval/question buttons) are on by default.
+        // Set DSH_IM_INTERACTION_CARDS=0 to fall back to plain-text replies.
+        interactionCards: !['0', 'false', 'no', 'off'].includes(
+          String(process.env.DSH_IM_INTERACTION_CARDS ?? '').trim().toLowerCase(),
+        ),
         signal,
         logger: this.#logger,
       });

package/src/channels/feishu/slash-command-registry.mjs

@@ -43,6 +43,9 @@ export const SLASH_COMMAND_MANIFEST = Object.freeze([
   { command: 'compact', icon: 'ai-block_outlined', default: '压缩当前会话上下文', en_us: 'Compact the current session' },
   { command: 'sessionlist', icon: 'chat-ai_outlined', default: '列出会话', en_us: 'List sessions' },
   { command: 'workspacelist', icon: 'folder_outlined', default: '列出工作区', en_us: 'List workspaces' },
+  { command: 'workspaces', icon: 'folder_outlined', default: '列出工作区', en_us: 'List workspaces' },
+  { command: 'wsl', icon: 'folder_outlined', default: '列出工作区', en_us: 'List workspaces' },
+  { command: 'ws', icon: 'folder_outlined', default: '切换工作区', en_us: 'Switch workspace' },
   { command: 'watch', icon: 'flag_outlined', default: '关注一个会话', en_us: 'Watch a session' },
   { command: 'unwatch', icon: 'clear_outlined', default: '取消关注会话', en_us: 'Unwatch a session' },
   { command: 'watchlist', icon: 'flag_outlined', default: '查看关注列表', en_us: 'List watched sessions' },

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

@@ -90,6 +90,7 @@ function helpText() {
     t('/history [数量]  查看最近历史消息（默认 3 条，最多 5 条）'),
     t('/workspace 工作区序号或绝对路径  切换工作区'),
     t('/workspacelist  列出工作区绝对路径'),
+    t('/ws、/wsl、/workspaces  工作区命令别名'),
     t('/sessionlist 或 /sessions [工作区序号或绝对路径]  列出会话 ID 和标题'),
     t('/sessionlist --limit N  仅列出当前工作区前 N 个会话'),
     t('/session Session ID 或当前工作区序号  将当前聊天绑定到指定会话'),