@xmanrui/dsh-im 0.10.0 → 0.11.0

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

@@ -1,5 +1,9 @@
 import { QQBot, typingIndicator } from '@tencent-connect/qqbot-nodejs';
 
+import {
+  connectionTestTarget,
+  connectionTestTargetUnavailable,
+} from '../shared/connection-test.mjs';
 import { createQqBridgeStatus, QqHarnessBridge } from './qq-bridge.mjs';
 
 function timeoutError() {
@@ -67,6 +71,28 @@ export class QqRuntime {
     return structuredClone(this.#status);
   }
 
+  async sendConnectionTest(text) {
+    if (!this.#status.ready || !this.#bot) {
+      throw connectionTestTargetUnavailable('QQ机器人');
+    }
+    const ownerUserOpenid = typeof this.#config.ownerUserOpenid === 'string'
+      ? this.#config.ownerUserOpenid.trim()
+      : '';
+    const remembered = connectionTestTarget(this.#state);
+    const rememberedUserOpenid = remembered?.scope === 'c2c'
+      && typeof remembered.targetId === 'string'
+      ? remembered.targetId.trim()
+      : '';
+    const target = rememberedUserOpenid
+      ? { scope: 'c2c', targetId: rememberedUserOpenid }
+      : (ownerUserOpenid && ownerUserOpenid !== '*'
+        ? { scope: 'c2c', targetId: ownerUserOpenid }
+        : null);
+    if (!target) throw connectionTestTargetUnavailable('QQ机器人');
+    await this.#bot.sendText(target, text);
+    return { sent: true };
+  }
+
   async start() {
     if (this.#status.ready && this.#bot) return this.status;
     if (this.#starting) return this.#starting;

package/src/channels/shared/bot-workspace-store.mjs

@@ -9,6 +9,7 @@ import {
 } from 'node:fs/promises';
 import { dirname, isAbsolute, resolve } from 'node:path';
 
+import { CONNECTION_TEST_STATE_IDENTITY } from './connection-test.mjs';
 import { WORKSPACE_SESSION_STALE } from './workspace-session.mjs';
 
 const EMPTY_DOCUMENT = Object.freeze({ version: 1, workspaces: Object.freeze({}) });
@@ -687,6 +688,7 @@ export function createBotWorkspaceScope(harness, { botId, workspaces, state }) {
   });
   const scopedState = new Proxy(state, {
     get(target, property) {
+      if (property === CONNECTION_TEST_STATE_IDENTITY) return target;
       if (property === 'sessionFor') {
         return (key, ...args) => {
           if (!isCurrentScope()) return null;

package/src/channels/shared/connection-test.mjs

@@ -0,0 +1,54 @@
+const targets = new WeakMap();
+
+export const CONNECTION_TEST_STATE_IDENTITY = Symbol('dsh-im.connection-test-state-identity');
+
+function stateIdentity(state) {
+  return state?.[CONNECTION_TEST_STATE_IDENTITY] ?? state;
+}
+
+function cleanText(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+export function rememberConnectionTestTarget(state, target) {
+  if (!state || !target || typeof target !== 'object') return false;
+  try {
+    targets.set(stateIdentity(state), structuredClone(target));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function connectionTestTarget(state) {
+  const target = state ? targets.get(stateIdentity(state)) : null;
+  return target ? structuredClone(target) : null;
+}
+
+export function connectionTestMessage(botName, channelLabel = '机器人') {
+  const name = cleanText(botName) ?? channelLabel;
+  return `✅ DeepSeek Harness 连接测试成功\n这条消息由插件页面中的“${name}”机器人卡片发出。`;
+}
+
+export function connectionTestTargetUnavailable(channelLabel = '机器人') {
+  const error = new Error(`${channelLabel}尚未收到可用于测试的私聊消息。`);
+  error.code = 'test-target-unavailable';
+  return error;
+}
+
+export async function sendRememberedConnectionTest({ state, send, text, channelLabel }) {
+  const target = connectionTestTarget(state);
+  if (!target) throw connectionTestTargetUnavailable(channelLabel);
+  await send(target, text);
+  return { sent: true };
+}
+
+export function publicConnectionTestResult(error) {
+  if (!error) return Object.freeze({ sent: true });
+  return Object.freeze({
+    sent: false,
+    code: error?.code === 'test-target-unavailable'
+      ? 'test-target-unavailable'
+      : 'test-message-failed',
+  });
+}

package/src/channels/shared/harness-client.mjs

@@ -327,7 +327,7 @@ export class HarnessClient {
   constructor({
     baseUrl,
     workspace,
-    agentPreset = 'standard',
+    agentPreset,
     autostart = false,
     dshBin = 'dsh',
     fetchImpl = fetch,
@@ -354,7 +354,8 @@ export class HarnessClient {
     }
     this.#baseUrl = new URL(baseUrl);
     this.#workspace = workspace;
-    this.#agentPreset = agentPreset;
+    // Keep an omitted preset absent so session.create resolves the Host's current default.
+    this.#agentPreset = agentPreset ?? undefined;
     this.#autostart = autostart;
     this.#dshBin = dshBin;
     this.#fetch = fetchImpl;
@@ -458,10 +459,9 @@ export class HarnessClient {
   async createSession(options = {}) {
     await this.ensureRunning(options);
     const workspaceId = await this.workspaceId(options);
-    const created = await this.rpc('session.create', {
-      workspaceId,
-      agentPreset: this.#agentPreset,
-    }, 30_000, options);
+    const payload = { workspaceId };
+    if (this.#agentPreset !== undefined) payload.agentPreset = this.#agentPreset;
+    const created = await this.rpc('session.create', payload, 30_000, options);
     return created.sessionId;
   }
 

package/src/channels/shared/text-harness-bridge.mjs

@@ -1,5 +1,9 @@
 import { runWorkspaceCommand } from './workspace-command.mjs';
 import { runCompactCommand } from './compact-command.mjs';
+import {
+  rememberConnectionTestTarget,
+  sendRememberedConnectionTest,
+} from './connection-test.mjs';
 import { askInWorkspaceSession } from './workspace-session.mjs';
 import { HarnessApprovalQueue } from './harness-approval.mjs';
 import {
@@ -97,6 +101,12 @@ export class TextHarnessBridge {
       return Promise.resolve();
     }
     this.#acceptedMessageIds.add(messageId);
+    if (normalized.kind === 'direct') {
+      rememberConnectionTestTarget(
+        this.#state,
+        normalized.connectionTestTarget ?? normalized.replyTarget,
+      );
+    }
 
     const key = `${kind}:${conversationId}`;
     const pending = this.#pendingInteractions.get(key);
@@ -194,6 +204,15 @@ export class TextHarnessBridge {
     ]);
   }
 
+  sendConnectionTest(text) {
+    return sendRememberedConnectionTest({
+      state: this.#state,
+      text,
+      channelLabel: `${this.#descriptor.label}机器人`,
+      send: (target, message) => this.#bot.sendText(target, message),
+    });
+  }
+
   async #process(message, messageId, senderId, conversationKey, {
     alreadyRecorded = false,
   } = {}) {

package/src/channels/shared/token-bot-controller.mjs

@@ -1,3 +1,5 @@
+import { connectionTestMessage } from './connection-test.mjs';
+
 function cleanString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
@@ -161,6 +163,25 @@ export class TokenBotController {
     return this.status();
   }
 
+  async sendConnectionTest(botId) {
+    const config = this.#configStore.get(botId);
+    if (!config) throw new Error(`Unknown ${this.#descriptor.label} bot`);
+    return this.#withBotTransition(botId, async () => {
+      const runtime = this.#runtimes.get(botId);
+      if (!runtime?.status?.ready || typeof runtime.sendConnectionTest !== 'function') {
+        const error = new Error(`${this.#descriptor.label}机器人尚未连接`);
+        error.code = 'test-target-unavailable';
+        throw error;
+      }
+      const cardLabel = `${config.name}（${this.#maskPlatformId(config.platformId)}）`;
+      await runtime.sendConnectionTest(connectionTestMessage(
+        cardLabel,
+        `${this.#descriptor.label}机器人`,
+      ));
+      return { sent: true };
+    });
+  }
+
   async deleteBot(botId) {
     const config = this.#configStore.get(botId);
     if (!config) throw new Error(`Unknown ${this.#descriptor.label} bot`);

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

@@ -1,3 +1,4 @@
+import { connectionTestMessage } from '../shared/connection-test.mjs';
 import { deriveSlackBotIdentity, maskSlackBotId } from './config-store.mjs';
 import { inspectSlackCredentials } from './slack-api.mjs';
 import { SLACK_DESCRIPTOR } from './slack-bridge.mjs';
@@ -168,6 +169,24 @@ export class SlackController {
     return this.status();
   }
 
+  async sendConnectionTest(botId) {
+    const config = this.#configStore.get(botId);
+    if (!config) throw new Error('Unknown Slack bot');
+    return this.#withBotTransition(botId, async () => {
+      const runtime = this.#runtimes.get(botId);
+      if (!runtime?.status?.ready || typeof runtime.sendConnectionTest !== 'function') {
+        const error = new Error('Slack机器人尚未连接');
+        error.code = 'test-target-unavailable';
+        throw error;
+      }
+      await runtime.sendConnectionTest(connectionTestMessage(
+        `${config.name}（${maskSlackBotId(config.platformId)}）`,
+        'Slack机器人',
+      ));
+      return { sent: true };
+    });
+  }
+
   async deleteBot(botId) {
     const config = this.#configStore.get(botId);
     if (!config) throw new Error('Unknown Slack bot');

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

@@ -83,6 +83,7 @@ export function normalizeSlackEvent(payload, botUserId, { loadFile = async () =>
       recipientUserId: String(event.user),
       recipientTeamId: String(event.user_team ?? payload.team_id ?? ''),
     },
+    connectionTestTarget: { channelId: String(event.channel) },
   };
 }
 
@@ -293,6 +294,15 @@ export class SlackRuntime {
     return structuredClone(this.#status);
   }
 
+  async sendConnectionTest(text) {
+    if (!this.#status.ready || !this.#bridge) {
+      const error = new Error('Slack 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/telegram/telegram-runtime.mjs

@@ -111,6 +111,7 @@ export function normalizeTelegramUpdate(update, { botId, username, loadFile = as
       replyToMessageId: messageId,
       messageThreadId,
     },
+    connectionTestTarget: { chatId, messageThreadId },
   };
 }
 
@@ -229,6 +230,15 @@ export class TelegramRuntime {
     return structuredClone(this.#status);
   }
 
+  async sendConnectionTest(text) {
+    if (!this.#status.ready || !this.#bridge) {
+      const error = new Error('Telegram bot is not connected');
+      error.code = 'test-target-unavailable';
+      throw error;
+    }
+    return this.#bridge.sendConnectionTest(text);
+  }
+
   async start() {
     if (this.#status.ready && this.#pollTask) return this.status;
     if (this.#starting) return this.#starting;

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

@@ -14,6 +14,7 @@ import {
   imagePromptUserMessage,
   promptContentForMessage,
 } from '../shared/image-prompt.mjs';
+import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
 
 const HELP_TEXT = [
   '企业微信机器人已连接 DeepSeek Harness。',
@@ -269,6 +270,9 @@ export class WecomHarnessBridge {
 
     const key = conversationKey(frame);
     this.#acceptedMessageIds.add(messageId);
+    if (body.chattype === 'single') {
+      rememberConnectionTestTarget(this.#state, { chatId });
+    }
     const pending = this.#pendingInteractions.get(key);
     const approval = this.#approvals.claimReply({
       key,

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

@@ -1,6 +1,10 @@
 import { randomUUID } from 'node:crypto';
 
 import { deriveWecomBotIdentity, maskWecomBotId } from './config-store.mjs';
+import {
+  connectionTestMessage,
+  connectionTestTargetUnavailable,
+} from '../shared/connection-test.mjs';
 
 const ACTIVE_ATTEMPT_STATES = new Set(['pending', 'connecting']);
 const TERMINAL_ATTEMPT_STATES = new Set(['connected', 'failed', 'cancelled', 'expired']);
@@ -237,6 +241,20 @@ export class WecomController {
     return this.status();
   }
 
+  async sendConnectionTest(botId) {
+    const config = this.#configStore.get(botId);
+    if (!config) throw new Error('Unknown Enterprise WeChat 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(
+        `企业微信机器人（${maskWecomBotId(config.remoteBotId)}）`,
+      ));
+    });
+  }
+
   async deleteBot(botId) {
     const config = this.#configStore.get(botId);
     if (!config) throw new Error('Unknown Enterprise WeChat bot');

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

@@ -1,6 +1,7 @@
 import { WSAuthFailureError, WSClient, WSReconnectExhaustedError } from '@wecom/aibot-node-sdk';
 
 import { createWecomBridgeStatus, WecomHarnessBridge } from './wecom-bridge.mjs';
+import { sendRememberedConnectionTest } from '../shared/connection-test.mjs';
 
 function timeoutError() {
   const error = new Error('Enterprise WeChat WebSocket authentication timed out');
@@ -197,6 +198,23 @@ export class WecomRuntime {
     return this.status;
   }
 
+  async sendConnectionTest(text) {
+    return sendRememberedConnectionTest({
+      state: this.#state,
+      text,
+      channelLabel: '企业微信机器人',
+      send: async ({ chatId }, content) => {
+        if (!this.#status.ready || !this.#client) {
+          throw new Error('Enterprise WeChat runtime is not connected');
+        }
+        await this.#client.sendMessage(chatId, {
+          msgtype: 'markdown',
+          markdown: { content },
+        });
+      },
+    });
+  }
+
   async #stopActive() {
     const client = this.#client;
     const bridge = this.#bridge;

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.10.0',
+    bot_agent: 'DeepSeekHarness/0.11.0',
   };
 }
 

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

@@ -18,6 +18,7 @@ import {
   imagePromptUserMessage,
   promptContentForMessage,
 } from '../shared/image-prompt.mjs';
+import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
 
 const INTERACTION_RESOLVED_TEXT = '这个问题已在其他客户端处理，无需再次回答。';
 
@@ -128,6 +129,9 @@ export class WeixinHarnessBridge {
     if (!messageId || !sender || this.#state.hasSeen(messageId)
       || this.#acceptedMessageIds.has(messageId)) return Promise.resolve();
     this.#acceptedMessageIds.add(messageId);
+    if (sender === this.#ownerUserId) {
+      rememberConnectionTestTarget(this.#state, { toUserId: sender });
+    }
     const key = conversationKey(sender);
     const contextToken = nonEmptyString(message?.context_token) ?? undefined;
     const runId = nonEmptyString(message?.run_id) ?? undefined;

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

@@ -6,6 +6,10 @@ import {
   WeixinApiError,
 } from './weixin-api.mjs';
 import { deriveWeixinBotIdentity, maskWeixinAccountId } from './config-store.mjs';
+import {
+  connectionTestMessage,
+  connectionTestTargetUnavailable,
+} from '../shared/connection-test.mjs';
 
 const ACTIVE_ATTEMPT_STATES = new Set([
   'starting',
@@ -240,6 +244,20 @@ export class WeixinController {
     return this.status();
   }
 
+  async sendConnectionTest(botId) {
+    const config = this.#configStore.get(botId);
+    if (!config) throw new Error('Unknown Weixin account');
+    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(
+        `微信机器人（${maskWeixinAccountId(config.accountId)}）`,
+      ));
+    });
+  }
+
   async deleteBot(botId) {
     const config = this.#configStore.get(botId);
     if (!config) throw new Error('Unknown Weixin account');

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

@@ -1,5 +1,9 @@
 import { WeixinApiError } from './weixin-api.mjs';
 import { createWeixinBridgeStatus, WeixinHarnessBridge } from './weixin-bridge.mjs';
+import {
+  connectionTestTarget,
+  connectionTestTargetUnavailable,
+} from '../shared/connection-test.mjs';
 
 const DEFAULT_START_RETRY_DELAYS_MS = Object.freeze([250, 1_000, 3_000]);
 
@@ -250,4 +254,25 @@ export class WeixinRuntime {
     this.#status.weixinConnectionState = 'idle';
     return this.status;
   }
+
+  async sendConnectionTest(text) {
+    const remembered = connectionTestTarget(this.#state);
+    const toUserId = typeof remembered?.toUserId === 'string' && remembered.toUserId.trim()
+      ? remembered.toUserId.trim()
+      : typeof this.#config.ownerUserId === 'string' && this.#config.ownerUserId.trim()
+        ? this.#config.ownerUserId.trim()
+        : null;
+    if (!toUserId) throw connectionTestTargetUnavailable('微信机器人');
+    if (!this.#status.ready || !this.#abortController) {
+      throw new Error('Weixin runtime is not connected');
+    }
+    await this.#api.sendText({
+      baseUrl: this.#config.baseUrl,
+      token: this.#token,
+      toUserId,
+      text,
+      signal: this.#abortController.signal,
+    });
+    return { sent: true };
+  }
 }

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

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 
+import { connectionTestMessage } from '../shared/connection-test.mjs';
 import { deriveWhatsappBotId, maskWhatsappAccount } from './config-store.mjs';
 
 const ACTIVE_ATTEMPT_STATES = new Set(['starting', 'pending', 'connecting']);
@@ -198,6 +199,25 @@ export class WhatsappController {
     return this.status();
   }
 
+  async sendConnectionTest(botId) {
+    const config = this.#configStore.get(botId);
+    if (!config) throw new Error('Unknown WhatsApp bot');
+    return this.#withBotTransition(botId, async () => {
+      const runtime = this.#runtimes.get(botId);
+      if (!runtime?.status?.ready || typeof runtime.sendConnectionTest !== 'function') {
+        const error = new Error('WhatsApp机器人尚未连接');
+        error.code = 'test-target-unavailable';
+        throw error;
+      }
+      return runtime.sendConnectionTest(
+        connectionTestMessage(
+          `${config.name}（${maskWhatsappAccount(config.accountJid)}）`,
+          'WhatsApp机器人',
+        ),
+      );
+    });
+  }
+
   async deleteBot(botId) {
     const config = this.#configStore.get(botId);
     if (!config) throw new Error('Unknown WhatsApp bot');

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

@@ -421,6 +421,22 @@ export class WhatsappRuntime {
     return this.stop();
   }
 
+  async sendConnectionTest(text) {
+    if (!this.#status.ready || !this.#client) {
+      const error = new Error('WhatsApp机器人尚未连接');
+      error.code = 'test-target-unavailable';
+      throw error;
+    }
+    if (typeof text !== 'string' || !text.trim()) {
+      throw new TypeError('WhatsApp connection test text is required');
+    }
+    await this.#client.sendText({
+      jid: this.#config.accountJid,
+      selfChat: true,
+    }, text);
+    return { sent: true };
+  }
+
   async stop() {
     const session = this.#session;
     const client = this.#client;