@xmanrui/dsh-im 4.0.0 → 4.1.0

package/plugin-src/host/delivery-service.mjs

@@ -0,0 +1,224 @@
+import { normalizeDeliveryTarget } from './delivery-adapter.mjs';
+
+const BOT_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+const TARGET_ID_PATTERN = /^[A-Za-z0-9._:@-]{1,128}$/;
+const CHANNEL_PATTERN = /^[a-z][a-z0-9-]{0,31}$/;
+const DRAFT_TARGET_ID = '__test__';
+
+const ADAPTER_METHODS = Object.freeze([
+  'ownsBot',
+  'listTargets',
+  'listSuggestions',
+  'createTarget',
+  'updateTarget',
+  'deleteTarget',
+  'sendText',
+]);
+
+const DELIVERY_ERROR_CODES = new Set([
+  'bad-request',
+  'unknown-bot',
+  'unknown-target',
+  'target-conflict',
+  'invalid-target',
+  'bot-not-connected',
+  'target-rejected',
+  'delivery-failed',
+  'cancelled',
+]);
+
+function deliveryError(code, message = code, options) {
+  const error = new Error(message, options);
+  error.code = code;
+  return error;
+}
+
+function botIdOf(value) {
+  if (typeof value !== 'string' || !BOT_ID_PATTERN.test(value)) {
+    throw deliveryError('bad-request', 'Invalid bot id');
+  }
+  return value;
+}
+
+function targetIdOf(value) {
+  if (typeof value !== 'string' || !TARGET_ID_PATTERN.test(value)) {
+    throw deliveryError('bad-request', 'Invalid target id');
+  }
+  return value;
+}
+
+function targetObject(value, { includesTargetId } = {}) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw deliveryError('bad-request', 'Invalid target');
+  }
+  if (includesTargetId) targetIdOf(value.targetId);
+  else if (Object.hasOwn(value, 'targetId')) {
+    throw deliveryError('bad-request', 'A target id cannot be changed');
+  }
+  return value;
+}
+
+function draftTargetObject(value) {
+  targetObject(value);
+  const keys = Object.keys(value);
+  if (keys.length !== 2 || !keys.includes('kind') || !keys.includes('route')) {
+    throw deliveryError('bad-request', 'Invalid draft target');
+  }
+  return value;
+}
+
+function cancellation(signal) {
+  if (signal?.aborted) throw deliveryError('cancelled', 'Request cancelled');
+}
+
+function publicOperationError(error, fallback = 'delivery-failed') {
+  if (error?.code === 'workspace-bot-not-found') {
+    return deliveryError('unknown-bot', 'Unknown bot', { cause: error });
+  }
+  if (DELIVERY_ERROR_CODES.has(error?.code)) return error;
+  return deliveryError(fallback, fallback, { cause: error });
+}
+
+function validateAdapter(adapter) {
+  if (!adapter || typeof adapter !== 'object'
+    || typeof adapter.channel !== 'string' || !CHANNEL_PATTERN.test(adapter.channel)) {
+    throw new TypeError('A delivery adapter with a valid channel is required');
+  }
+  for (const method of ADAPTER_METHODS) {
+    if (typeof adapter[method] !== 'function') {
+      throw new TypeError(`A complete delivery adapter is required (${method})`);
+    }
+  }
+  return adapter;
+}
+
+export class DeliveryService {
+  #adapters = new Map();
+
+  registerAdapter(value) {
+    const adapter = validateAdapter(value);
+    const registration = Object.freeze({ adapter });
+    this.#adapters.set(adapter.channel, registration);
+    return () => {
+      if (this.#adapters.get(adapter.channel) !== registration) return false;
+      this.#adapters.delete(adapter.channel);
+      return true;
+    };
+  }
+
+  async listTargets(botId) {
+    const id = botIdOf(botId);
+    const adapter = await this.#adapterFor(id);
+    try {
+      const targets = await adapter.listTargets(id);
+      if (!Array.isArray(targets)) throw new TypeError('Adapter returned invalid targets');
+      return { botId: id, channel: adapter.channel, targets };
+    } catch (error) {
+      throw publicOperationError(error);
+    }
+  }
+
+  async listSuggestions(botId) {
+    const id = botIdOf(botId);
+    const adapter = await this.#adapterFor(id);
+    try {
+      const suggestions = await adapter.listSuggestions(id);
+      if (!Array.isArray(suggestions)) throw new TypeError('Adapter returned invalid suggestions');
+      return {
+        botId: id,
+        channel: adapter.channel,
+        suggestions: suggestions.map((suggestion) => normalizeDeliveryTarget(
+          adapter.channel,
+          suggestion,
+          { targetIdRequired: false },
+        )),
+      };
+    } catch (error) {
+      throw publicOperationError(error);
+    }
+  }
+
+  async createTarget(botId, target) {
+    const id = botIdOf(botId);
+    targetObject(target, { includesTargetId: true });
+    const adapter = await this.#adapterFor(id);
+    try {
+      return await adapter.createTarget(id, target);
+    } catch (error) {
+      throw publicOperationError(error);
+    }
+  }
+
+  async updateTarget(botId, targetId, replacement) {
+    const id = botIdOf(botId);
+    const targetKey = targetIdOf(targetId);
+    targetObject(replacement);
+    const adapter = await this.#adapterFor(id);
+    try {
+      return await adapter.updateTarget(id, targetKey, replacement);
+    } catch (error) {
+      throw publicOperationError(error);
+    }
+  }
+
+  async deleteTarget(botId, targetId) {
+    const id = botIdOf(botId);
+    const targetKey = targetIdOf(targetId);
+    const adapter = await this.#adapterFor(id);
+    try {
+      await adapter.deleteTarget(id, targetKey);
+      return { deleted: true };
+    } catch (error) {
+      throw publicOperationError(error);
+    }
+  }
+
+  async send(botId, targetIdOrDraft, text, { signal } = {}) {
+    const id = botIdOf(botId);
+    const targetKey = typeof targetIdOrDraft === 'string'
+      ? targetIdOf(targetIdOrDraft)
+      : null;
+    const draft = targetKey === null ? draftTargetObject(targetIdOrDraft) : null;
+    if (typeof text !== 'string' || !text.trim()) {
+      throw deliveryError('bad-request', 'Message text is required');
+    }
+    cancellation(signal);
+    const adapter = await this.#adapterFor(id);
+    try {
+      let target;
+      if (draft) {
+        target = { targetId: DRAFT_TARGET_ID, ...draft };
+      } else {
+        const targets = await adapter.listTargets(id);
+        if (!Array.isArray(targets)) throw new TypeError('Adapter returned invalid targets');
+        target = targets.find((candidate) => candidate?.targetId === targetKey);
+        if (!target) throw deliveryError('unknown-target', 'Unknown target');
+      }
+      cancellation(signal);
+      await adapter.sendText(id, target, text, { signal });
+      return { sent: true };
+    } catch (error) {
+      if (signal?.aborted || error?.name === 'AbortError' || error?.code === 'ABORT_ERR') {
+        throw deliveryError('cancelled', 'Request cancelled', { cause: error });
+      }
+      throw publicOperationError(error);
+    }
+  }
+
+  async #adapterFor(botId) {
+    for (const { adapter } of this.#adapters.values()) {
+      let ownsBot;
+      try {
+        ownsBot = await adapter.ownsBot(botId);
+      } catch (error) {
+        throw publicOperationError(error);
+      }
+      if (ownsBot) return adapter;
+    }
+    throw deliveryError('unknown-bot', 'Unknown bot');
+  }
+}
+
+export function createDeliveryService() {
+  return new DeliveryService();
+}

package/plugin-src/host/delivery-suggestions.mjs

@@ -0,0 +1,135 @@
+const CHANNELS = new Set([
+  'weixin',
+  'feishu',
+  'dingtalk',
+  'wecom',
+  'qq',
+  'slack',
+  'telegram',
+  'discord',
+  'whatsapp',
+]);
+
+function isRecord(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function opaqueId(value) {
+  return typeof value === 'string'
+    && value.length > 0
+    && value.length <= 512
+    && value.trim() === value
+    && !/[\s:\u0000-\u001f\u007f]/u.test(value);
+}
+
+function afterPrefix(key, prefix) {
+  const marker = `${prefix}:`;
+  if (!key.startsWith(marker)) return null;
+  const value = key.slice(marker.length);
+  return opaqueId(value) ? value : null;
+}
+
+function simpleSuggestion(key, definitions) {
+  for (const [prefix, kind, field] of definitions) {
+    const value = afterPrefix(key, prefix);
+    if (value) return { kind, route: { [field]: value } };
+  }
+  return null;
+}
+
+function feishuSuggestion(key) {
+  const openId = afterPrefix(key, 'p2p');
+  if (openId?.startsWith('ou_')) {
+    return { kind: 'user', route: { openId } };
+  }
+  return simpleSuggestion(key, [['group', 'group', 'chatId']]);
+}
+
+function slackSuggestion(key) {
+  const directChannel = afterPrefix(key, 'direct');
+  if (directChannel && /^[A-Za-z0-9_-]{1,128}$/.test(directChannel)) {
+    return { kind: 'conversation', route: { channelId: directChannel } };
+  }
+  const match = /^group:([^:]+):(\d{1,20}(?:\.\d{1,20})?)$/.exec(key);
+  if (!match || !/^[A-Za-z0-9_-]{1,128}$/.test(match[1])) return null;
+  return { kind: 'thread', route: { channelId: match[1], threadTs: match[2] } };
+}
+
+function telegramSuggestion(key) {
+  const match = /^(direct|group):(-?\d+)(?::([1-9]\d*))?$/.exec(key);
+  if (!match) return null;
+  const chatId = Number(match[2]);
+  if (!Number.isSafeInteger(chatId)) return null;
+  if (match[1] === 'direct' && match[3] !== undefined) return null;
+  if (match[3] === undefined) return { kind: 'chat', route: { chatId: match[2] } };
+  const messageThreadId = Number(match[3]);
+  if (!Number.isSafeInteger(messageThreadId) || messageThreadId <= 0) return null;
+  return { kind: 'topic', route: { chatId: match[2], messageThreadId } };
+}
+
+function discordSuggestion(key) {
+  const match = /^(?:direct|group):(\d{1,32})$/.exec(key);
+  return match ? { kind: 'channel', route: { channelId: match[1] } } : null;
+}
+
+function whatsappSuggestion(key) {
+  const direct = /^direct:(\d{5,32}@(s\.whatsapp\.net|lid))$/.exec(key);
+  if (direct) return { kind: 'user', route: { jid: direct[1] } };
+  const group = /^group:(\d{5,32}(?:-\d{1,32})?@g\.us)$/.exec(key);
+  return group ? { kind: 'group', route: { jid: group[1] } } : null;
+}
+
+/** Convert one persisted conversation key into a stable proactive-delivery route. */
+export function deliverySuggestionFromConversationKey(channel, key) {
+  if (!CHANNELS.has(channel) || typeof key !== 'string') return null;
+  switch (channel) {
+    case 'weixin':
+      return simpleSuggestion(key, [['p2p', 'user', 'toUserId']]);
+    case 'feishu':
+      return feishuSuggestion(key);
+    case 'dingtalk':
+      return simpleSuggestion(key, [
+        ['p2p', 'user', 'userId'],
+        ['group', 'group', 'openConversationId'],
+      ]);
+    case 'wecom':
+      return simpleSuggestion(key, [
+        ['direct', 'user', 'chatId'],
+        ['group', 'group', 'chatId'],
+      ]);
+    case 'qq':
+      return simpleSuggestion(key, [
+        ['c2c', 'user', 'userOpenId'],
+        ['group', 'group', 'groupOpenId'],
+      ]);
+    case 'slack':
+      return slackSuggestion(key);
+    case 'telegram':
+      return telegramSuggestion(key);
+    case 'discord':
+      return discordSuggestion(key);
+    case 'whatsapp':
+      return whatsappSuggestion(key);
+    default:
+      return null;
+  }
+}
+
+/**
+ * Extract and de-duplicate stable delivery routes from a persisted sessions map.
+ * Session ids and every other state field are intentionally ignored.
+ */
+export function deliverySuggestionsFromSessions(channel, sessions) {
+  if (!CHANNELS.has(channel) || !isRecord(sessions)) return [];
+  const suggestions = [];
+  const seen = new Set();
+  for (const key of Object.keys(sessions)) {
+    const suggestion = deliverySuggestionFromConversationKey(channel, key);
+    if (!suggestion) continue;
+    const identity = JSON.stringify(suggestion);
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+    suggestions.push(suggestion);
+  }
+  return suggestions;
+}

package/plugin-src/host/index.mjs

@@ -10,6 +10,9 @@ import { apply as applyWeixin } from './channels/weixin/index.mjs';
 import { apply as applyWhatsapp } from './channels/whatsapp/index.mjs';
 import { installOutboundArtifactTool } from '../../src/channels/shared/semantic/artifact.mjs';
 import { setImHostLanguage } from '../../src/channels/shared/i18n.mjs';
+import { installDeliveryRpc } from './delivery-rpc.mjs';
+import { installDeliveryHttp } from './delivery-http.mjs';
+import { createDeliveryService } from './delivery-service.mjs';
 import { installUpdateRpc } from './update-rpc.mjs';
 
 export const name = 'dsh-im-host';
@@ -19,15 +22,19 @@ export const inject = [
   'typertGateway',
 ];
 
-function channelConfig(config, name) {
+function channelConfig(config, name, deliveryService) {
   const channel = config[name] ?? {};
-  return config.rpcAuthority === undefined
+  const withAuthority = config.rpcAuthority === undefined
     ? channel
     : { ...channel, rpcAuthority: config.rpcAuthority };
+  return name === 'office' ? withAuthority : { ...withAuthority, deliveryService };
 }
 
 export function createImHostPlugin(internals = {}) {
   const startUpdate = internals.installUpdateRpc ?? installUpdateRpc;
+  const startDelivery = internals.installDeliveryRpc ?? installDeliveryRpc;
+  const startDeliveryHttp = internals.installDeliveryHttp ?? installDeliveryHttp;
+  const makeDeliveryService = internals.createDeliveryService ?? createDeliveryService;
   const startFeishu = internals.applyFeishu ?? applyFeishu;
   const startWeixin = internals.applyWeixin ?? applyWeixin;
   const startDingtalk = internals.applyDingtalk ?? applyDingtalk;
@@ -54,8 +61,17 @@ export function createImHostPlugin(internals = {}) {
     name,
     inject,
     async apply(ctx, config = {}) {
+      const deliveryService = makeDeliveryService();
+      if (typeof ctx?.provide === 'function') {
+        ctx.provide('dshIm', Object.freeze({
+          send: (botId, targetId, text, options) => (
+            deliveryService.send(botId, targetId, text, options)
+          ),
+          listTargets: async (botId) => (await deliveryService.listTargets(botId)).targets,
+        }));
+      }
       const activate = async (readyCtx) => {
-        await activateChannels(readyCtx, config);
+        await activateChannels(readyCtx, config, deliveryService);
       };
       if (typeof ctx?.inject === 'function') {
         const modern = typeof ctx?.typertGateway?.stream === 'function';
@@ -63,13 +79,19 @@ export function createImHostPlugin(internals = {}) {
           modern ? ['sessionController', 'workspaceController'] : ['apiProxy'],
           activate,
         );
+        ctx.inject(['webServer'], (httpCtx) => {
+          startDeliveryHttp(httpCtx, deliveryService);
+        });
         return;
       }
       await activate(ctx);
+      if (ctx?.webServer?.register && typeof ctx?.effect === 'function') {
+        startDeliveryHttp(ctx, deliveryService);
+      }
     },
   });
 
-  async function activateChannels(ctx, config) {
+  async function activateChannels(ctx, config, deliveryService) {
     setImHostLanguage(config.language ?? process.env.DSH_IM_LANGUAGE);
     if (typeof ctx?.inject === 'function') {
       ctx.inject(['tools', 'systemPrompt'], (artifactCtx) => {
@@ -87,11 +109,16 @@ export function createImHostPlugin(internals = {}) {
       } catch (error) {
         logger.error?.('[dsh-im] failed to activate update management; continuing with channels', error);
       }
+      try {
+        startDelivery(ctx, deliveryService, { authority: config.rpcAuthority });
+      } catch (error) {
+        logger.error?.('[dsh-im] failed to activate delivery management; continuing with channels', error);
+      }
     }
     const failures = [];
     for (const [channel, start] of channels) {
       try {
-        await start(ctx, channelConfig(config, channel));
+        await start(ctx, channelConfig(config, channel, deliveryService));
       } catch (error) {
         failures.push(error);
         logger.error?.(`[dsh-im] failed to activate ${channel}; continuing with the remaining channels`, error);

package/scripts/verify-package.mjs

@@ -24,6 +24,9 @@ const required = [
   'bin/dsh-im.mjs',
   'cordis.patch.yml',
   'README.md',
+  'README.en.md',
+  'PROACTIVE_DELIVERY.md',
+  'PROACTIVE_DELIVERY.en.md',
   'THIRD_PARTY_NOTICES.md',
   'plugin-src/client/channels/dingtalk/index.js',
   'plugin-src/client/channels/slack/index.js',

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

@@ -1049,6 +1049,39 @@ export function createDingtalkApi({
       return true;
     },
 
+    async sendRobotText({ clientId, clientSecret, target, text, signal }) {
+      if (typeof text !== 'string' || !text.trim()) throw new TypeError('text is required');
+      const content = text;
+      const normalizedTarget = normalizeFileTarget(target);
+      const token = await accessToken({ clientId, clientSecret, signal });
+      const body = {
+        robotCode: normalizedTarget.robotCode,
+        msgKey: 'sampleText',
+        msgParam: JSON.stringify({ content }),
+        ...(normalizedTarget.type === 'group'
+          ? { openConversationId: normalizedTarget.openConversationId }
+          : { userIds: [normalizedTarget.userId] }),
+      };
+      const pathname = normalizedTarget.type === 'group'
+        ? 'v1.0/robot/groupMessages/send'
+        : 'v1.0/robot/oToMessages/batchSend';
+      const response = await requestJson(fetchImpl, endpoint(apiBase, pathname), {
+        body,
+        headers: { 'x-acs-dingtalk-access-token': token },
+        signal,
+        action: '主动文字消息发送',
+      });
+      const rejection = rejectedProviderResponse(response);
+      if (rejection) {
+        throw new DingtalkApiError(
+          'send-rejected',
+          '钉钉服务拒绝了主动文字消息。',
+          { providerCode: rejection },
+        );
+      }
+      return response;
+    },
+
     async sendFile(request) {
       return sendArtifact(request, {
         uploadType: 'file',

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

@@ -72,14 +72,14 @@ const HELP_TEXT_LINES = [
   '/history [数量]  查看最近历史消息（默认 3 条，最多 5 条）',
   '/workspace 工作区绝对路径  切换工作区',
   '/workspacelist  列出工作区绝对路径',
-  '/sessionlist [工作区序号或绝对路径]  列出会话 ID 和标题',
+  '/sessionlist 或 /sessions [工作区序号或绝对路径]  列出会话 ID 和标题',
   '/session Session ID 或当前工作区序号  将当前聊天绑定到指定会话',
   '/models  按序号列出所有可用模型',
   '/reasoninglist 或 /reasonings  按序号列出当前模型可用推理等级',
   '/reasoning [序号、等级ID或 --default]  查看或切换当前推理等级',
   '/model [序号或完整模型ID] [推理等级ID]  查看或切换当前会话模型',
   '示例：先发 /models，再发 /model 2 [推理等级ID]',
-  '/presetlist  按序号列出可用 Agent Preset',
+  '/presetlist 或 /presets  按序号列出可用 Agent Preset',
   '/preset [序号或完整ID]  查看或设置当前机器人 Agent Preset',
   '纯数字 ID：/preset id:<ID>',
   '/preset --default  跟随 Host 默认',

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

@@ -406,6 +406,20 @@ export class DingtalkController {
     });
   }
 
+  async sendProactiveText(botId, target, text, 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.sendProactiveText !== 'function') {
+        const error = new Error(t('钉钉消息连接当前离线'));
+        error.code = 'bot-not-connected';
+        throw error;
+      }
+      return runtime.sendProactiveText(target, text, options);
+    });
+  }
+
   /** Removes one bot, its secret, runtime, and local conversation state. */
   async deleteBot(botId) {
     const config = this.#configStore.get(botId);

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

@@ -388,6 +388,45 @@ export class DingtalkRuntime {
     });
   }
 
+  async sendProactiveText(target, text, { signal } = {}) {
+    const userId = typeof target?.route?.userId === 'string'
+      ? target.route.userId.trim() : '';
+    const openConversationId = typeof target?.route?.openConversationId === 'string'
+      ? target.route.openConversationId.trim() : '';
+    if ((target?.kind === 'user' && (!userId || openConversationId))
+      || (target?.kind === 'group' && (!openConversationId || userId))
+      || (target?.kind !== 'user' && target?.kind !== 'group')) {
+      const error = new TypeError('Invalid DingTalk proactive delivery target');
+      error.code = 'invalid-target';
+      throw error;
+    }
+    if (!this.#status.ready || !this.#abortController) {
+      const error = new Error('DingTalk runtime is not connected');
+      error.code = 'bot-not-connected';
+      throw error;
+    }
+    signal?.throwIfAborted();
+    try {
+      await this.#api.sendRobotText({
+        clientId: this.#config.clientId,
+        clientSecret: this.#clientSecret,
+        target: {
+          type: target.kind,
+          robotCode: this.#config.clientId,
+          ...(target.kind === 'user' ? { userId } : { openConversationId }),
+        },
+        text,
+        signal: signal ?? this.#abortController.signal,
+      });
+    } catch (cause) {
+      if (cause?.code !== 'send-rejected') throw cause;
+      const error = new Error('DingTalk rejected the proactive delivery target', { cause });
+      error.code = 'target-rejected';
+      throw error;
+    }
+    return { sent: true };
+  }
+
   #pendingSenders() {
     return typeof this.#state.pendingSenders === 'function'
       ? this.#state.pendingSenders()

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

@@ -501,6 +501,22 @@ export class DiscordRuntime {
     return this.#bridge.sendConnectionTest(text);
   }
 
+  async sendProactiveText(target, text, options = {}) {
+    if (!this.#status.ready || !this.#bridge) {
+      const error = new Error('Discord bot is not connected');
+      error.code = 'bot-not-connected';
+      throw error;
+    }
+    const channelId = typeof target?.route?.channelId === 'string'
+      ? target.route.channelId.trim() : '';
+    if (target?.kind !== 'channel' || !channelId) {
+      const error = new TypeError('Invalid Discord proactive delivery target');
+      error.code = 'invalid-target';
+      throw error;
+    }
+    return this.#bridge.sendProactiveText({ channelId }, text, options);
+  }
+
   async start() {
     if (this.#status.ready && this.#socket) return this.status;
     if (this.#starting) return this.#starting;

package/src/channels/feishu/bridge.mjs

@@ -93,7 +93,7 @@ const REPAIR_COMMAND = /^\/repair(?:\s+(qr|status|cancel|verify))?\s*$/i;
 const WATCH_COMMAND = /^\/watch(?:\s+([^\s]+))?$/i;
 const UNWATCH_COMMAND = /^\/unwatch(?:\s+([^\s]+))?$/i;
 const WATCHLIST_COMMAND = /^\/watchlist$/i;
-const SESSION_LIST_PREFIX = /^\/sessionlist(?:\s|$)/i;
+const SESSION_LIST_PREFIX = /^\/(?:sessionlist|sessions)(?:\s|$)/i;
 const WORKSPACE_LIST_COMMAND = /^\/workspacelist$/i;
 const NUMBER_REPLY = /^\d{1,2}$/;
 /** A displayed menu stays number-tappable for this long. */
@@ -133,13 +133,13 @@ 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(?:\s|$)|workspacelist|watchlist|archived(?:\s+(on|off))?)$/i;
+const CARD_COMMAND = /^\/(?:m(?:enu)?|new|help|status|compact|(?:sessionlist|sessions)(?:\s|$)|workspacelist|watchlist|archived(?:\s+(on|off))?)$/i;
 
 /** Canonical workspace/session help advertised by every bridge family. */
 const WORKSPACE_HELP_LINES = [
   '/session Session ID 或当前工作区序号  将当前聊天绑定到指定会话',
   '/workspacelist  列出工作区绝对路径',
-  '/sessionlist [工作区序号或绝对路径]  列出会话 ID 和标题',
+  '/sessionlist 或 /sessions [工作区序号或绝对路径]  列出会话 ID 和标题',
 ];
 
 /** Safe user-facing text for bind/workspace failures (no raw messages). */
@@ -1005,7 +1005,7 @@ export class FeishuHarnessBridge {
       return;
     }
     if (SESSION_LIST_PREFIX.test(commandText)) {
-      const selector = commandText.slice('/sessionlist'.length).trim() || null;
+      const selector = commandText.replace(/^\/(?:sessionlist|sessions)/i, '').trim() || null;
       await this.#showSessions({ chatId: event.message.chat_id, key }, selector, 0);
       return;
     }

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

@@ -487,7 +487,7 @@ export function menuHelpText() {
     '🤖 助手菜单（回复数字即可，无需记命令）',
     '',
     '📋 会话 / 工作区',
-    '/sessionlist  列出工作区会话',
+    '/sessionlist 或 /sessions  列出工作区会话',
     '/session ID  绑定已有会话',
     '/workspacelist  列出工作区',
     '/workspace 路径  切换工作区',
@@ -506,7 +506,7 @@ export function menuHelpText() {
     '/unwatch ID  取消关注',
     '',
     '🤖 预设 / 模型',
-    '/presetlist  列出可用 Agent Preset',
+    '/presetlist 或 /presets  列出可用 Agent Preset',
     '/preset [序号或完整ID]  查看或设置当前机器人 Agent Preset',
     '纯数字 ID：/preset id:<ID>',
     '/preset --default  跟随 Host 默认',
@@ -553,7 +553,7 @@ const HELP_TEXT_COMMANDS = [
   '`/m` — 打开菜单卡片',
   '`/new` — 开启全新会话',
   '`/session ID` — 绑定已有会话',
-  '`/sessionlist [工作区]` — 列出会话',
+  '`/sessionlist [工作区]` 或 `/sessions [工作区]` — 列出会话',
   '`/workspace 路径` — 切换工作区',
   '`/workspacelist` — 列出工作区',
   '`/status` — 查看连接状态',
@@ -564,7 +564,7 @@ const HELP_TEXT_COMMANDS = [
   '`/watchlist` — 关注列表',
   '`/unwatch ID` — 取消关注',
   '`/archived on/off` — 归档显隐',
-  '`/presetlist` — 列出预设',
+  '`/presetlist` 或 `/presets` — 列出预设',
   '`/preset [序号/ID]` — 切换预设',
   '`/preset --default` — 跟随默认',
   '`/models` — 列出模型',