@xmanrui/dsh-im 0.18.0 → 0.19.0

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

@@ -5,12 +5,24 @@ import {
   CALLBACK_REPAIR_OPERATION,
   CallbackRepairManager,
 } from './repair-manager.mjs';
+import {
+  GROUP_MESSAGE_PERMISSION_OPERATION,
+  GroupMessagePermissionManager,
+} from './group-message-permission-manager.mjs';
 import { REQUIRED_TENANT_SCOPES } from './plugin-controller.mjs';
+import {
+  isFeishuGroupResponseMode,
+  normalizeFeishuGroupResponseMode,
+} from './group-response-mode.mjs';
 
 const ACTIVE_REGISTRATION_STATES = new Set([
   'starting', 'qr_ready', 'polling', 'slow_down', 'domain_switched',
 ]);
 const MUTABLE_REGISTRATION_STATES = new Set([...ACTIVE_REGISTRATION_STATES, 'saving']);
+const TARGETED_APP_UPDATE_OPERATIONS = new Set([
+  CALLBACK_REPAIR_OPERATION,
+  GROUP_MESSAGE_PERMISSION_OPERATION,
+]);
 const ALL_VISIBLE_SENDERS = '*';
 const DEFAULT_CALLBACK_PROBE_TIMEOUT_MS = 120_000;
 const MAX_CALLBACK_PROBE_TIMEOUT_MS = 600_000;
@@ -76,6 +88,8 @@ function configuredBotFingerprint(config) {
     botName: config.botName,
     botOpenId: config.botOpenId,
     activated: config.activated,
+    groupResponseMode: normalizeFeishuGroupResponseMode(config.groupResponseMode),
+    groupMessagePermissionGranted: config.groupMessagePermissionGranted === true,
     deletionPending: config.deletionPending === true,
     connectedAt: config.connectedAt ?? null,
     createdAt: config.createdAt ?? null,
@@ -103,7 +117,7 @@ export class MultiBotDshFeishuController {
   #runtimes = new Map();
   #botErrors = new Map();
   #registrations = new Map();
-  #activeRepairs = new Map();
+  #activeAppUpdates = new Map();
   #botOwnership = new Map();
   #latestRegistrationId = null;
   #configTransition = Promise.resolve();
@@ -234,12 +248,15 @@ export class MultiBotDshFeishuController {
     const target = this.#requireBot(botId);
     if (target.deletionPending) throw new Error('Cannot repair a Feishu bot pending deletion');
 
-    const activeId = this.#activeRepairs.get(botId);
+    const activeId = this.#activeAppUpdates.get(botId);
     const active = activeId ? this.#registrations.get(activeId) : null;
     if (active && MUTABLE_REGISTRATION_STATES.has(active.manager.status().state)) {
+      if (active.operation !== CALLBACK_REPAIR_OPERATION) {
+        throw new Error('Another Feishu app update is already active for this bot');
+      }
       return this.registrationStatus(active.id);
     }
-    this.#activeRepairs.delete(botId);
+    this.#activeAppUpdates.delete(botId);
 
     const id = this.#createRegistrationId();
     if (typeof id !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(id) || this.#registrations.has(id)) {
@@ -278,7 +295,66 @@ export class MultiBotDshFeishuController {
       },
     });
     this.#registrations.set(id, record);
-    this.#activeRepairs.set(botId, id);
+    this.#activeAppUpdates.set(botId, id);
+    this.#latestRegistrationId = id;
+    this.#trimRegistrations();
+    record.manager.start();
+    this.#touch();
+    return this.registrationStatus(id);
+  }
+
+  startGroupMessagePermission(botId) {
+    this.#assertOpen();
+    const target = this.#requireBot(botId);
+    if (target.deletionPending) {
+      throw new Error('Cannot update permissions for a Feishu bot pending deletion');
+    }
+
+    const activeId = this.#activeAppUpdates.get(botId);
+    const active = activeId ? this.#registrations.get(activeId) : null;
+    if (active && MUTABLE_REGISTRATION_STATES.has(active.manager.status().state)) {
+      if (active.operation !== GROUP_MESSAGE_PERMISSION_OPERATION) {
+        throw new Error('Another Feishu app update is already active for this bot');
+      }
+      return this.registrationStatus(active.id);
+    }
+    this.#activeAppUpdates.delete(botId);
+
+    const id = this.#createRegistrationId();
+    if (typeof id !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(id) || this.#registrations.has(id)) {
+      throw new Error('Registration id generator returned an invalid or duplicate id');
+    }
+    const record = {
+      id,
+      operation: GROUP_MESSAGE_PERMISSION_OPERATION,
+      manager: null,
+      botId,
+      createdNew: false,
+      cancelled: false,
+      remoteCommitted: false,
+      processing: null,
+      publicError: null,
+      stage: 'authorizing',
+      target: structuredClone(target),
+      targetFingerprint: configuredBotFingerprint(target),
+      initiator: { actorOpenId: null, chatId: null },
+    };
+    record.manager = new GroupMessagePermissionManager({
+      registerApp: this.#registerApp,
+      appId: target.appId,
+      domain: target.domain,
+      onCredentials: (result) => {
+        record.remoteCommitted = true;
+        const processing = this.#acceptGroupMessagePermission(record, result);
+        const tracked = processing.finally(() => {
+          if (record.processing === tracked) record.processing = null;
+        });
+        record.processing = tracked;
+        return tracked;
+      },
+    });
+    this.#registrations.set(id, record);
+    this.#activeAppUpdates.set(botId, id);
     this.#latestRegistrationId = id;
     this.#trimRegistrations();
     record.manager.start();
@@ -303,7 +379,7 @@ export class MultiBotDshFeishuController {
     // Once registerApp has returned, the platform-side update has committed.
     // A repair must finish converging the returned credential and callback
     // probe; cancelling here cannot roll that remote mutation back.
-    if (record.operation === CALLBACK_REPAIR_OPERATION && state === 'saving') {
+    if (TARGETED_APP_UPDATE_OPERATIONS.has(record.operation) && state === 'saving') {
       return this.registrationStatus(attemptId);
     }
     if (!MUTABLE_REGISTRATION_STATES.has(state)) {
@@ -473,6 +549,25 @@ export class MultiBotDshFeishuController {
     });
   }
 
+  async updateGroupResponseMode(botId, groupResponseMode) {
+    this.#assertOpen();
+    if (!isFeishuGroupResponseMode(groupResponseMode)) {
+      throw new TypeError('Invalid Feishu group response mode');
+    }
+    return this.#serializeConfig(() => this.#withBotTransition(botId, async () => {
+      const config = this.#requireBot(botId);
+      if (groupResponseMode === 'all' && config.groupMessagePermissionGranted !== true) {
+        const error = new Error('Authorize im:message.group_msg before enabling all group messages');
+        error.code = 'group_message_permission_required';
+        throw error;
+      }
+      const saved = await this.#configStore.saveBot({ ...config, groupResponseMode });
+      this.#runtimes.get(botId)?.setGroupResponseMode?.(saved.groupResponseMode);
+      this.#touch();
+      return this.status(botId);
+    }));
+  }
+
   async deleteBot(botId) {
     this.#assertOpen();
     return this.#serializeConfig(() => this.#withBotTransition(botId, async () => {
@@ -497,14 +592,14 @@ export class MultiBotDshFeishuController {
   async close() {
     if (this.#closed) return;
     this.#closed = true;
-    const repairProcessing = [];
+    const appUpdateProcessing = [];
     for (const record of this.#registrations.values()) {
       const state = record.manager.status().state;
-      if (record.operation === CALLBACK_REPAIR_OPERATION && state === 'saving') {
+      if (TARGETED_APP_UPDATE_OPERATIONS.has(record.operation) && state === 'saving') {
         // Stop projecting an in-flight repair, but do not request its local
         // credential rollback after the remote update has committed.
         record.manager.cancel();
-        if (record.processing) repairProcessing.push(record.processing);
+        if (record.processing) appUpdateProcessing.push(record.processing);
       } else if (MUTABLE_REGISTRATION_STATES.has(state)) {
         record.cancelled = true;
         record.manager.cancel();
@@ -513,7 +608,7 @@ export class MultiBotDshFeishuController {
     await this.#configTransition;
     await Promise.allSettled([...this.#botTransitions.values()]);
     await Promise.allSettled([...this.#runtimes.keys()].map((id) => this.#stopRuntime(id)));
-    await Promise.allSettled(repairProcessing);
+    await Promise.allSettled(appUpdateProcessing);
     // A committed repair can be between SDK completion and its serialized
     // credential/runtime transition when close begins. Waiting for the repair
     // can therefore create a replacement runtime after the first drain. Drain
@@ -534,6 +629,8 @@ export class MultiBotDshFeishuController {
         phase: botPhase({ connected, error, connection }),
         connected,
         configured: true,
+        groupResponseMode: normalizeFeishuGroupResponseMode(config.groupResponseMode),
+        groupMessagePermissionGranted: config.groupMessagePermissionGranted === true,
         bot: publicBot(config),
         connection,
         error,
@@ -585,6 +682,158 @@ export class MultiBotDshFeishuController {
     };
   }
 
+  async #acceptGroupMessagePermission(record, result) {
+    const appId = result.client_id;
+    const appSecret = result.client_secret;
+    const ownerOpenId = optionalNonEmptyString(result.user_info?.open_id);
+    const tenantBrand = result.user_info?.tenant_brand;
+    const target = record.target;
+
+    if (record.cancelled) {
+      throw this.#callbackRepairError(
+        record,
+        'abort',
+        'Group message permission update was cancelled before local activation.',
+      );
+    }
+    if (appId !== target.appId) {
+      throw this.#callbackRepairError(
+        record,
+        'repair_app_mismatch',
+        'Feishu returned credentials for a different app.',
+      );
+    }
+    if (!ownerOpenId) {
+      throw this.#callbackRepairError(
+        record,
+        'repair_owner_missing',
+        'Feishu returned no permission operator identity.',
+      );
+    }
+    if (tenantBrand !== undefined && tenantBrand !== target.domain) {
+      throw this.#callbackRepairError(
+        record,
+        'repair_domain_mismatch',
+        'Feishu returned credentials for a different account domain.',
+      );
+    }
+    if (!target.ownerOpenIds.includes(ALL_VISIBLE_SENDERS)
+      && !target.ownerOpenIds.includes(ownerOpenId)) {
+      throw this.#callbackRepairError(
+        record,
+        'repair_owner_mismatch',
+        'The Feishu permission operator is not an owner of this configured bot.',
+      );
+    }
+
+    record.stage = 'verifying_identity';
+    let verified;
+    try {
+      verified = await this.#verifyApp({ appId, appSecret, domain: target.domain });
+    } catch (error) {
+      throw this.#callbackRepairError(
+        record,
+        'repair_credentials_invalid',
+        'Feishu could not verify the updated app credentials.',
+        error,
+      );
+    }
+    if (target.botOpenId && verified?.openId !== target.botOpenId) {
+      throw this.#callbackRepairError(
+        record,
+        'repair_bot_mismatch',
+        'The updated Feishu app belongs to a different bot identity.',
+      );
+    }
+
+    await this.#serializeConfig(() => this.#withBotTransition(record.botId, async () => {
+      const current = this.#configStore.getBot(record.botId);
+      if (!current
+        || current.deletionPending
+        || configuredBotFingerprint(current) !== record.targetFingerprint) {
+        throw this.#callbackRepairError(
+          record,
+          'repair_target_changed',
+          'The Feishu bot changed while its permission update was in progress.',
+        );
+      }
+
+      let previous;
+      try {
+        previous = await this.#credentials.resolve(current.secretRef);
+      } catch (error) {
+        throw this.#callbackRepairError(
+          record,
+          'credential_update_failed',
+          'Unable to read the current Feishu credential.',
+          error,
+        );
+      }
+      if (previous?.value !== appSecret) {
+        record.stage = 'persisting_secret';
+        try {
+          await this.#credentials.set(current.secretRef, appSecret);
+        } catch (writeError) {
+          const observed = await this.#credentials.resolve(current.secretRef).catch(() => null);
+          if (observed?.value !== appSecret) {
+            throw this.#callbackRepairError(
+              record,
+              'credential_update_failed',
+              'Unable to store the updated Feishu credential.',
+              writeError,
+            );
+          }
+        }
+        const persisted = await this.#credentials.resolve(current.secretRef).catch(() => null);
+        if (persisted?.value !== appSecret) {
+          throw this.#callbackRepairError(
+            record,
+            'credential_state_unknown',
+            'The updated Feishu credential could not be confirmed after writing.',
+          );
+        }
+      }
+
+      record.stage = 'enabling_all_messages';
+      let saved;
+      try {
+        saved = await this.#configStore.saveBot({
+          ...current,
+          groupMessagePermissionGranted: true,
+          groupResponseMode: 'all',
+        });
+      } catch (error) {
+        throw this.#callbackRepairError(
+          record,
+          'group_message_permission_save_failed',
+          'The permission was accepted, but all-message mode could not be saved.',
+          error,
+        );
+      }
+
+      record.stage = 'restarting';
+      try {
+        await this.#startRuntime(saved, appSecret);
+      } catch (error) {
+        this.#botErrors.set(record.botId, {
+          code: 'connection_failed',
+          message: '群消息权限已开通，但机器人长连接未就绪，请点击重试。',
+        });
+        this.#touch();
+        throw this.#callbackRepairError(
+          record,
+          'group_message_permission_connection_failed',
+          'The permission was accepted, but the Feishu runtime could not restart.',
+          error,
+        );
+      }
+      this.#botErrors.delete(record.botId);
+      record.stage = 'verified';
+      record.publicError = null;
+      this.#touch();
+    }));
+  }
+
   async #acceptCallbackRepair(record, result) {
     const appId = result.client_id;
     const appSecret = result.client_secret;

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

@@ -1,6 +1,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';
 
 export const LEGACY_FEISHU_SECRET_REF = 'DSH_FEISHU_APP_SECRET';
 
@@ -43,6 +44,8 @@ function normalizeBot(value, { legacy = false } = {}) {
     botName: cleanString(value.botName),
     botOpenId: cleanString(value.botOpenId),
     activated: value.activated ?? null,
+    groupResponseMode: normalizeFeishuGroupResponseMode(value.groupResponseMode),
+    groupMessagePermissionGranted: value.groupMessagePermissionGranted === true,
     deletionPending: value.deletionPending === true,
     connectedAt: cleanString(value.connectedAt),
     createdAt: cleanString(value.createdAt) ?? cleanString(value.connectedAt),

package/src/channels/feishu/repair-manager.mjs

@@ -17,12 +17,17 @@ function launcherDomain(domain) {
  * never fall back to the create-only flow. This catches regressions such as a
  * literal `{{client_id}}` before the broken URL reaches the browser.
  */
-export function assertCallbackRepairUrl(value, expectedAppId, domain = 'feishu') {
+export function assertTargetedAppUpdateUrl(
+  value,
+  expectedAppId,
+  domain = 'feishu',
+  operationLabel = 'Feishu app update',
+) {
   let url;
   try {
     url = new URL(value);
   } catch {
-    throw new Error('Feishu callback repair returned an invalid verification URL');
+    throw new Error(`${operationLabel} returned an invalid verification URL`);
   }
   const supportedDomain = domain === 'feishu' || domain === 'lark';
   const clientIds = url.searchParams.getAll('clientID');
@@ -49,11 +54,20 @@ export function assertCallbackRepairUrl(value, expectedAppId, domain = 'feishu')
     || addons.length !== 1
     || !addons[0]?.trim()
     || hasPlaceholder) {
-    throw new Error('Feishu callback repair returned an unsafe verification URL');
+    throw new Error(`${operationLabel} returned an unsafe verification URL`);
   }
   return url.toString();
 }
 
+export function assertCallbackRepairUrl(value, expectedAppId, domain = 'feishu') {
+  return assertTargetedAppUpdateUrl(
+    value,
+    expectedAppId,
+    domain,
+    'Feishu callback repair',
+  );
+}
+
 /**
  * One targeted update attempt for an existing Feishu app.  It intentionally
  * shares RegistrationManager's polling/state implementation while fixing the

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

@@ -16,6 +16,18 @@ export function validTelegramToken(value) {
   return typeof value === 'string' && /^\d{5,20}:[A-Za-z0-9_-]{20,}$/.test(value.trim());
 }
 
+const TELEGRAM_COMMAND_NAME = /^[a-z0-9_]{1,32}$/;
+
+function validBotCommand(value) {
+  return Boolean(value)
+    && typeof value === 'object' && !Array.isArray(value)
+    && typeof value.command === 'string' && TELEGRAM_COMMAND_NAME.test(value.command)
+    && typeof value.description === 'string' && value.description.length >= 1
+    && value.description.length <= 256;
+}
+
+export const COMMANDS_MENU_BUTTON = Object.freeze({ type: 'commands' });
+
 export class TelegramApi {
   #token;
   #fetch;
@@ -113,6 +125,25 @@ export class TelegramApi {
     }, { signal });
   }
 
+  async setMyCommands({ commands, scope, languageCode, signal } = {}) {
+    if (!Array.isArray(commands) || commands.length === 0
+      || commands.some((command) => !validBotCommand(command))) {
+      throw new TypeError('Telegram bot commands are invalid');
+    }
+    return this.#call('setMyCommands', {
+      commands,
+      ...(scope ? { scope } : {}),
+      ...(cleanString(languageCode) ? { language_code: cleanString(languageCode) } : {}),
+    }, { signal });
+  }
+
+  async setChatMenuButton({ menuButton = COMMANDS_MENU_BUTTON, signal } = {}) {
+    if (!menuButton || typeof menuButton !== 'object' || Array.isArray(menuButton)) {
+      throw new TypeError('Telegram menu button is invalid');
+    }
+    return this.#call('setChatMenuButton', { menu_button: menuButton }, { signal });
+  }
+
   async #call(method, payload, { signal, timeoutMs = 15_000 } = {}) {
     const url = new URL(this.#baseUrl);
     url.pathname = `${url.pathname.replace(/\/$/, '')}/bot${this.#token}/${method}`;

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

@@ -1,11 +1,26 @@
 import { createEditableMessageStream, splitMessageText } from '../shared/editable-message-stream.mjs';
-import { TelegramApi } from './telegram-api.mjs';
+import { COMMANDS_MENU_BUTTON, TelegramApi } from './telegram-api.mjs';
 import { createTelegramBridgeStatus, TelegramHarnessBridge } from './telegram-bridge.mjs';
 import {
   TELEGRAM_ACCESS_MODES,
   normalizeTelegramAccessPolicy,
 } from './config-store.mjs';
 
+export const TELEGRAM_COMMAND_MENU = Object.freeze([
+  { command: 'new', description: '开启一个全新会话' },
+  { command: 'compact', description: '压缩当前会话的较早上下文' },
+  { command: 'workspace', description: '切换工作区' },
+  { command: 'workspacelist', description: '列出工作区绝对路径' },
+  { command: 'sessionlist', description: '列出会话 ID 和标题' },
+  { command: 'session', description: '将当前聊天绑定到指定会话' },
+  { command: 'models', description: '按序号列出所有可用模型' },
+  { command: 'model', description: '查看或切换当前会话模型' },
+  { command: 'stop', description: '停止当前任务' },
+  { command: 'steer', description: '纠偏当前任务' },
+  { command: 'status', description: '检查连接状态' },
+  { command: 'help', description: '显示帮助' },
+]);
+
 function escaped(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -290,6 +305,15 @@ export class TelegramRuntime {
         error.code = 'webhook-configured';
         throw error;
       }
+      try {
+        await api.setMyCommands({ commands: TELEGRAM_COMMAND_MENU, signal: controller.signal });
+        await api.setChatMenuButton({ menuButton: COMMANDS_MENU_BUTTON, signal: controller.signal });
+      } catch (error) {
+        this.#logger.warn?.(
+          `[dsh-im:telegram] bot ${this.#config.botId} command menu setup failed:`,
+          error,
+        );
+      }
       const client = new TelegramBotClient({ api, signal: controller.signal });
       this.#bridge = new TelegramHarnessBridge({
         bot: client,

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

@@ -184,7 +184,7 @@ function authenticatedHeaders(token) {
 function baseInfo() {
   return {
     channel_version: WEIXIN_PROTOCOL_VERSION,
-    bot_agent: 'DeepSeekHarness/0.18.0',
+    bot_agent: 'DeepSeekHarness/0.19.0',
   };
 }