@sidleo3/dsh-chat 0.0.4

package/host/prompt-context.mjs

@@ -0,0 +1,70 @@
+/**
+ * 把"本会话的增强提示词"注入成**系统提示词的一段**（而不是拼在用户消息前面）。
+ *
+ * 背景：`dsh-chat` 早先是把提示词块 `<dsh_im_source_guidance>…</dsh_im_source_guidance>`
+ * 拼在飞书那条消息的正文前面，于是它成了**用户轮次的内容**——每轮重复、占用户消息的上下文、
+ * 还可能被模型当成"用户说的话"。现在改成 DSH 的系统提示词段（system 角色），
+ * 用户消息里只剩真正的来源块 `<dsh_im_source>{…}</dsh_im_source>`。
+ *
+ * 作用域：段是**全局注册**的，但文本是**按 agent 求值**的（`AssembleContext.agent`），
+ * 所以只有我们自己的会话（`guidance` 登记表里有值的那种）才会渲染出内容——
+ * 这台 Host 上其它会话（Web 聊天、子代理…）拿到的还是空字符串，等价于没这一段。
+ * 不用 `agent.ctx` 逐 agent 注册：全局一份 + 按 agent 过滤更简单，也不会随 agent 生死来回注册。
+ *
+ * 顺序：400——排在部署 persona（0）之后、第一方政策（500+）与工具指导（1000+）之前。
+ * 这类"在这个群里该怎么说话"的上下文不该盖过第一方政策，所以放在它们前面。
+ *
+ * @module dsh-chat/host/prompt-context
+ */
+
+/** 段名（全局唯一；同名重复注册会抛）。 */
+export const SOURCE_GUIDANCE_SECTION = 'dsh-chat:source-guidance';
+
+/** 段顺序（见文件头的取舍）。 */
+export const SOURCE_GUIDANCE_ORDER = 400;
+
+/**
+ * 从一次组装的上下文里取会话 id。
+ *
+ * `AssembleContext.agent` 由 `dsh-agent` 扩展提供；诊断类组装可能没有 agent。
+ *
+ * @param context - 组装上下文 `{ agent? }`。
+ * @returns 会话 id 或 null。
+ */
+function sessionIdOf(context) {
+  const agent = context?.agent;
+  const id = agent?.id ?? agent?.session?.id;
+  return typeof id === 'string' && id ? id : null;
+}
+
+/**
+ * 注册"增强提示词"这一段。
+ *
+ * @param ctx - Cordis host 上下文。
+ * @param guidance - `createGuidanceRegistry()` 的登记表。
+ * @param options - { logger }。
+ * @returns 是否真的装上了（false = 当前 Host 没有 `systemPrompt`，调用方要退回前缀注入）。
+ */
+export function installSourceGuidanceSection(ctx, guidance, { logger = console } = {}) {
+  const systemPrompt = typeof ctx?.get === 'function' ? ctx.get('systemPrompt') : ctx?.systemPrompt;
+  if (!systemPrompt || typeof systemPrompt.section !== 'function') return false;
+  const register = () => systemPrompt.section({
+    name: SOURCE_GUIDANCE_SECTION,
+    order: SOURCE_GUIDANCE_ORDER,
+    // 文本按 agent 现算：登记表里没有这个会话就返回空，空段在渲染时会被丢掉。
+    text: (context) => {
+      const sessionId = sessionIdOf(context);
+      return (sessionId && guidance.get(sessionId)) || '';
+    },
+  });
+  try {
+    if (typeof ctx?.effect === 'function') ctx.effect(register, 'dsh-chat: 增强提示词段');
+    else register();
+  } catch (error) {
+    // 注册失败（ctx 已销毁 / 同名段已存在）：当作没装上，由调用方退回前缀注入。
+    logger.warn?.(`[dsh-chat] 注册增强提示词段失败：${error?.message ?? error}`);
+    return false;
+  }
+  logger.info?.('[dsh-chat] 增强提示词走系统提示词段（按会话生效，不再拼进用户消息）。');
+  return true;
+}

package/host/rpc.mjs

@@ -0,0 +1,147 @@
+/**
+ * hub 的 RPC 载体：把每个渠道挂到 `/api/dsh-chat/<channelId>`，
+ * hub 自身的控制端点挂在 `/api/dsh-chat/control`。
+ *
+ * 线路格式与 DSH Connection 的客户端 RPC 载体一致（浏览器侧用
+ * `connection.rpc.call('/api', 'dsh-chat/<channelId>', { method, payload })`）：
+ *
+ *   请求  { type:'client-request', rpcId, method:'dsh-chat/<channelId>', payload:{ method, payload } }
+ *   响应  { type:'server-response', rpcId, result: { ok:true, value } | { ok:false, error } }
+ *
+ * @module dsh-chat/host/rpc
+ */
+
+import { RPC_PREFIX } from '../shared/contract.mjs';
+
+/**
+ * @param channelId - 渠道 id（或控制端点 id）。
+ * @returns 浏览器侧端点名，如 `dsh-chat/feishu`。
+ */
+export function rpcEndpoint(channelId) {
+  return `${RPC_PREFIX}/${channelId}`;
+}
+
+/**
+ * @param channelId - 渠道 id。
+ * @returns host 侧精确路由路径，如 `/api/dsh-chat/feishu`。
+ */
+export function rpcPath(channelId) {
+  return `/api/${rpcEndpoint(channelId)}`;
+}
+
+/**
+ * 成功结果。
+ *
+ * @param value - 可 JSON 序列化的返回值。
+ * @returns 结果对象。
+ */
+export function ok(value) {
+  return { ok: true, value };
+}
+
+/**
+ * 失败结果。
+ *
+ * @param code - 稳定错误码。
+ * @param message - 面向用户的中文说明。
+ * @param details - 附加信息（不得含凭据）。
+ * @returns 结果对象。
+ */
+export function fail(code, message, details = {}) {
+  return { ok: false, error: { code, message, details } };
+}
+
+/** 把任意异常折成失败结果。 */
+export function failFrom(error, fallbackCode = 'chat/internal') {
+  const code = typeof error?.code === 'string' ? error.code : fallbackCode;
+  const message = typeof error?.message === 'string' && error.message
+    ? error.message
+    : '聊天插件内部错误。';
+  return fail(code, message);
+}
+
+function jsonResponse(rpcId, result) {
+  // 旧端点可能省略 details，客户端要求该字段存在。
+  const value = result?.ok === false
+    ? { ...result, error: { ...result.error, details: result.error?.details ?? {} } }
+    : result;
+  return Response.json({ type: 'server-response', rpcId, result: value });
+}
+
+/**
+ * 创建 RPC 载体。
+ *
+ * @param ctx - host 插件上下文（需要 connection.fetch.register）。
+ * @param options - { logger }。
+ * @returns { register, registered, disposeAll }。
+ */
+export function createRpcCarrier(ctx, { logger = console } = {}) {
+  if (typeof ctx?.connection?.fetch?.register !== 'function') {
+    throw new TypeError('dsh-chat 需要 DSH 的 connection.fetch 注册表。');
+  }
+  const releases = new Map();
+
+  function register(channelId, handler) {
+    const path = rpcPath(channelId);
+    const endpoint = rpcEndpoint(channelId);
+    if (releases.has(path)) throw new Error(`RPC 路径 ${path} 已被注册。`);
+    if (typeof handler !== 'function') throw new TypeError('RPC handler 必须是函数。');
+
+    const dispose = ctx.connection.fetch.register({
+      path,
+      methods: ['POST'],
+      requestBody: 'buffered',
+      async fetch(request) {
+        // DSH 已在本处理器之前完成浏览器鉴权与 Host/Origin 信任校验。
+        if (request.method !== 'POST') return new Response('method not allowed', { status: 405 });
+        const contentType = request.headers.get('content-type')?.split(';', 1)[0].trim().toLowerCase();
+        if (contentType !== 'application/json') {
+          return new Response('content type must be application/json', { status: 415 });
+        }
+        let message;
+        try {
+          message = await request.json();
+        } catch {
+          return new Response('body is not JSON', { status: 400 });
+        }
+        const rpcId = typeof message?.rpcId === 'string' ? message.rpcId : 'invalid-request';
+        const call = message?.payload;
+        if (message?.type !== 'client-request' || typeof message.rpcId !== 'string'
+          || message.method !== endpoint || call === null || typeof call !== 'object'
+          || Array.isArray(call) || typeof call.method !== 'string'
+          || !Object.hasOwn(call, 'payload')) {
+          return jsonResponse(rpcId, fail('chat/bad-request', '无效的聊天插件管理请求。'));
+        }
+        try {
+          return jsonResponse(rpcId, await handler(call.method, call.payload, request.signal));
+        } catch (error) {
+          logger.warn?.(`[dsh-chat] ${endpoint} 处理 ${call.method} 失败：${error?.message ?? error}`);
+          return jsonResponse(rpcId, failFrom(error));
+        }
+      },
+    });
+
+    const release = () => {
+      if (!releases.delete(path)) return;
+      try {
+        dispose?.();
+      } catch {
+        // 已经释放过就算了。
+      }
+    };
+    releases.set(path, release);
+    return release;
+  }
+
+  return {
+    register,
+    /** @returns 已注册的路径数。 */
+    get registered() {
+      return releases.size;
+    },
+    /** 释放全部路由（插件卸载时）。 */
+    disposeAll() {
+      for (const release of [...releases.values()]) release();
+    },
+  };
+}

package/host/session-keys.mjs

@@ -0,0 +1,25 @@
+/**
+ * 会话键（`p2p:<平台 id>` / `group:<平台 id>`）的小工具。
+ *
+ * 单独一个模块：面板与命令都要把会话键说成人话，而它们之间不该互相 import。
+ *
+ * @module dsh-chat/host/session-keys
+ */
+
+/**
+ * 会话键的人话名字（`p2p:ou_x` → 「私聊 ou_x」/`group:oc_y` → 「群 oc_y」）。
+ *
+ * 键里的 id 是**平台 id**：hub 拿不到昵称（那是渠道的事），所以只给类型 + 掩码 id——
+ * 用户要照它去找到那个聊天，够用，也不编造。
+ *
+ * @param key - 会话键。
+ * @returns 一行说明。
+ */
+export function chatKeyLabel(key) {
+  const raw = typeof key === 'string' ? key : '';
+  const [kind, id = ''] = raw.split(':', 2);
+  const masked = id.length > 12 ? `${id.slice(0, 12)}…` : id;
+  if (kind === 'p2p') return `私聊 ${masked}`;
+  if (kind === 'group') return `群 ${masked}`;
+  return raw || '未知聊天';
+}

package/host/session-store.mjs

@@ -0,0 +1,187 @@
+/**
+ * IM 会话 ↔ DSH 会话的绑定表（hub 所有）。
+ *
+ * 渠道只提供"会话键"（飞书 `p2p:ou_xxx` / `group:oc_xxx`，微信 `p2p:<user>@im.wechat`），
+ * 由 hub 统一维护到 Session id 的映射，因此每个渠道不必各写一份状态文件。
+ *
+ * 旧实现（dsh-im）的绑定存在渠道自己的 `state.json` 里，渠道加载时用 `adopt()`
+ * 把它们灌进来即可继续沿用原会话。
+ *
+ * @module dsh-chat/host/session-store
+ */
+
+import { join } from 'node:path';
+
+import { createJsonStore } from './json-store.mjs';
+
+const DOCUMENT_VERSION = 1;
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function normalizeDocument(value) {
+  const source = isPlainObject(value) && value.version === DOCUMENT_VERSION ? value : {};
+  const channels = {};
+  if (isPlainObject(source.channels)) {
+    for (const [channelId, bots] of Object.entries(source.channels)) {
+      if (!isPlainObject(bots)) continue;
+      const accounts = {};
+      for (const [botId, keys] of Object.entries(bots)) {
+        if (!isPlainObject(keys)) continue;
+        const entries = {};
+        for (const [key, entry] of Object.entries(keys)) {
+          const sessionId = typeof entry?.sessionId === 'string' ? entry.sessionId : null;
+          if (!sessionId) continue;
+          entries[key] = {
+            sessionId,
+            workspacePath: typeof entry.workspacePath === 'string' ? entry.workspacePath : null,
+            boundAt: typeof entry.boundAt === 'string' ? entry.boundAt : null,
+          };
+        }
+        accounts[botId] = entries;
+      }
+      channels[channelId] = accounts;
+    }
+  }
+  return { version: DOCUMENT_VERSION, channels };
+}
+
+/**
+ * 创建会话绑定表。
+ *
+ * @param options - { dataDir, logger }。
+ * @returns 绑定表 API。
+ */
+export function createSessionStore({ dataDir, logger = console } = {}) {
+  if (typeof dataDir !== 'string' || !dataDir.trim()) {
+    throw new TypeError('session store 需要 dataDir。');
+  }
+  const store = createJsonStore({
+    path: join(dataDir, 'sessions.json'),
+    normalize: normalizeDocument,
+    empty: () => ({ version: DOCUMENT_VERSION, channels: {} }),
+    logger,
+    label: '会话绑定',
+  });
+
+  function entriesOf(channelId, botId) {
+    return store.snapshot().channels?.[channelId]?.[botId] ?? {};
+  }
+
+  return {
+    path: store.path,
+    ready: () => store.ready(),
+    subscribe: (listener) => store.subscribe(listener),
+
+    /**
+     * @returns 绑定记录，未绑定时为 undefined。
+     */
+    get(channelId, botId, key) {
+      const entry = entriesOf(channelId, botId)[key];
+      return entry ? Object.freeze({ ...entry }) : undefined;
+    },
+
+    /** @returns 某个机器人的全部绑定（key → entry）。 */
+    entries(channelId, botId) {
+      return Object.freeze({ ...entriesOf(channelId, botId) });
+    },
+
+    /**
+     * 绑定（或更新）一个会话键。
+     *
+     * @param channelId - 渠道 id。
+     * @param botId - 机器人 id。
+     * @param key - 渠道侧会话键。
+     * @param entry - { sessionId, workspacePath? }。
+     */
+    async bind(channelId, botId, key, entry) {
+      if (typeof key !== 'string' || !key) throw new TypeError('会话键必填。');
+      if (typeof entry?.sessionId !== 'string' || !entry.sessionId) {
+        throw new TypeError('绑定需要 sessionId。');
+      }
+      await store.update((current) => ({
+        ...current,
+        channels: {
+          ...current.channels,
+          [channelId]: {
+            ...(current.channels[channelId] ?? {}),
+            [botId]: {
+              ...((current.channels[channelId] ?? {})[botId] ?? {}),
+              [key]: {
+                sessionId: entry.sessionId,
+                workspacePath: typeof entry.workspacePath === 'string' ? entry.workspacePath : null,
+                boundAt: new Date().toISOString(),
+              },
+            },
+          },
+        },
+      }));
+    },
+
+    /** 解除一个会话键的绑定（下一条消息开新会话）。 */
+    async unbind(channelId, botId, key) {
+      await store.update((current) => {
+        const accounts = current.channels[channelId];
+        const keys = accounts?.[botId];
+        if (!keys || !Object.hasOwn(keys, key)) return null;
+        const nextKeys = { ...keys };
+        delete nextKeys[key];
+        return {
+          ...current,
+          channels: { ...current.channels, [channelId]: { ...accounts, [botId]: nextKeys } },
+        };
+      });
+    },
+
+    /**
+     * 一次性接管旧实现的绑定（只补空缺，不覆盖已有绑定）。
+     *
+     * @param channelId - 渠道 id。
+     * @param botId - 机器人 id。
+     * @param entries - `{ [key]: sessionId | { sessionId, workspacePath? } }`。
+     * @returns 实际接管的条数。
+     */
+    async adopt(channelId, botId, entries) {
+      if (!isPlainObject(entries)) throw new TypeError('adopt 需要 { key: sessionId } 形式。');
+      let adopted = 0;
+      await store.update((current) => {
+        const accounts = current.channels[channelId] ?? {};
+        const keys = { ...(accounts[botId] ?? {}) };
+        for (const [key, value] of Object.entries(entries)) {
+          if (!key || keys[key]) continue;
+          const sessionId = typeof value === 'string' ? value : value?.sessionId;
+          if (typeof sessionId !== 'string' || !sessionId) continue;
+          keys[key] = {
+            sessionId,
+            workspacePath: isPlainObject(value) && typeof value.workspacePath === 'string'
+              ? value.workspacePath
+              : null,
+            boundAt: new Date().toISOString(),
+          };
+          adopted += 1;
+        }
+        if (adopted === 0) return null;
+        return {
+          ...current,
+          channels: { ...current.channels, [channelId]: { ...accounts, [botId]: keys } },
+        };
+      });
+      return adopted;
+    },
+
+    /** 该 Session 属于哪个 (渠道, 机器人, 会话键)——审批/提问回传时用。 */
+    locate(sessionId) {
+      if (typeof sessionId !== 'string' || !sessionId) return undefined;
+      const channels = store.snapshot().channels ?? {};
+      for (const [channelId, accounts] of Object.entries(channels)) {
+        for (const [botId, keys] of Object.entries(accounts)) {
+          for (const [key, entry] of Object.entries(keys)) {
+            if (entry.sessionId === sessionId) return Object.freeze({ channelId, botId, key });
+          }
+        }
+      }
+      return undefined;
+    },
+  };
+}