@xmanrui/dsh-im 0.4.0 → 0.6.0

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

@@ -0,0 +1,115 @@
+import { stat } from 'node:fs/promises';
+import { isAbsolute, resolve } from 'node:path';
+
+const WORKSPACE_COMMAND = /^\/workspace(?:\s+([\s\S]+))?$/i;
+const WORKSPACE_LIST_COMMAND = /^\/workspacelist(?:\s+([\s\S]+))?$/i;
+const MAX_WORKSPACE_PATH_LENGTH = 4_096;
+const MAX_COMMAND_MESSAGE_LENGTH = 1_800;
+
+function commandResult(message, messages = [message]) {
+  return { handled: true, message, messages };
+}
+
+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;
+  return resolve(value);
+}
+
+async function existingWorkspacePaths(values) {
+  const unique = [...new Set(values.map(normalizedWorkspacePath).filter(Boolean))];
+  const checked = await Promise.all(unique.map(async (workspace) => {
+    try {
+      return (await stat(workspace)).isDirectory() ? workspace : null;
+    } catch {
+      return null;
+    }
+  }));
+  return checked.filter(Boolean);
+}
+
+export function splitWorkspaceCommandMessage(message) {
+  const messages = [];
+  let offset = 0;
+  while (offset < message.length) {
+    let end = Math.min(offset + MAX_COMMAND_MESSAGE_LENGTH, message.length);
+    if (end < message.length) {
+      const lineBreak = message.lastIndexOf('\n', end - 1);
+      if (lineBreak >= offset) {
+        end = lineBreak + 1;
+      } else {
+        const trailing = message.charCodeAt(end - 1);
+        const leading = message.charCodeAt(end);
+        if (trailing >= 0xd800 && trailing <= 0xdbff
+          && leading >= 0xdc00 && leading <= 0xdfff) end -= 1;
+      }
+    }
+    messages.push(message.slice(offset, end));
+    offset = end;
+  }
+  return messages;
+}
+
+async function runWorkspaceListCommand(match, harness) {
+  if (match[1]?.trim()) return commandResult('用法：/workspacelist');
+  if (typeof harness?.listWorkspaces !== 'function') {
+    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?.();
+    if (paths.length === 0) {
+      return commandResult('当前 Harness Host 上没有仍然存在的已登记工作区。');
+    }
+    const lines = [
+      `当前 Harness Host 上存在的工作区（${paths.length}）：`,
+      ...paths.map((workspace, index) => (
+        `${index + 1}. ${workspace}${workspace === current ? '（当前）' : ''}`
+      )),
+      '',
+      '切换用法：/workspace 工作区绝对路径',
+    ];
+    const message = lines.join('\n');
+    return commandResult(message, splitWorkspaceCommandMessage(message));
+  } catch (error) {
+    if (error?.code === 'workspace-bot-not-found') {
+      return commandResult('机器人正在移除或已重新接入，无法列出原会话的工作区。');
+    }
+    return commandResult('暂时无法获取工作区列表，请稍后重试。');
+  }
+}
+
+export async function runWorkspaceCommand(text, harness) {
+  if (typeof text !== 'string') return null;
+  const command = text.trim();
+  const listMatch = WORKSPACE_LIST_COMMAND.exec(command);
+  if (listMatch) return runWorkspaceListCommand(listMatch, harness);
+  const match = WORKSPACE_COMMAND.exec(command);
+  if (!match) return null;
+  const workspace = match[1]?.trim();
+  if (!workspace) {
+    return commandResult('用法：/workspace 工作区绝对路径');
+  }
+  if (typeof harness?.switchWorkspace !== 'function') {
+    return commandResult('当前机器人暂不支持切换工作区。');
+  }
+  try {
+    const current = await harness.switchWorkspace(workspace);
+    return commandResult(`工作区已切换为：${current}`);
+  } catch (error) {
+    if (['workspace-not-absolute', 'workspace-not-found', 'workspace-not-directory'].includes(error?.code)) {
+      return commandResult(`${error.message}\n用法：/workspace 工作区绝对路径`);
+    }
+    if (error?.code === 'workspace-bot-not-found') {
+      return commandResult('机器人正在移除或已重新接入，无法切换原会话的工作区。');
+    }
+    throw error;
+  }
+}

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

@@ -0,0 +1,44 @@
+export const WORKSPACE_SESSION_STALE = 'workspace-session-stale';
+
+async function sessionExists(harness, sessionId, options) {
+  return options === undefined
+    ? harness.sessionExists(sessionId)
+    : harness.sessionExists(sessionId, options);
+}
+
+async function createSession(harness, options) {
+  return options === undefined
+    ? harness.createSession()
+    : harness.createSession(options);
+}
+
+/**
+ * Resolve, persist, and ask through a session that belongs to the bot's
+ * current workspace. A concurrent workspace switch invalidates the scoped
+ * session and retries before any prompt is sent to the stale session.
+ */
+export async function askInWorkspaceSession({
+  harness,
+  state,
+  key,
+  text,
+  createOptions,
+  existsOptions,
+  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 {
+      return {
+        sessionId,
+        answer: await harness.ask(sessionId, text, askOptions),
+      };
+    } catch (error) {
+      if (error?.code !== WORKSPACE_SESSION_STALE) throw error;
+    }
+  }
+}

package/src/channels/wecom/state-store.mjs

@@ -54,6 +54,11 @@ export class WecomStateStore {
     await this.#persist();
   }
 
+  async clearSessions() {
+    this.#state.sessions = {};
+    await this.#persist();
+  }
+
   hasSeen(messageId) {
     return this.#state.seenMessageIds.includes(messageId);
   }

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

@@ -1,10 +1,14 @@
 import { generateReqId } from '@wecom/aibot-node-sdk';
+import { runWorkspaceCommand } from '../shared/workspace-command.mjs';
+import { askInWorkspaceSession } from '../shared/workspace-session.mjs';
 
 const HELP_TEXT = [
   '企业微信机器人已连接 DeepSeek Harness。',
   '',
   '直接发送文字即可继续当前会话。',
   '/new  开启一个全新会话',
+  '/workspace 工作区绝对路径  切换工作区',
+  '/workspacelist  列出工作区绝对路径',
   '/status  检查连接状态',
   '/help  显示本帮助',
 ].join('\n');
@@ -182,11 +186,13 @@ export class WecomHarnessBridge {
         await this.#state.markSeen(messageId);
         return;
       }
-
-      let sessionId = this.#state.sessionFor(key);
-      if (!sessionId || !(await this.#harness.sessionExists(sessionId))) {
-        sessionId = await this.#harness.createSession();
-        await this.#state.setSession(key, sessionId);
+      const workspaceCommand = await runWorkspaceCommand(text, this.#harness);
+      if (workspaceCommand) {
+        for (const reply of workspaceCommand.messages ?? [workspaceCommand.message]) {
+          await this.#sendImmediate(frame, chatId, reply);
+        }
+        await this.#state.markSeen(messageId);
+        return;
       }
 
       streamId = this.#generateReqId('stream');
@@ -197,14 +203,20 @@ export class WecomHarnessBridge {
         this.#logger.warn?.('[dsh-im:wecom] unable to start a stream; using an active reply:', error);
       }
 
-      const answer = await this.#harness.ask(sessionId, text, {
-        timeoutMs: this.#replyTimeoutMs,
-        onUpdate: streamStarted && typeof this.#client.replyStreamNonBlocking === 'function'
-          ? async (update) => {
-              const progress = splitUtf8(progressText(update))[0];
-              if (progress) await this.#client.replyStreamNonBlocking(frame, streamId, progress, false);
-            }
-          : undefined,
+      const { answer } = await askInWorkspaceSession({
+        harness: this.#harness,
+        state: this.#state,
+        key,
+        text,
+        askOptions: {
+          timeoutMs: this.#replyTimeoutMs,
+          onUpdate: streamStarted && typeof this.#client.replyStreamNonBlocking === 'function'
+            ? async (update) => {
+                const progress = splitUtf8(progressText(update))[0];
+                if (progress) await this.#client.replyStreamNonBlocking(frame, streamId, progress, false);
+              }
+            : undefined,
+        },
       });
 
       const chunks = splitUtf8(answer || '任务已完成，但没有生成可显示的文本。');

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

@@ -400,7 +400,14 @@ export class WecomController {
         if (record.controller.signal.aborted) {
           await this.#stopRuntime(identity.botId);
           if (previousConfig) await this.#configStore.save(previousConfig).catch(() => undefined);
-          else await this.#configStore.remove(identity.botId).catch(() => undefined);
+          else {
+            const removed = await this.#configStore.remove(identity.botId).catch(() => null);
+            if (removed) {
+              await this.#deleteState({ botId: identity.botId, config }).catch((cleanupError) => {
+                this.#logger.warn?.('[dsh-im:wecom] cancelled bot state cleanup failed:', cleanupError);
+              });
+            }
+          }
           await this.#restoreCredential(identity.secretRef, previousSecret);
           throw error;
         }

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

@@ -1,8 +1,16 @@
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
+import { isAbsolute } from 'node:path';
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+function workspacePaths(value) {
+  if (!Array.isArray(value?.items)) return [];
+  return value.items.flatMap((item) => (
+    typeof item?.path === 'string' && isAbsolute(item.path) ? [item.path] : []
+  ));
+}
+
 function assistantMessageText(event) {
   return (event?.data?.message?.content ?? [])
     .filter((part) => part.type === 'text' && typeof part.text === 'string')
@@ -187,17 +195,23 @@ export class HarnessClient {
     throw new Error(`Harness did not become ready: ${lastError?.message ?? 'timeout'}`);
   }
 
-  async workspaceId() {
+  async listWorkspaces(options = {}) {
+    await this.ensureRunning();
+    return workspacePaths(await this.rpc('workspace.list', {}, 30_000, options));
+  }
+
+  async workspaceId(options = {}) {
+    const workspace = options.workspace ?? this.#workspace;
     const { items } = await this.rpc('workspace.list', {});
-    const existing = items.find((item) => item.path === this.#workspace);
+    const existing = items.find((item) => item.path === workspace);
     if (existing) return existing.workspaceId;
-    const created = await this.rpc('workspace.create', { path: this.#workspace });
+    const created = await this.rpc('workspace.create', { path: workspace });
     return created.workspace.workspaceId;
   }
 
-  async createSession() {
+  async createSession(options = {}) {
     await this.ensureRunning();
-    const workspaceId = await this.workspaceId();
+    const workspaceId = await this.workspaceId(options);
     const created = await this.rpc('session.create', {
       workspaceId,
       agentPreset: this.#agentPreset,

package/src/channels/weixin/state-store.mjs

@@ -62,6 +62,11 @@ export class WeixinStateStore {
     await this.#persist();
   }
 
+  async clearSessions() {
+    this.#state.sessions = {};
+    await this.#persist();
+  }
+
   hasSeen(messageId) {
     return this.#state.seenMessageIds.includes(messageId);
   }

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

@@ -92,7 +92,7 @@ function authenticatedHeaders(token) {
 function baseInfo() {
   return {
     channel_version: WEIXIN_PROTOCOL_VERSION,
-    bot_agent: 'DeepSeekHarness/0.4.0',
+    bot_agent: 'DeepSeekHarness/0.6.0',
   };
 }
 

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

@@ -3,12 +3,16 @@ import {
   splitWeixinText,
   weixinMessageId,
 } from './weixin-api.mjs';
+import { runWorkspaceCommand } from '../shared/workspace-command.mjs';
+import { askInWorkspaceSession } from '../shared/workspace-session.mjs';
 
 const HELP_TEXT = [
   '微信已连接 DeepSeek Harness。',
   '',
   '直接发送文字或带文字识别结果的语音即可继续当前会话。',
   '/new  开启一个全新会话',
+  '/workspace 工作区绝对路径  切换工作区',
+  '/workspacelist  列出工作区绝对路径',
   '/status  检查连接状态',
   '/help  显示本帮助',
 ].join('\n');
@@ -133,14 +137,23 @@ export class WeixinHarnessBridge {
         await this.#state.markSeen(messageId);
         return;
       }
+      const workspaceCommand = await runWorkspaceCommand(text, this.#harness);
+      if (workspaceCommand) {
+        for (const reply of workspaceCommand.messages ?? [workspaceCommand.message]) {
+          await this.#send(sender, reply, contextToken, runId);
+        }
+        await this.#state.markSeen(messageId);
+        return;
+      }
 
       const key = conversationKey(sender);
-      let sessionId = this.#state.sessionFor(key);
-      if (!sessionId || !(await this.#harness.sessionExists(sessionId))) {
-        sessionId = await this.#harness.createSession();
-        await this.#state.setSession(key, sessionId);
-      }
-      const answer = await this.#harness.ask(sessionId, text, { timeoutMs: this.#replyTimeoutMs });
+      const { answer } = await askInWorkspaceSession({
+        harness: this.#harness,
+        state: this.#state,
+        key,
+        text,
+        askOptions: { timeoutMs: this.#replyTimeoutMs },
+      });
       await this.#send(sender, answer, contextToken, runId);
       await this.#state.markSeen(messageId);
       this.#status.messagesReplied += 1;

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

@@ -468,7 +468,12 @@ export class WeixinController {
         await this.#stopRuntime(identity.botId);
         if (previousConfig) await this.#configStore.save(previousConfig).catch(() => undefined);
         else if (this.#configStore.get(identity.botId)) {
-          await this.#configStore.remove(identity.botId).catch(() => undefined);
+          const removed = await this.#configStore.remove(identity.botId).catch(() => null);
+          if (removed) {
+            await this.#deleteState({ botId: identity.botId, config }).catch((cleanupError) => {
+              this.#logger.warn?.('[dsh-weixin] failed to clean up cancelled bot state:', cleanupError);
+            });
+          }
         }
         await this.#restoreCredential(identity.tokenRef, previousToken);
         if (previousConfig && previousToken?.value) {

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

@@ -311,7 +311,14 @@ export class WhatsappController {
       if (record.controller.signal.aborted || this.#closed || error?.name === 'AbortError') {
         await this.#stopRuntime(botId);
         if (previous) await this.#configStore.save(previous).catch(() => undefined);
-        else await this.#configStore.remove(botId).catch(() => undefined);
+        else {
+          const removed = await this.#configStore.remove(botId).catch(() => null);
+          if (removed) {
+            await this.#deleteState({ botId, config }).catch((cleanupError) => {
+              this.#logger.warn?.('[dsh-im:whatsapp] cancelled bot state cleanup failed:', cleanupError);
+            });
+          }
+        }
         await this.#deleteAuth(record.authDirectory).catch(() => undefined);
         if (previous) await this.#startRuntime(previous).catch(() => undefined);
         record.state = 'cancelled';