@xmanrui/dsh-im 0.6.0 → 0.7.1

package/src/channels/shared/workspace-command.mjs

@@ -1,10 +1,25 @@
-import { stat } from 'node:fs/promises';
+import { realpath, stat } from 'node:fs/promises';
 import { isAbsolute, resolve } from 'node:path';
 
+import { WORKSPACE_SESSION_STALE } from './workspace-session.mjs';
+
 const WORKSPACE_COMMAND = /^\/workspace(?:\s+([\s\S]+))?$/i;
 const WORKSPACE_LIST_COMMAND = /^\/workspacelist(?:\s+([\s\S]+))?$/i;
+const SESSION_LIST_COMMAND = /^\/sessionlist(?:\s+([\s\S]+))?$/i;
+const SESSION_BIND_PREFIX = /^\/session(?=$|\s)/i;
+const SESSION_BIND_COMMAND = /^\/session[ \t]+([^\s]+)$/i;
 const MAX_WORKSPACE_PATH_LENGTH = 4_096;
 const MAX_COMMAND_MESSAGE_LENGTH = 1_800;
+const MAX_SESSION_ID_LENGTH = 256;
+const UNSAFE_DISPLAY_TEXT = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u;
+const UNSAFE_DISPLAY_TEXT_GLOBAL = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]+/gu;
+const SESSION_BIND_USAGE = '用法：/session Session ID';
+const SESSION_LIST_USAGE = [
+  '用法：',
+  '/sessionlist  列出当前工作区会话',
+  '/sessionlist 工作区序号  按 /workspacelist 序号列出会话',
+  '/sessionlist 工作区绝对路径  列出指定工作区会话',
+].join('\n');
 
 function commandResult(message, messages = [message]) {
   return { handled: true, message, messages };
@@ -12,20 +27,74 @@ function commandResult(message, messages = [message]) {
 
 function normalizedWorkspacePath(value) {
   if (typeof value !== 'string' || value.length > MAX_WORKSPACE_PATH_LENGTH
-    || !isAbsolute(value) || /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(value)) return null;
+    || !isAbsolute(value) || UNSAFE_DISPLAY_TEXT.test(value)) return null;
   return resolve(value);
 }
 
+function safeDisplayText(value) {
+  if (typeof value !== 'string') return '';
+  return value.replace(UNSAFE_DISPLAY_TEXT_GLOBAL, ' ').replace(/\s+/gu, ' ').trim();
+}
+
+function validSessionId(value) {
+  return typeof value === 'string'
+    && value.length > 0
+    && value.length <= MAX_SESSION_ID_LENGTH
+    && !/\p{White_Space}/u.test(value)
+    && !UNSAFE_DISPLAY_TEXT.test(value);
+}
+
 async function existingWorkspacePaths(values) {
-  const unique = [...new Set(values.map(normalizedWorkspacePath).filter(Boolean))];
-  const checked = await Promise.all(unique.map(async (workspace) => {
+  const checked = await Promise.all(values.map(async (value) => {
+    const workspace = normalizedWorkspacePath(value);
+    if (!workspace) return null;
     try {
-      return (await stat(workspace)).isDirectory() ? workspace : null;
+      if (!(await stat(workspace)).isDirectory()) return null;
+      return normalizedWorkspacePath(await realpath(workspace));
     } catch {
       return null;
     }
   }));
-  return checked.filter(Boolean);
+  return [...new Set(checked.filter(Boolean))];
+}
+
+async function selectedWorkspacePath(value) {
+  if (typeof value !== 'string' || !isAbsolute(value.trim())) {
+    return { error: `工作区必须是绝对路径。\n${SESSION_LIST_USAGE}` };
+  }
+  const workspace = normalizedWorkspacePath(value.trim());
+  if (!workspace) {
+    return { error: `工作区路径包含不支持的字符或长度超过限制。\n${SESSION_LIST_USAGE}` };
+  }
+  let info;
+  try {
+    info = await stat(workspace);
+  } catch {
+    return { error: `工作区路径不存在。\n${SESSION_LIST_USAGE}` };
+  }
+  if (!info.isDirectory()) {
+    return { error: `工作区路径必须指向一个目录。\n${SESSION_LIST_USAGE}` };
+  }
+  try {
+    const canonical = normalizedWorkspacePath(await realpath(workspace));
+    return canonical
+      ? { workspace: canonical }
+      : { error: `工作区路径包含不支持的字符或长度超过限制。\n${SESSION_LIST_USAGE}` };
+  } catch {
+    return { error: `工作区路径不存在。\n${SESSION_LIST_USAGE}` };
+  }
+}
+
+async function workspacePathSnapshot(harness) {
+  const listed = await harness.listWorkspaces();
+  const currentValue = typeof harness?.currentWorkspace === 'function'
+    ? harness.currentWorkspace()
+    : null;
+  const [current] = currentValue ? await existingWorkspacePaths([currentValue]) : [];
+  const registered = await existingWorkspacePaths(Array.isArray(listed) ? listed : []);
+  const paths = [...new Set([...(current ? [current] : []), ...registered])];
+  harness.assertWorkspaceScope?.();
+  return { current: current ?? null, paths };
 }
 
 export function splitWorkspaceCommandMessage(message) {
@@ -56,15 +125,7 @@ async function runWorkspaceListCommand(match, harness) {
     return commandResult('当前机器人暂不支持列出工作区。');
   }
   try {
-    const listed = await harness.listWorkspaces();
-    const current = typeof harness.currentWorkspace === 'function'
-      ? normalizedWorkspacePath(harness.currentWorkspace())
-      : null;
-    const paths = await existingWorkspacePaths([
-      ...(current ? [current] : []),
-      ...(Array.isArray(listed) ? listed : []),
-    ]);
-    harness.assertWorkspaceScope?.();
+    const { current, paths } = await workspacePathSnapshot(harness);
     if (paths.length === 0) {
       return commandResult('当前 Harness Host 上没有仍然存在的已登记工作区。');
     }
@@ -75,6 +136,7 @@ async function runWorkspaceListCommand(match, harness) {
       )),
       '',
       '切换用法：/workspace 工作区绝对路径',
+      '查看会话：/sessionlist 工作区序号或绝对路径',
     ];
     const message = lines.join('\n');
     return commandResult(message, splitWorkspaceCommandMessage(message));
@@ -86,9 +148,143 @@ async function runWorkspaceListCommand(match, harness) {
   }
 }
 
-export async function runWorkspaceCommand(text, harness) {
+async function resolveSessionListWorkspace(selector, harness) {
+  if (!selector) {
+    if (typeof harness?.currentWorkspace !== 'function') {
+      return { error: '当前机器人没有可用的工作区。' };
+    }
+    const selected = await selectedWorkspacePath(harness.currentWorkspace());
+    harness.assertWorkspaceScope?.();
+    return selected;
+  }
+
+  if (/^\d+$/u.test(selector)) {
+    if (typeof harness?.listWorkspaces !== 'function') {
+      return { error: '当前机器人暂不支持按序号选择工作区。' };
+    }
+    const { paths } = await workspacePathSnapshot(harness);
+    const position = Number(selector);
+    if (!Number.isSafeInteger(position) || position < 1 || position > paths.length) {
+      return { error: '工作区序号不存在，请先执行 /workspacelist。' };
+    }
+    return { workspace: paths[position - 1] };
+  }
+
+  const selected = await selectedWorkspacePath(selector);
+  harness.assertWorkspaceScope?.();
+  return selected;
+}
+
+function sessionListMessage(workspace, sessions) {
+  const rows = sessions.map((session) => {
+    const sessionId = safeDisplayText(session?.sessionId);
+    if (!sessionId) throw new TypeError('Harness returned an invalid session id');
+    const title = session?.summaryAvailable === false
+      ? '标题暂不可用'
+      : safeDisplayText(session?.title) || '暂无标题';
+    return `${title}${session?.archived === true ? '（已归档）' : ''}\n   ID: ${sessionId}`;
+  });
+  if (rows.length === 0) return `工作区：${workspace}\n该工作区暂无会话。`;
+  return [
+    `工作区：${workspace}`,
+    `会话（${rows.length}）：`,
+    '',
+    ...rows.map((row, index) => `${index + 1}. ${row}`),
+    '',
+    '绑定用法：/session Session ID',
+  ].join('\n');
+}
+
+async function runSessionListCommand(match, harness) {
+  if (typeof harness?.listWorkspaceSessions !== 'function') {
+    return commandResult('当前机器人暂不支持列出工作区会话。');
+  }
+  const selector = match[1]?.trim() ?? '';
+  try {
+    const resolved = await resolveSessionListWorkspace(selector, harness);
+    if (resolved.error) return commandResult(resolved.error);
+    const listed = await harness.listWorkspaceSessions(resolved.workspace);
+    if (!listed || !Array.isArray(listed.sessions)) {
+      throw new TypeError('Harness returned an invalid workspace session list');
+    }
+    harness.assertWorkspaceScope?.();
+    const workspace = normalizedWorkspacePath(listed.workspace) ?? resolved.workspace;
+    const message = sessionListMessage(workspace, listed.sessions);
+    return commandResult(message, splitWorkspaceCommandMessage(message));
+  } catch (error) {
+    if (error?.code === 'workspace-bot-not-found') {
+      return commandResult('机器人正在移除或已重新接入，无法列出原会话的工作区会话。');
+    }
+    return commandResult('暂时无法获取工作区会话列表，请稍后重试。');
+  }
+}
+
+function sessionBindErrorMessage(error) {
+  if (error?.code === 'session-id-invalid') {
+    return `Session ID 格式无效。\n${SESSION_BIND_USAGE}`;
+  }
+  if (['session-not-registered', 'session-not-found'].includes(error?.code)) {
+    return '未找到该会话，请先执行 /sessionlist 确认 Session ID。';
+  }
+  if (error?.code === 'session-subagent-unsupported') {
+    return '子代理会话不能绑定到机器人对话，请选择普通会话。';
+  }
+  if (error?.code === 'session-workspace-ambiguous') {
+    return '该会话的工作区归属不明确，暂时无法绑定。';
+  }
+  if (error?.code === 'session-summary-unavailable') {
+    return '暂时无法读取该会话的信息，请稍后重试。';
+  }
+  if (error?.code === 'workspace-bot-not-found') {
+    return '机器人正在移除或已重新接入，无法绑定原对话的会话。';
+  }
+  if ([WORKSPACE_SESSION_STALE, 'agent-busy', 'session-conflict', 'workspace-conflict']
+    .includes(error?.code)) {
+    return '工作区或会话状态已发生变化，请重试。';
+  }
+  return '暂时无法绑定会话，请稍后重试。';
+}
+
+async function runSessionBindCommand(command, harness, conversationKey) {
+  const match = SESSION_BIND_COMMAND.exec(command);
+  const sessionId = match?.[1];
+  if (!validSessionId(sessionId)) return commandResult(SESSION_BIND_USAGE);
+  if (typeof harness?.bindWorkspaceSession !== 'function') {
+    return commandResult('当前机器人暂不支持绑定已有会话。');
+  }
+  if (typeof conversationKey !== 'string' || !conversationKey) {
+    return commandResult('当前消息缺少可绑定的会话上下文。');
+  }
+  try {
+    const bound = await harness.bindWorkspaceSession(conversationKey, sessionId);
+    harness.assertWorkspaceScope?.();
+    const workspace = normalizedWorkspacePath(bound?.workspace);
+    const boundSessionId = safeDisplayText(bound?.sessionId);
+    if (!workspace || !boundSessionId) {
+      throw new TypeError('Harness returned an invalid bound session');
+    }
+    const title = safeDisplayText(bound?.title) || '暂无标题';
+    const message = [
+      '当前聊天已绑定会话：',
+      `工作区：${workspace}`,
+      `标题：${title}`,
+      `ID：${boundSessionId}`,
+      `归档：${bound?.archived === true ? '是' : '否'}`,
+    ].join('\n');
+    return commandResult(message, splitWorkspaceCommandMessage(message));
+  } catch (error) {
+    return commandResult(sessionBindErrorMessage(error));
+  }
+}
+
+export async function runWorkspaceCommand(text, harness, conversationKey) {
   if (typeof text !== 'string') return null;
   const command = text.trim();
+  if (SESSION_BIND_PREFIX.test(command)) {
+    return runSessionBindCommand(command, harness, conversationKey);
+  }
+  const sessionListMatch = SESSION_LIST_COMMAND.exec(command);
+  if (sessionListMatch) return runSessionListCommand(sessionListMatch, harness);
   const listMatch = WORKSPACE_LIST_COMMAND.exec(command);
   if (listMatch) return runWorkspaceListCommand(listMatch, harness);
   const match = WORKSPACE_COMMAND.exec(command);

package/src/channels/shared/workspace-session.mjs

@@ -1,9 +1,20 @@
 export const WORKSPACE_SESSION_STALE = 'workspace-session-stale';
 
-async function sessionExists(harness, sessionId, options) {
+function workspaceSession(harness, sessionId) {
+  if (typeof harness.workspaceSession === 'function') {
+    return harness.workspaceSession(sessionId);
+  }
+  return Object.freeze({
+    sessionId,
+    sessionExists: (...args) => harness.sessionExists(sessionId, ...args),
+    ask: (...args) => harness.ask(sessionId, ...args),
+  });
+}
+
+async function sessionExists(session, options) {
   return options === undefined
-    ? harness.sessionExists(sessionId)
-    : harness.sessionExists(sessionId, options);
+    ? session.sessionExists()
+    : session.sessionExists(options);
 }
 
 async function createSession(harness, options) {
@@ -27,15 +38,17 @@ export async function askInWorkspaceSession({
   askOptions,
 }) {
   while (true) {
-    let sessionId = state.sessionFor(key);
-    if (!sessionId || !(await sessionExists(harness, sessionId, existsOptions))) {
-      sessionId = await createSession(harness, createOptions);
-      if (await state.setSession(key, sessionId) === false) continue;
-    }
     try {
+      let sessionId = state.sessionFor(key);
+      let session = sessionId ? workspaceSession(harness, sessionId) : null;
+      if (!session || !(await sessionExists(session, existsOptions))) {
+        sessionId = await createSession(harness, createOptions);
+        if (await state.setSession(key, sessionId) === false) continue;
+        session = workspaceSession(harness, sessionId);
+      }
       return {
         sessionId,
-        answer: await harness.ask(sessionId, text, askOptions),
+        answer: await session.ask(text, askOptions),
       };
     } catch (error) {
       if (error?.code !== WORKSPACE_SESSION_STALE) throw error;

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

@@ -1,3 +1,11 @@
-import { HarnessClient } from '../weixin/harness-client.mjs';
+import { HarnessClient } from '../shared/harness-client.mjs';
 
-export class SlackHarnessClient extends HarnessClient {}
+export class SlackHarnessClient extends HarnessClient {
+  constructor(options) {
+    super({
+      ...options,
+      rpcIdPrefix: 'slack',
+      logPrefix: 'dsh-slack',
+    });
+  }
+}

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

@@ -309,6 +309,7 @@ export class SlackRuntime {
         status: this.#status,
         logger: this.#logger,
         replyTimeoutMs: this.#replyTimeoutMs,
+        signal: controller.signal,
       });
       let timer;
       try {
@@ -389,7 +390,16 @@ export class SlackRuntime {
         if (this.#appId && packet.payload.api_app_id
           && packet.payload.api_app_id !== this.#appId) return;
         const message = normalizeSlackEvent(packet.payload, this.#config.platformId.split(':')[1]);
-        if (message) void this.#bridge?.accept(message);
+        const bridge = this.#bridge;
+        if (message && bridge) {
+          void bridge.accept(message).catch((error) => {
+            if (generation !== this.#generation || this.#stopped) return;
+            this.#logger.error?.(
+              `[dsh-im:slack] bot ${this.#config.botId} message handling failed:`,
+              error,
+            );
+          });
+        }
       });
 
       addSocketListener(socket, 'close', (event = {}) => {

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

@@ -1,3 +1,11 @@
-import { HarnessClient } from '../weixin/harness-client.mjs';
+import { HarnessClient } from '../shared/harness-client.mjs';
 
-export class TelegramHarnessClient extends HarnessClient {}
+export class TelegramHarnessClient extends HarnessClient {
+  constructor(options) {
+    super({
+      ...options,
+      rpcIdPrefix: 'telegram',
+      logPrefix: 'dsh-telegram',
+    });
+  }
+}

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

@@ -34,19 +34,21 @@ export function normalizeTelegramUpdate(update, { botId, username }) {
   const addressed = direct
     || String(message.reply_to_message?.from?.id ?? '') === String(botId)
     || mentionedUsername(message, username);
+  const messageThreadId = Number.isSafeInteger(message.message_thread_id)
+    ? message.message_thread_id : undefined;
   return {
     messageId: String(update.update_id),
     senderId: String(senderId),
     senderIsBot: message.from?.is_bot === true,
     kind: direct ? 'direct' : 'group',
-    conversationId: String(chatId),
+    conversationId: messageThreadId === undefined
+      ? String(chatId) : `${chatId}:${messageThreadId}`,
     content: withoutBotMention(message.text ?? message.caption ?? '', username),
     addressed,
     replyTarget: {
       chatId,
       replyToMessageId: messageId,
-      messageThreadId: Number.isSafeInteger(message.message_thread_id)
-        ? message.message_thread_id : undefined,
+      messageThreadId,
     },
   };
 }
@@ -206,6 +208,7 @@ export class TelegramRuntime {
         status: this.#status,
         logger: this.#logger,
         replyTimeoutMs: this.#replyTimeoutMs,
+        signal: controller.signal,
       });
 
       let cursor = this.#state.cursor();
@@ -248,7 +251,15 @@ export class TelegramRuntime {
           botId: this.#config.platformId,
           username: this.#config.username,
         });
-        if (message) await this.#bridge.accept(message);
+        if (message) {
+          void this.#bridge.accept(message).catch((error) => {
+            if (signal.aborted) return;
+            this.#logger.error?.(
+              `[dsh-im:telegram] bot ${this.#config.botId} message handling failed:`,
+              error,
+            );
+          });
+        }
         cursor = update.update_id + 1;
         await this.#state.setCursor(cursor);
       }

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

@@ -1,3 +1,11 @@
-import { HarnessClient } from '../weixin/harness-client.mjs';
+import { HarnessClient } from '../shared/harness-client.mjs';
 
-export class WecomHarnessClient extends HarnessClient {}
+export class WecomHarnessClient extends HarnessClient {
+  constructor(options) {
+    super({
+      ...options,
+      rpcIdPrefix: 'wecom',
+      logPrefix: 'dsh-wecom',
+    });
+  }
+}