@xmanrui/dsh-im 0.6.0 → 0.7.0

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.6.0)',
+          'user-agent': 'DeepSeek-Harness-dsh-im (https://github.com/xmanrui/dsh-im, 0.7.0)',
         },
         ...(body === undefined ? {} : { body: JSON.stringify(body) }),
         signal: requestSignal(signal, timeoutMs),

package/src/channels/feishu/bridge.mjs

@@ -15,6 +15,8 @@ const HELP_TEXT = [
   '/new  开启一个全新会话',
   '/workspace 工作区绝对路径  切换工作区',
   '/workspacelist  列出工作区绝对路径',
+  '/sessionlist [工作区序号或绝对路径]  列出会话 ID 和标题',
+  '/session Session ID  将当前聊天绑定到指定会话',
   '/status  检查连接状态',
   '/help  显示本帮助',
 ].join('\n');
@@ -110,7 +112,7 @@ export class FeishuHarnessBridge {
       await this.#send(event.message.chat_id, '飞书机器人与 DeepSeek Harness 连接正常。');
       return;
     }
-    const workspaceCommand = await runWorkspaceCommand(text, this.#harness);
+    const workspaceCommand = await runWorkspaceCommand(text, this.#harness, key);
     if (workspaceCommand) {
       for (const reply of workspaceCommand.messages ?? [workspaceCommand.message]) {
         await this.#send(event.message.chat_id, reply);

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

@@ -2,6 +2,8 @@ import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { isAbsolute } from 'node:path';
 
+import { adoptRegisteredWorkspaceSession } from '../shared/harness-session-binding.mjs';
+
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 function workspacePaths(value) {
@@ -11,6 +13,47 @@ function workspacePaths(value) {
   ));
 }
 
+function workspaceFromList(workspacePath, workspaceList) {
+  if (!Array.isArray(workspaceList?.items)
+    || !Array.isArray(workspaceList?.archivedSessionIds)) {
+    throw new Error('Harness returned an invalid response for workspace.list');
+  }
+
+  const workspace = workspaceList.items.find((item) => item?.path === workspacePath);
+  if (!workspace) return null;
+  if (!Array.isArray(workspace.sessionIds)
+    || workspace.sessionIds.some((sessionId) => typeof sessionId !== 'string')) {
+    throw new Error('Harness returned invalid session IDs for workspace.list');
+  }
+  return workspace;
+}
+
+function workspaceSessions(workspace, archivedSessionIds, sessionList) {
+  if (!Array.isArray(sessionList?.items)) {
+    throw new Error('Harness returned an invalid response for session.list');
+  }
+
+  const archived = new Set(archivedSessionIds);
+  const summaries = new Map(sessionList.items.flatMap((item) => (
+    typeof item?.sessionId === 'string' ? [[item.sessionId, item]] : []
+  )));
+  return {
+    workspace: workspace.path,
+    sessions: workspace.sessionIds.map((sessionId) => {
+      const summary = summaries.get(sessionId);
+      const title = summary?.projections?.values?.title;
+      return {
+        sessionId,
+        title: typeof title === 'string' ? title : null,
+        archived: archived.has(sessionId),
+        blank: summary?.blank === true,
+        origin: summary?.origin === 'subagent' ? 'subagent' : null,
+        summaryAvailable: summary !== undefined,
+      };
+    }),
+  };
+}
+
 function messageText(event) {
   return (event?.data?.message?.content ?? [])
     .filter((part) => part.type === 'text' && typeof part.text === 'string')
@@ -210,6 +253,19 @@ export class HarnessClient {
     return workspacePaths(await this.rpc('workspace.list', {}, 30000, options));
   }
 
+  async listWorkspaceSessions(workspacePath, options = {}) {
+    await this.ensureRunning();
+    const workspaceList = await this.rpc('workspace.list', {}, 30000, options);
+    const workspace = workspaceFromList(workspacePath, workspaceList);
+    if (!workspace) return { workspace: workspacePath, sessions: [] };
+    const sessionList = await this.rpc('session.list', {}, 30000, options);
+    return workspaceSessions(workspace, workspaceList.archivedSessionIds, sessionList);
+  }
+
+  async adoptWorkspaceSession(value, options = {}) {
+    return adoptRegisteredWorkspaceSession(this, value, options, 30000);
+  }
+
   async workspaceId(options = {}) {
     const workspace = options.workspace ?? this.#workspace;
     const { items } = await this.rpc('workspace.list', {});

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

@@ -8,6 +8,8 @@ const HELP_TEXT = [
   '/new  开启一个全新会话',
   '/workspace 工作区绝对路径  切换工作区',
   '/workspacelist  列出工作区绝对路径',
+  '/sessionlist [工作区序号或绝对路径]  列出会话 ID 和标题',
+  '/session Session ID  将当前聊天绑定到指定会话',
   '/status  检查连接状态',
   '/help  显示本帮助',
 ].join('\n');
@@ -126,7 +128,7 @@ export class QqHarnessBridge {
         await this.#state.markSeen(messageId);
         return;
       }
-      const workspaceCommand = await runWorkspaceCommand(text, this.#harness);
+      const workspaceCommand = await runWorkspaceCommand(text, this.#harness, key);
       if (workspaceCommand) {
         for (const reply of workspaceCommand.messages ?? [workspaceCommand.message]) {
           await this.#bot.sendText(target, reply);

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

@@ -1,10 +1,37 @@
-import { mkdir, readFile, rename, stat, unlink, writeFile } from 'node:fs/promises';
+import {
+  mkdir,
+  readFile,
+  realpath,
+  rename,
+  stat,
+  unlink,
+  writeFile,
+} from 'node:fs/promises';
 import { dirname, isAbsolute, resolve } from 'node:path';
 
 import { WORKSPACE_SESSION_STALE } from './workspace-session.mjs';
 
 const EMPTY_DOCUMENT = Object.freeze({ version: 1, workspaces: Object.freeze({}) });
 
+function workspaceSessionStale(message) {
+  const error = new Error(message);
+  error.code = WORKSPACE_SESSION_STALE;
+  return error;
+}
+
+async function canonicalWorkspacePath(value) {
+  return resolve(await realpath(value));
+}
+
+async function sameWorkspacePath(left, right) {
+  if (left === right) return true;
+  try {
+    return await canonicalWorkspacePath(left) === await canonicalWorkspacePath(right);
+  } catch {
+    return false;
+  }
+}
+
 function botIdOf(value) {
   if (typeof value !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(value)) {
     throw new TypeError('Invalid bot id');
@@ -179,6 +206,72 @@ export class BotWorkspaceStore {
     });
   }
 
+  async bindWorkspaceSession(botId, value, {
+    conversationKey,
+    sessionId,
+    clearSessions,
+    setSession,
+    incarnation,
+    expectedGeneration,
+  } = {}) {
+    const id = botIdOf(botId);
+    if (typeof conversationKey !== 'string' || !conversationKey
+      || typeof sessionId !== 'string' || !sessionId) {
+      throw new TypeError('conversationKey and sessionId are required');
+    }
+    if (typeof clearSessions !== 'function' || typeof setSession !== 'function') {
+      throw new TypeError('session state callbacks are required');
+    }
+    if (!this.has(id)
+      || (incarnation !== undefined && incarnation !== this.incarnationFor(id))) {
+      const error = new Error('找不到要修改的机器人。');
+      error.code = 'workspace-bot-not-found';
+      throw error;
+    }
+    const workspace = await canonicalWorkspacePath(await validateWorkspacePath(value));
+    return this.#enqueue(id, async () => {
+      if (!this.has(id)
+        || (incarnation !== undefined && incarnation !== this.incarnationFor(id))) {
+        const error = new Error('找不到要修改的机器人。');
+        error.code = 'workspace-bot-not-found';
+        throw error;
+      }
+      if (expectedGeneration !== undefined
+        && expectedGeneration !== this.generationFor(id)) {
+        throw workspaceSessionStale(
+          'The bot workspace changed before the session binding could be committed.',
+        );
+      }
+
+      if (!(await sameWorkspacePath(workspace, this.workspaceFor(id)))) {
+        const previous = this.#workspaces[id];
+        // Fence every session resolved before this transition, then remove
+        // the old workspace mappings before publishing the new workspace.
+        this.#generations.set(id, this.#freshGeneration());
+        await clearSessions();
+        this.#workspaces[id] = workspace;
+        try {
+          await this.#persist();
+        } catch (error) {
+          // Session mappings stay cleared and the advanced generation stays
+          // fenced. Restoring either could pair an old session with a state
+          // transition whose durable outcome is unknown.
+          this.#workspaces[id] = previous;
+          throw error;
+        }
+      }
+
+      // This write remains inside the same bot transition as the workspace
+      // mutation, so another switch or bind cannot interleave between them.
+      await setSession(conversationKey, sessionId);
+      return {
+        workspace,
+        sessionId,
+        generation: this.#generations.get(id),
+      };
+    });
+  }
+
   async invalidateSessions(botId, { clearSessions } = {}) {
     const id = botIdOf(botId);
     return this.#enqueue(id, async () => {
@@ -417,20 +510,21 @@ export function createBotWorkspaceScope(harness, { botId, workspaces, state }) {
           }
         };
       }
-      if (property === 'listWorkspaces' && typeof target.listWorkspaces === 'function') {
+      if ((property === 'listWorkspaces' || property === 'listWorkspaceSessions')
+        && typeof target[property] === 'function') {
         return async (...args) => {
           if (!isCurrentScope()) {
             const error = new Error('找不到要修改的机器人。');
             error.code = 'workspace-bot-not-found';
             throw error;
           }
-          const paths = await target.listWorkspaces(...args);
+          const result = await target[property](...args);
           if (!isCurrentScope()) {
             const error = new Error('找不到要修改的机器人。');
             error.code = 'workspace-bot-not-found';
             throw error;
           }
-          return paths;
+          return result;
         };
       }
       if (property === 'switchWorkspace') {
@@ -446,6 +540,62 @@ export function createBotWorkspaceScope(harness, { botId, workspaces, state }) {
           });
         };
       }
+      if (property === 'bindWorkspaceSession') {
+        return async (conversationKey, sessionId) => {
+          if (typeof conversationKey !== 'string' || !conversationKey
+            || typeof sessionId !== 'string' || !sessionId) {
+            throw new TypeError('conversationKey and sessionId are required');
+          }
+          if (!isCurrentScope()) {
+            const error = new Error('找不到要修改的机器人。');
+            error.code = 'workspace-bot-not-found';
+            throw error;
+          }
+          if (typeof target.adoptWorkspaceSession !== 'function') {
+            throw new TypeError('Harness does not support adopting workspace sessions');
+          }
+          const expectedGeneration = workspaces.generationFor(botId);
+          const adopted = await target.adoptWorkspaceSession(sessionId);
+          if (!isCurrentScope()) {
+            const error = new Error('找不到要修改的机器人。');
+            error.code = 'workspace-bot-not-found';
+            throw error;
+          }
+          if (expectedGeneration !== workspaces.generationFor(botId)) {
+            throw workspaceSessionStale(
+              'The bot workspace changed while the session was being adopted.',
+            );
+          }
+          if (!adopted || typeof adopted !== 'object'
+            || adopted.sessionId !== sessionId || typeof adopted.workspace !== 'string') {
+            throw new TypeError('Harness returned an invalid adopted workspace session');
+          }
+          const bound = await workspaces.bindWorkspaceSession(botId, adopted.workspace, {
+            conversationKey,
+            sessionId,
+            clearSessions: () => state.clearSessions(),
+            setSession: (key, selectedSessionId) => state.setSession(key, selectedSessionId),
+            incarnation,
+            expectedGeneration,
+          });
+          if (!isCurrentScope()) {
+            const error = new Error('找不到要修改的机器人。');
+            error.code = 'workspace-bot-not-found';
+            throw error;
+          }
+          if (bound.generation !== workspaces.generationFor(botId)) {
+            throw workspaceSessionStale(
+              'The bot workspace changed before the session binding completed.',
+            );
+          }
+          sessionGenerations.set(sessionId, bound.generation);
+          return {
+            ...adopted,
+            workspace: bound.workspace,
+            sessionId: bound.sessionId,
+          };
+        };
+      }
       if (property === 'createSession') {
         return async (options = {}) => {
           await workspaces.whenBotIdle(botId);
@@ -463,6 +613,37 @@ export function createBotWorkspaceScope(harness, { botId, workspaces, state }) {
           return sessionId;
         };
       }
+      if (property === 'workspaceSession') {
+        return (sessionId) => {
+          if (typeof sessionId !== 'string' || !sessionId) {
+            throw new TypeError('sessionId is required');
+          }
+          const generation = sessionGenerations.get(sessionId)
+            ?? workspaces.generationFor(botId);
+          // Transfer the mutable provenance entry into this immutable handle.
+          // A later handle for the same id captures its own generation instead
+          // of sharing deletion or rebinding state with this call.
+          sessionGenerations.delete(sessionId);
+          const isCurrentSession = () => isCurrentScope()
+            && generation === workspaces.generationFor(botId);
+          return Object.freeze({
+            sessionId,
+            async sessionExists(...args) {
+              if (!isCurrentSession()) return false;
+              const exists = await target.sessionExists(sessionId, ...args);
+              return isCurrentSession() && exists;
+            },
+            ask(...args) {
+              if (!isCurrentSession()) {
+                throw workspaceSessionStale(
+                  'The bot workspace changed before this prompt started.',
+                );
+              }
+              return target.ask(sessionId, ...args);
+            },
+          });
+        };
+      }
       if (property === 'sessionExists') {
         return (sessionId, ...args) => {
           if (!isCurrentScope()) return false;

package/src/channels/shared/harness-session-binding.mjs

@@ -0,0 +1,110 @@
+import { isAbsolute } from 'node:path';
+
+const MAX_SESSION_ID_LENGTH = 256;
+const UNSAFE_SESSION_ID = /[\p{White_Space}\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u;
+const UNSAFE_WORKSPACE_PATH = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u;
+
+function bindingError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+function validatedSessionId(value) {
+  if (typeof value !== 'string' || !value || value.length > MAX_SESSION_ID_LENGTH
+    || UNSAFE_SESSION_ID.test(value)) {
+    throw bindingError('session-id-invalid', 'A non-empty, safe session id is required');
+  }
+  return value;
+}
+
+function sessionWorkspace(sessionId, value) {
+  if (!Array.isArray(value?.items) || !Array.isArray(value?.archivedSessionIds)
+    || value.archivedSessionIds.some((id) => typeof id !== 'string' || !id)) {
+    throw new Error('Harness returned an invalid response for workspace.list');
+  }
+
+  const owners = [];
+  for (const workspace of value.items) {
+    if (typeof workspace?.workspaceId !== 'string' || !workspace.workspaceId
+      || typeof workspace.path !== 'string' || !isAbsolute(workspace.path)
+      || !Array.isArray(workspace.sessionIds)
+      || workspace.sessionIds.some((id) => typeof id !== 'string' || !id)) {
+      throw new Error('Harness returned an invalid response for workspace.list');
+    }
+    for (const accountedId of workspace.sessionIds) {
+      if (accountedId === sessionId) owners.push(workspace);
+    }
+  }
+
+  if (owners.length === 0) {
+    throw bindingError('session-not-registered', 'The session is not registered to a Harness workspace');
+  }
+  if (owners.length !== 1) {
+    throw bindingError(
+      'session-workspace-ambiguous',
+      'The session is registered to more than one Harness workspace',
+    );
+  }
+  if (UNSAFE_WORKSPACE_PATH.test(owners[0].path)) {
+    throw new Error('Harness returned an unsafe workspace path for the session');
+  }
+  return {
+    workspace: owners[0],
+    archived: value.archivedSessionIds.includes(sessionId),
+  };
+}
+
+function sessionSummary(sessionId, value) {
+  if (!Array.isArray(value?.items)
+    || value.items.some((item) => typeof item?.sessionId !== 'string' || !item.sessionId)) {
+    throw new Error('Harness returned an invalid response for session.list');
+  }
+  const matches = value.items.filter((item) => item.sessionId === sessionId);
+  if (matches.length === 0) {
+    throw bindingError('session-summary-unavailable', 'The session is no longer available from Harness');
+  }
+  if (matches.length !== 1) {
+    throw new Error('Harness returned duplicate session summaries for session.list');
+  }
+
+  const [summary] = matches;
+  if (summary.origin === 'subagent') {
+    throw bindingError(
+      'session-subagent-unsupported',
+      'Subagent sessions cannot be adopted as a bot conversation',
+    );
+  }
+  if (summary.origin !== undefined) {
+    throw new Error('Harness returned an invalid session origin for session.list');
+  }
+  const title = summary.projections?.values?.title;
+  if (title !== undefined && title !== null && typeof title !== 'string') {
+    throw new Error('Harness returned an invalid session title for session.list');
+  }
+  return { title: typeof title === 'string' ? title : null };
+}
+
+export async function adoptRegisteredWorkspaceSession(client, value, options = {}, timeoutMs = 30_000) {
+  const sessionId = validatedSessionId(value);
+  await client.ensureRunning(options);
+  const workspaceList = await client.rpc('workspace.list', {}, timeoutMs, options);
+  const { workspace, archived } = sessionWorkspace(sessionId, workspaceList);
+  const summary = sessionSummary(
+    sessionId,
+    await client.rpc('session.list', {}, timeoutMs, options),
+  );
+  const adopted = await client.rpc('session.create', {
+    workspaceId: workspace.workspaceId,
+    sessionId,
+  }, timeoutMs, options);
+  if (!adopted || adopted.sessionId !== sessionId) {
+    throw new Error('Harness returned an invalid response for session.create');
+  }
+  return {
+    sessionId,
+    workspace: workspace.path,
+    title: summary.title,
+    archived,
+  };
+}

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

@@ -102,6 +102,8 @@ export class TextHarnessBridge {
           '/new  开启一个全新会话',
           '/workspace 工作区绝对路径  切换工作区',
           '/workspacelist  列出工作区绝对路径',
+          '/sessionlist [工作区序号或绝对路径]  列出会话 ID 和标题',
+          '/session Session ID  将当前聊天绑定到指定会话',
           '/status  检查连接状态',
           '/help  显示本帮助',
         ].join('\n'));
@@ -114,7 +116,8 @@ export class TextHarnessBridge {
         await this.#state.markSeen(messageId);
         return;
       }
-      const workspaceCommand = await runWorkspaceCommand(text, this.#harness);
+      const conversationKey = `${message.kind}:${message.conversationId}`;
+      const workspaceCommand = await runWorkspaceCommand(text, this.#harness, conversationKey);
       if (workspaceCommand) {
         for (const reply of workspaceCommand.messages ?? [workspaceCommand.message]) {
           await this.#bot.sendText(target, reply);
@@ -122,7 +125,6 @@ export class TextHarnessBridge {
         await this.#state.markSeen(messageId);
         return;
       }
-      const conversationKey = `${message.kind}:${message.conversationId}`;
       if (command === '/new') {
         await this.#state.clearSession(conversationKey);
         await this.#bot.sendText(target, '已开启新会话。请发送你的问题。');