@xmanrui/dsh-im 0.10.0 → 0.11.0

package/plugin-src/host/channels/slack/rpc.mjs

@@ -1,4 +1,5 @@
 import { resolveRpcAuthority } from '../../rpc-authority.mjs';
+import { publicConnectionTestResult } from '../../../../src/channels/shared/connection-test.mjs';
 import {
   publicWorkspaceError,
   SET_WORKSPACE_ENDPOINT,
@@ -53,7 +54,8 @@ function payloadFailure(endpoint, payload) {
       ? null : 'bot.bind-credentials requires xoxb Bot Token and xapp App Token.';
   }
   if (endpoint === SLACK_ENDPOINTS.reconnectBot) {
-    return exactKeys(payload, ['botId']) && validId(payload.botId)
+    return exactKeys(payload, ['botId', 'sendTest']) && validId(payload.botId)
+      && (payload.sendTest === undefined || typeof payload.sendTest === 'boolean')
       ? null : 'bot.reconnect requires a botId.';
   }
   if (endpoint === SLACK_ENDPOINTS.deleteBot) {
@@ -114,7 +116,31 @@ export function createSlackRpcHandler(controller) {
       let value;
       if (endpoint === SLACK_ENDPOINTS.status) value = await controller.status();
       else if (endpoint === SLACK_ENDPOINTS.bindCredentials) value = await controller.bindCredentials(payload);
-      else if (endpoint === SLACK_ENDPOINTS.reconnectBot) value = await controller.reconnectBot(payload.botId);
+      else if (endpoint === SLACK_ENDPOINTS.reconnectBot) {
+        value = await controller.reconnectBot(payload.botId);
+        if (signal?.aborted) {
+          return { ok: false, error: { code: 'cancelled', message: 'The request was cancelled.' } };
+        }
+        if (payload.sendTest === true) {
+          let testError = null;
+          try {
+            if (value?.bots?.find((bot) => bot?.botId === payload.botId)?.connected !== true) {
+              const unavailable = new Error('Bot is not connected');
+              unavailable.code = 'test-target-unavailable';
+              throw unavailable;
+            }
+            if (typeof controller.sendConnectionTest !== 'function') {
+              const unavailable = new Error('Connection test is unavailable');
+              unavailable.code = 'test-target-unavailable';
+              throw unavailable;
+            }
+            await controller.sendConnectionTest(payload.botId);
+          } catch (error) {
+            testError = error;
+          }
+          value = { ...value, testMessage: publicConnectionTestResult(testError) };
+        }
+      }
       else if (endpoint === SLACK_ENDPOINTS.setWorkspace) {
         if (typeof controller.updateWorkspace !== 'function') throw new Error('Workspace update is unavailable');
         value = await controller.updateWorkspace(payload.botId, payload.workspace);

package/plugin-src/host/channels/wecom/production.mjs

@@ -78,7 +78,7 @@ export async function createProductionController(ctx, config = {}, internals = {
   const harness = new Harness({
     baseUrl: harnessOrigin(ctx.webServer, config.harnessBaseUrl),
     workspace: defaultWorkspace,
-    agentPreset: config.agentPreset ?? 'standard',
+    ...(config.agentPreset == null ? {} : { agentPreset: config.agentPreset }),
     autostart: false,
     dshBin: config.dshBin ?? 'dsh',
     ...(commandExecutor ? { commandExecutor } : {}),

package/plugin-src/host/channels/wecom/rpc.mjs

@@ -1,6 +1,10 @@
 import QRCode from 'qrcode';
 import { resolveRpcAuthority } from '../../rpc-authority.mjs';
 import { publicWorkspaceError, SET_WORKSPACE_ENDPOINT, validWorkspacePayload } from '../shared/workspace-rpc.mjs';
+import {
+  connectionTestTargetUnavailable,
+  publicConnectionTestResult,
+} from '../../../../src/channels/shared/connection-test.mjs';
 
 export const WECOM_RPC_CHANNEL = '/wecom';
 export const WECOM_ENDPOINTS = Object.freeze({
@@ -53,7 +57,10 @@ function payloadFailure(endpoint, payload) {
       ? null : 'bot.bind-credentials requires Bot ID and Secret.';
   }
   if (endpoint === WECOM_ENDPOINTS.reconnectBot) {
-    return exactKeys(payload, ['botId']) && validId(payload.botId) ? null : 'bot.reconnect requires a botId.';
+    return exactKeys(payload, ['botId', 'sendTest'])
+      && validId(payload.botId)
+      && (payload.sendTest === undefined || payload.sendTest === true)
+      ? null : 'bot.reconnect requires a botId and optional sendTest=true.';
   }
   if (endpoint === WECOM_ENDPOINTS.deleteBot) {
     return exactKeys(payload, ['botId', 'confirm']) && validId(payload.botId) && payload.confirm === true
@@ -130,7 +137,29 @@ export function createWecomRpcHandler(controller, { encodeQr = qrDataUrl } = {})
       } else if (endpoint === WECOM_ENDPOINTS.bindCredentials) {
         value = await publicStatus(await controller.bindCredentials(payload), cachedEncode);
       } else if (endpoint === WECOM_ENDPOINTS.reconnectBot) {
-        value = await publicStatus(await controller.reconnectBot(payload.botId), cachedEncode);
+        const snapshot = await controller.reconnectBot(payload.botId);
+        if (signal?.aborted) {
+          return { ok: false, error: { code: 'cancelled', message: 'The request was cancelled.' } };
+        }
+        let testMessage;
+        if (payload.sendTest === true) {
+          const connected = snapshot?.bots?.some(
+            (bot) => bot?.botId === payload.botId && bot?.connected === true,
+          );
+          if (!connected || typeof controller.sendConnectionTest !== 'function') {
+            testMessage = publicConnectionTestResult(
+              connectionTestTargetUnavailable('企业微信机器人'),
+            );
+          } else {
+            try {
+              await controller.sendConnectionTest(payload.botId);
+              testMessage = publicConnectionTestResult();
+            } catch (error) {
+              testMessage = publicConnectionTestResult(error);
+            }
+          }
+        }
+        value = await publicStatus({ ...snapshot, ...(testMessage ? { testMessage } : {}) }, cachedEncode);
       } else if (endpoint === WECOM_ENDPOINTS.setWorkspace) {
         if (typeof controller.updateWorkspace !== 'function') throw new Error('Workspace update is unavailable');
         value = await publicStatus(

package/plugin-src/host/channels/weixin/production.mjs

@@ -78,7 +78,7 @@ export async function createProductionController(ctx, config = {}, internals = {
   const harness = new Harness({
     baseUrl: harnessOrigin(ctx.webServer, config.harnessBaseUrl),
     workspace: defaultWorkspace,
-    agentPreset: config.agentPreset ?? 'standard',
+    ...(config.agentPreset == null ? {} : { agentPreset: config.agentPreset }),
     autostart: false,
     dshBin: config.dshBin ?? 'dsh',
     ...(commandExecutor ? { commandExecutor } : {}),

package/plugin-src/host/channels/weixin/rpc.mjs

@@ -5,6 +5,10 @@ import {
   SET_WORKSPACE_ENDPOINT,
   validWorkspacePayload,
 } from '../shared/workspace-rpc.mjs';
+import {
+  connectionTestTargetUnavailable,
+  publicConnectionTestResult,
+} from '../../../../src/channels/shared/connection-test.mjs';
 
 export const WEIXIN_RPC_CHANNEL = '/weixin';
 export const WEIXIN_ENDPOINTS = Object.freeze({
@@ -55,9 +59,11 @@ function payloadFailure(endpoint, payload) {
       : 'provision.verify requires an attemptId and a 4-to-8-digit code.';
   }
   if (endpoint === WEIXIN_ENDPOINTS.reconnectBot) {
-    return exactKeys(payload, ['botId']) && validId(payload.botId)
+    return exactKeys(payload, ['botId', 'sendTest'])
+      && validId(payload.botId)
+      && (payload.sendTest === undefined || payload.sendTest === true)
       ? null
-      : 'bot.reconnect requires a botId.';
+      : 'bot.reconnect requires a botId and optional sendTest=true.';
   }
   if (endpoint === WEIXIN_ENDPOINTS.deleteBot) {
     return exactKeys(payload, ['botId', 'confirm']) && validId(payload.botId) && payload.confirm === true
@@ -165,7 +171,27 @@ export function createWeixinRpcHandler(controller, { encodeQr = qrDataUrl } = {}
         value = await controller.cancelProvisioning(payload.attemptId);
         if (!value) return badRequest('The provisioning attempt no longer exists.');
       } else if (endpoint === WEIXIN_ENDPOINTS.reconnectBot) {
-        value = await publicStatus(await controller.reconnectBot(payload.botId), cachedEncode);
+        const snapshot = await controller.reconnectBot(payload.botId);
+        if (signal?.aborted) return cancelled();
+        let testMessage;
+        if (payload.sendTest === true) {
+          const connected = snapshot?.bots?.some(
+            (bot) => bot?.botId === payload.botId && bot?.connected === true,
+          );
+          if (!connected || typeof controller.sendConnectionTest !== 'function') {
+            testMessage = publicConnectionTestResult(
+              connectionTestTargetUnavailable('微信机器人'),
+            );
+          } else {
+            try {
+              await controller.sendConnectionTest(payload.botId);
+              testMessage = publicConnectionTestResult();
+            } catch (error) {
+              testMessage = publicConnectionTestResult(error);
+            }
+          }
+        }
+        value = await publicStatus({ ...snapshot, ...(testMessage ? { testMessage } : {}) }, cachedEncode);
       } else if (endpoint === WEIXIN_ENDPOINTS.setWorkspace) {
         if (typeof controller.updateWorkspace !== 'function') throw new Error('Workspace update is unavailable');
         value = await publicStatus(

package/plugin-src/host/channels/whatsapp/production.mjs

@@ -81,7 +81,7 @@ export async function createProductionController(ctx, config = {}, internals = {
   const harness = new Harness({
     baseUrl: harnessOrigin(ctx.webServer, config.harnessBaseUrl),
     workspace: defaultWorkspace,
-    agentPreset: config.agentPreset ?? 'standard',
+    ...(config.agentPreset == null ? {} : { agentPreset: config.agentPreset }),
     autostart: false,
     dshBin: config.dshBin ?? 'dsh',
     ...(commandExecutor ? { commandExecutor } : {}),

package/plugin-src/host/channels/whatsapp/rpc.mjs

@@ -1,5 +1,6 @@
 import QRCode from 'qrcode';
 
+import { publicConnectionTestResult } from '../../../../src/channels/shared/connection-test.mjs';
 import { resolveRpcAuthority } from '../../rpc-authority.mjs';
 import { publicWorkspaceError, SET_WORKSPACE_ENDPOINT, validWorkspacePayload } from '../shared/workspace-rpc.mjs';
 
@@ -39,8 +40,9 @@ function payloadFailure(endpoint, payload) {
       ? null : `${endpoint} requires an attemptId.`;
   }
   if (endpoint === WHATSAPP_ENDPOINTS.reconnectBot) {
-    return exactKeys(payload, ['botId']) && validId(payload.botId)
-      ? null : 'bot.reconnect requires a botId.';
+    return exactKeys(payload, ['botId', 'sendTest']) && validId(payload.botId)
+      && (payload.sendTest === undefined || typeof payload.sendTest === 'boolean')
+      ? null : 'bot.reconnect requires a botId and optional sendTest flag.';
   }
   if (endpoint === WHATSAPP_ENDPOINTS.deleteBot) {
     return exactKeys(payload, ['botId', 'confirm']) && validId(payload.botId)
@@ -119,7 +121,33 @@ export function createWhatsappRpcHandler(controller, { encodeQr = qrDataUrl } =
       } else if (endpoint === WHATSAPP_ENDPOINTS.cancelProvisioning) {
         value = sanitizePublic(await controller.cancelProvisioning(payload.attemptId));
       } else if (endpoint === WHATSAPP_ENDPOINTS.reconnectBot) {
-        value = await publicStatus(await controller.reconnectBot(payload.botId), cachedEncode);
+        const checked = await controller.reconnectBot(payload.botId);
+        if (signal?.aborted) {
+          return { ok: false, error: { code: 'cancelled', message: 'The request was cancelled.' } };
+        }
+        value = await publicStatus(checked, cachedEncode);
+        if (payload.sendTest === true) {
+          let testError = null;
+          const connected = checked?.bots?.some(
+            (bot) => bot?.botId === payload.botId && bot.connected === true,
+          ) === true;
+          if (!connected) {
+            testError = new Error('WhatsApp bot is not connected');
+            testError.code = 'test-target-unavailable';
+          } else {
+            try {
+              if (typeof controller.sendConnectionTest !== 'function') {
+                const unavailable = new Error('Connection test is unavailable');
+                unavailable.code = 'test-target-unavailable';
+                throw unavailable;
+              }
+              await controller.sendConnectionTest(payload.botId);
+            } catch (error) {
+              testError = error;
+            }
+          }
+          value = { ...value, testMessage: publicConnectionTestResult(testError) };
+        }
       } else if (endpoint === WHATSAPP_ENDPOINTS.setWorkspace) {
         if (typeof controller.updateWorkspace !== 'function') throw new Error('Workspace update is unavailable');
         value = await publicStatus(

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

@@ -17,6 +17,7 @@ import {
   imagePromptUserMessage,
   promptContentForMessage,
 } from '../shared/image-prompt.mjs';
+import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
 
 const CARD_INITIAL_TEXT = '已连接 DeepSeek Harness，正在思考…';
 const CARD_ERROR_TEXT = '消息处理失败，请稍后重试。';
@@ -309,6 +310,9 @@ export class DingtalkHarnessBridge {
     } catch {
       // An unsafe reply route must never be able to submit an approval.
     }
+    if (sessionWebhook && String(message.conversationType) !== '2') {
+      rememberConnectionTestTarget(this.#state, { sessionWebhook });
+    }
     const pending = this.#pendingInteractions.get(key);
     const approvalReply = this.#approvals.claimReply({
       key,

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

@@ -6,6 +6,10 @@ import {
   maskDingtalkClientId,
   maskDingtalkSenderId,
 } from './config-store.mjs';
+import {
+  connectionTestMessage,
+  connectionTestTargetUnavailable,
+} from '../shared/connection-test.mjs';
 
 const ACTIVE_ATTEMPT_STATES = new Set(['starting', 'pending', 'connecting']);
 const TERMINAL_ATTEMPT_STATES = new Set(['connected', 'expired', 'failed', 'cancelled']);
@@ -386,6 +390,20 @@ export class DingtalkController {
     return this.status();
   }
 
+  async sendConnectionTest(botId) {
+    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.sendConnectionTest !== 'function') {
+        throw connectionTestTargetUnavailable('钉钉机器人');
+      }
+      return runtime.sendConnectionTest(connectionTestMessage(
+        `钉钉机器人（${maskDingtalkClientId(config.clientId)}）`,
+      ));
+    });
+  }
+
   /** 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

@@ -3,6 +3,7 @@ import {
   createDingtalkBridgeStatus,
   DingtalkHarnessBridge,
 } from './dingtalk-bridge.mjs';
+import { sendRememberedConnectionTest } from '../shared/connection-test.mjs';
 
 function nonEmptyString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
@@ -347,6 +348,26 @@ export class DingtalkRuntime {
     return this.status;
   }
 
+  async sendConnectionTest(text) {
+    return sendRememberedConnectionTest({
+      state: this.#state,
+      text,
+      channelLabel: '钉钉机器人',
+      send: async ({ sessionWebhook }, content) => {
+        if (!this.#status.ready || !this.#abortController) {
+          throw new Error('DingTalk runtime is not connected');
+        }
+        await this.#api.sendText({
+          clientId: this.#config.clientId,
+          clientSecret: this.#clientSecret,
+          sessionWebhook,
+          text: content,
+          signal: this.#abortController.signal,
+        });
+      },
+    });
+  }
+
   #pendingSenders() {
     return typeof this.#state.pendingSenders === 'function'
       ? this.#state.pendingSenders()

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

@@ -108,7 +108,7 @@ export class DiscordApi {
         headers: {
           authorization: `Bot ${this.#token}`,
           'content-type': 'application/json',
-          'user-agent': 'DeepSeek-Harness-dsh-im (https://github.com/xmanrui/dsh-im, 0.10.0)',
+          'user-agent': 'DeepSeek-Harness-dsh-im (https://github.com/xmanrui/dsh-im, 0.11.0)',
         },
         ...(body === undefined ? {} : { body: JSON.stringify(body) }),
         signal: requestSignal(signal, timeoutMs),

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

@@ -108,6 +108,7 @@ export function normalizeDiscordMessage(message, botId, { fetchImpl = fetch } =
       channelId: String(message.channel_id),
       replyToMessageId: String(message.id),
     },
+    connectionTestTarget: { channelId: String(message.channel_id) },
   };
 }
 
@@ -239,6 +240,15 @@ export class DiscordRuntime {
     return structuredClone(this.#status);
   }
 
+  async sendConnectionTest(text) {
+    if (!this.#status.ready || !this.#bridge) {
+      const error = new Error('Discord bot is not connected');
+      error.code = 'test-target-unavailable';
+      throw error;
+    }
+    return this.#bridge.sendConnectionTest(text);
+  }
+
   async start() {
     if (this.#status.ready && this.#socket) return this.status;
     if (this.#starting) return this.#starting;

package/src/channels/feishu/bridge.mjs

@@ -18,6 +18,7 @@ import {
 } from '../shared/harness-question.mjs';
 import { HarnessApprovalQueue } from '../shared/harness-approval.mjs';
 import { runCompactCommand } from '../shared/compact-command.mjs';
+import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
 import { runWorkspaceCommand } from '../shared/workspace-command.mjs';
 import { askInWorkspaceSession } from '../shared/workspace-session.mjs';
 
@@ -133,6 +134,11 @@ export class FeishuHarnessBridge {
       return Promise.resolve();
     }
 
+    if (event.message.chat_type === 'p2p') {
+      const chatId = nonEmptyString(event.message.chat_id);
+      if (chatId) rememberConnectionTestTarget(this.#state, { chatId });
+    }
+
     this.#acceptedMessageIds.add(messageId);
     const processingReaction = this.#addReaction(messageId, 'OnIt');
     if (this.#isResolvedQuestionReply(event, key)) {

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

@@ -1,5 +1,9 @@
 import { FeishuHarnessBridge } from './bridge.mjs';
 import { VerifiedFeishuChannel } from './feishu-channel.mjs';
+import {
+  connectionTestTargetUnavailable,
+  sendRememberedConnectionTest,
+} from '../shared/connection-test.mjs';
 
 const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
 
@@ -240,6 +244,47 @@ export class FeishuRuntime {
     }
   }
 
+  async sendConnectionTest(text) {
+    if (!this.#status.ready || !this.#client) {
+      const error = new Error('飞书机器人尚未连接');
+      error.code = 'test-target-unavailable';
+      throw error;
+    }
+    if (typeof text !== 'string' || !text.trim()) {
+      throw new TypeError('Feishu connection test text is required');
+    }
+    const send = async (receiveIdType, receiveId, content) => {
+      const response = await this.#client.im.v1.message.create({
+        params: { receive_id_type: receiveIdType },
+        data: {
+          receive_id: receiveId,
+          msg_type: 'text',
+          content: JSON.stringify({ text: content }),
+        },
+      });
+      if (response?.code && response.code !== 0) {
+        throw new Error(`Feishu connection test failed: ${response.msg || response.code}`);
+      }
+    };
+
+    const ownerOpenId = this.#ownerOpenIds.find((value) => value !== '*');
+    if (ownerOpenId) {
+      await send('open_id', ownerOpenId, text);
+      return { sent: true };
+    }
+
+    return sendRememberedConnectionTest({
+      state: this.#state,
+      text,
+      channelLabel: '飞书机器人',
+      send: async (target, content) => {
+        const chatId = typeof target?.chatId === 'string' ? target.chatId.trim() : '';
+        if (!chatId) throw connectionTestTargetUnavailable('飞书机器人');
+        await send('chat_id', chatId, content);
+      },
+    });
+  }
+
   async stop({ preserveError = false } = {}) {
     const error = preserveError ? this.#status.lastError : null;
     const abortController = this.#abortController;

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

@@ -1,5 +1,11 @@
 import { ImagePromptError } from '../shared/image-prompt.mjs';
 
+const FEISHU_MISSING_MESSAGE_SCOPE_CODE = 99991672;
+const FEISHU_ERROR_BODY_LIMIT = 64 * 1024;
+const FEISHU_ERROR_BODY_TIMEOUT_MS = 1_000;
+const FEISHU_IMAGE_PERMISSION_MESSAGE =
+  '飞书机器人缺少图片读取权限。请在飞书开放平台为该应用添加 im:message:readonly，发布新版本并完成必要的管理员审批后，再重新发送图片。';
+
 export function conversationKey(event) {
   const chatType = event?.message?.chat_type;
   if (chatType === 'p2p') {
@@ -119,17 +125,98 @@ async function readBoundedStream(stream, { signal, maxBytes }) {
   }
 }
 
+function providerCode(value) {
+  if (!value || typeof value !== 'object') return null;
+  const code = value.code ?? value.error?.code;
+  return Number.isSafeInteger(Number(code)) ? Number(code) : null;
+}
+
+async function readFeishuErrorBody(stream, signal) {
+  if (!stream || typeof stream[Symbol.asyncIterator] !== 'function') return null;
+  signal?.throwIfAborted();
+  const timeout = AbortSignal.timeout(FEISHU_ERROR_BODY_TIMEOUT_MS);
+  const readSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+  const abort = () => stream.destroy?.(readSignal.reason);
+  readSignal.addEventListener('abort', abort, { once: true });
+  const chunks = [];
+  let size = 0;
+  try {
+    for await (const chunk of stream) {
+      const data = Buffer.from(chunk);
+      size += data.length;
+      if (size > FEISHU_ERROR_BODY_LIMIT) {
+        stream.destroy?.();
+        return null;
+      }
+      chunks.push(data);
+    }
+    return Buffer.concat(chunks, size).toString('utf8');
+  } catch {
+    signal?.throwIfAborted();
+    return null;
+  } finally {
+    readSignal.removeEventListener('abort', abort);
+  }
+}
+
+async function feishuProviderCode(error, signal) {
+  const pending = [error];
+  const seen = new Set();
+  while (pending.length > 0 && seen.size < 8) {
+    const value = pending.shift();
+    if (!value || (typeof value !== 'object' && typeof value !== 'function') || seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    const directCode = providerCode(value);
+    const data = value.response?.data ?? value.data;
+    if (directCode === FEISHU_MISSING_MESSAGE_SCOPE_CODE) {
+      data?.destroy?.();
+      return directCode;
+    }
+    if (data && typeof data[Symbol.asyncIterator] === 'function') {
+      const body = await readFeishuErrorBody(data, signal);
+      try {
+        const parsedCode = providerCode(JSON.parse(body));
+        if (parsedCode === FEISHU_MISSING_MESSAGE_SCOPE_CODE) return parsedCode;
+      } catch {
+        // Non-JSON provider failures keep the generic image download message.
+      }
+    } else {
+      const dataCode = providerCode(data);
+      if (dataCode === FEISHU_MISSING_MESSAGE_SCOPE_CODE) return dataCode;
+    }
+    pending.push(value.cause);
+  }
+  return null;
+}
+
+async function feishuImageDownloadError(error, signal) {
+  if (await feishuProviderCode(error, signal) !== FEISHU_MISSING_MESSAGE_SCOPE_CODE) return error;
+  return new ImagePromptError(
+    'feishu-image-permission-required',
+    'Feishu image download requires the im:message:readonly tenant scope',
+    FEISHU_IMAGE_PERMISSION_MESSAGE,
+    { cause: error },
+  );
+}
+
 function feishuImageSource(event, client, key) {
   return {
     async load({ signal, maxBytes }) {
       signal?.throwIfAborted();
-      const resource = await client?.im?.v1?.messageResource?.get?.({
-        path: {
-          message_id: event.message.message_id,
-          file_key: key,
-        },
-        params: { type: 'image' },
-      });
+      let resource;
+      try {
+        resource = await client?.im?.v1?.messageResource?.get?.({
+          path: {
+            message_id: event.message.message_id,
+            file_key: key,
+          },
+          params: { type: 'image' },
+        });
+      } catch (error) {
+        throw await feishuImageDownloadError(error, signal);
+      }
       signal?.throwIfAborted();
       const size = declaredSize(resource?.headers);
       if (size !== null && size > maxBytes) {

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

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { connectionTestMessage } from '../shared/connection-test.mjs';
 import { RegistrationManager } from './registration-manager.mjs';
 import { REQUIRED_TENANT_SCOPES } from './plugin-controller.mjs';
 
@@ -339,6 +340,26 @@ export class MultiBotDshFeishuController {
     });
   }
 
+  async sendConnectionTest(botId) {
+    this.#assertOpen();
+    return this.#withBotTransition(botId, async () => {
+      const config = this.#requireBot(botId);
+      const runtime = this.#runtimes.get(botId);
+      if (!isConnected(connectionStatus(runtime))
+        || typeof runtime.sendConnectionTest !== 'function') {
+        const error = new Error('飞书机器人尚未连接');
+        error.code = 'test-target-unavailable';
+        throw error;
+      }
+      return runtime.sendConnectionTest(
+        connectionTestMessage(
+          `${config.botName}（${maskedAppId(config.appId)}）`,
+          '飞书机器人',
+        ),
+      );
+    });
+  }
+
   async disconnectBot(botId) {
     this.#assertOpen();
     // An operational pause only: credentials/config remain durable, so the

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

@@ -1,5 +1,6 @@
 import { runWorkspaceCommand } from '../shared/workspace-command.mjs';
 import { runCompactCommand } from '../shared/compact-command.mjs';
+import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
 import {
   harnessAnswerForQuestion,
   harnessQuestionText,
@@ -176,6 +177,12 @@ export class QqHarnessBridge {
       || this.#acceptedMessageIds.has(messageId)) return Promise.resolve();
     const key = conversationKey(message);
     this.#acceptedMessageIds.add(messageId);
+    if (message.kind === 'c2c'
+      && (this.#ownerUserOpenid === '*' || sender === this.#ownerUserOpenid)
+      && message.replyTarget?.scope === 'c2c'
+      && nonEmptyString(message.replyTarget.targetId) === sender) {
+      rememberConnectionTestTarget(this.#state, message.replyTarget);
+    }
     const pending = this.#pendingInteractions.get(key);
     const approval = this.#approvals.claimReply({
       key,

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

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 
+import { connectionTestMessage } from '../shared/connection-test.mjs';
 import { deriveQqBotIdentity, maskQqAppId } from './config-store.mjs';
 
 const ACTIVE_ATTEMPT_STATES = new Set(['starting', 'pending', 'refreshing', 'connecting']);
@@ -248,6 +249,23 @@ export class QqController {
     return this.status();
   }
 
+  async sendConnectionTest(botId) {
+    const config = this.#configStore.get(botId);
+    if (!config) throw new Error('Unknown QQ bot');
+    return this.#withBotTransition(botId, async () => {
+      const runtime = this.#runtimes.get(botId);
+      if (!runtime?.status?.ready || typeof runtime.sendConnectionTest !== 'function') {
+        const error = new Error('QQ机器人尚未连接');
+        error.code = 'test-target-unavailable';
+        throw error;
+      }
+      await runtime.sendConnectionTest(connectionTestMessage(
+        `QQ 机器人（${maskQqAppId(config.appId)}）`,
+      ));
+      return { sent: true };
+    });
+  }
+
   async deleteBot(botId) {
     const config = this.#configStore.get(botId);
     if (!config) throw new Error('Unknown QQ bot');