dsh-plugin-tool-management 0.9.1 → 0.11.0

package/lib/http-fence.js

@@ -21,9 +21,12 @@ const headerValue = (req, name) => {
 /**
  * 判定请求是否应被拒（返回 null = 放行）。
  *
- * 优先用宿主栅栏；它不在场时（非 web 组合、服务未注册）退回等价的本地判定，
- * 而不是静默放行。栅栏自身抛错时同样退回本地判定 —— 宁可拒绝也不要因为宿主
- * 内部变动而变成开放路由。
+ * 优先用宿主栅栏；它不在场时（非 web 组合、服务未注册）退回**本地最小判定**，而不是静默放行。
+ * 栅栏自身抛错时同样退回本地判定 —— 但这句**不是**"宁可拒绝"：本地链不含 cookie 鉴权，
+ * 于是丢掉的恰好是宿主栅栏比本地判定多出来的那一层。无 Origin 的非浏览器请求只要带上
+ * `Host: localhost` 就能过（本机任意进程都做得到），而写 op 里包含 `mcpm-add`（宿主 stdio
+ * 传输会按 command/args spawn 它）与 `history-delete`（永久删除会话）。
+ * 准确的说法是：退回一个**不依赖宿主内部**的判定 —— 仍要求回环 Host，但没有会话凭证。
  *
  * @param req - Node 请求对象（只读 headers）。
  * @param connection - ctx.get('connection')，可缺失。
@@ -71,24 +74,41 @@ export function fenceRejection(req, connection) {
     }
     return null;
 }
+// 令牌相关的拒绝文案**只有这一句**，所有出口都引用它（用户裁定 2026-09-18：
+// 「这些关于密钥没填的提示词应该统一文案」；2026-09-19 再简化成一句话）。
+//
+// 2026-09-19 晚再去掉"去哪儿填、点什么"那两句（用户截图：提示条在好几个地方都折成两行）——
+// 提示条右侧本来就挂着「填写令牌」按钮，把按钮名念一遍等于同一件事在一行里说两遍，还占掉
+// 一整行的宽度。这一句只说"缺什么 / 错在哪"，动作交给那颗按钮；它跳到哪、填完什么状态，
+// 由兼容页的胶囊与三行自己说。**不要再往这句里加指引**：契约测试钉着它的长度。
+//
+// 为什么必须同源：同一个"没填令牌"会在四个地方冒出来（宿主写门禁、明文门禁的两条分支、
+// 界面的错误码词典），此前各写一套 —— 截图里同一件事出现了三种说法，用户无法判断它们
+// 是不是同一件事。界面靠**文本相等**识别这句话（见 client.js 的 isTokenGateText），
+// 所以改这句必须同时改界面词典里的那三个键。
+export const TOKEN_MSG = '缺少访问令牌，或令牌不对';
+/**
+ * 界面按 code 在最右侧挂「填写令牌」跳转按钮（这一族里的 code 都算）。
+ *
+ * 2026-09-19 之后 `secretOpRejection` **不再产生** NO_HOST（没配令牌就直接放行，见上），
+ * 但常量与界面词典里的 `error.secret.noToken` 都留着：宿主没重启时旧响应里还可能出现它，
+ * 而界面同时按 code 与**文本相等**两条路识别这一族（见 client.js 的 isTokenGateText）。
+ */
+export const TOKEN_CODE_NO_HOST = 'error.secret.noToken';
+export const TOKEN_CODE_BAD = 'error.token.required';
 /**
  * 判定敏感 op 是否应被拒（返回 null = 放行）。
  *
- * 两种情况分开报，因为处置方式不同：没配令牌要去宿主配置里加，配了但没带/带错
- * 只要在界面里填对即可（界面按 code 决定给不给输入框）。
+ * 没配令牌 ⇒ 放行（与写门禁同一激活条件，理由见上方段落）。有令牌 ⇒ 必须带对的。
+ *
+ * 两个 code 仍然分开报：界面用不到（话已经一样了），但日志与排查需要区分
+ * 「宿主根本没配令牌」与「这次带的令牌不对」—— 前者是配置问题，后者是输入问题。
  */
 export function secretOpRejection(state) {
-    if (!state.tokenConfigured) {
-        return {
-            code: 'error.secret.noToken',
-            error: '明文查看与导出已被禁用：宿主未配置访问令牌。请在本插件配置里加 token（或设环境变量 DSH_PLUGIN_TOOL_MANAGEMENT_TOKEN）后重启 DSH，再在界面上填入同一个令牌。',
-        };
-    }
+    if (!state.tokenConfigured)
+        return null;
     if (!state.tokenAccepted) {
-        return {
-            code: 'error.secret.badToken',
-            error: '访问令牌缺失或不正确：请在界面里填入与宿主配置相同的令牌（随请求以 x-dsh-token 发送）。',
-        };
+        return { code: TOKEN_CODE_BAD, error: TOKEN_MSG };
     }
     return null;
 }

package/lib/hub.js

@@ -24,7 +24,13 @@
 //   ├─ mcp-disabled-tools.json | mcp-known-tools.json | mcp-notes.json | mcp-settings.json | mcp-export.json
 //   ├─ tool-management.log                               插件日志（滚动 .1）
 //   ├─ backups/cordis.patch.yml.bak-<时间戳>             改宿主 patch 前的备份
-//   └─ trash/{skills,subagents,prompts,scenes,memories}-trash/<id>/
+//   ├─ trash/{skills,subagents,prompts,scenes}-trash/<id>/  回收站（除记忆外的四类）
+//   └─ memories-trash/<id>/                              记忆回收站（**hub 根下独立目录**）
+//
+// 记忆回收站**不在 `trash/` 下**（本机实测 `trash/` 只有 4 个 `-trash` 目录）：它走
+// `memories/service.ts` 自己的路径（`join(stateDir, 'memories-trash', id)`，stateDir = hub 根），
+// 不经本模块的 `moveToTrash`。此前这行把它画进 `trash/{…}` 里，按它写备份/迁移脚本会既漏搬
+// 又误判（那是一类真实存在、条目数最多的用户数据）。
 //
 // 留在 `$DSH_HOME` 根下的两个文件**不是**插件的：`AGENTS.md`（宿主每轮读取的全局基线，
 // 插件只是按场景/预设写它）与 `cordis.patch.yml`（宿主加载插件的配置入口）。
@@ -116,7 +122,9 @@ export function migrateHubLayoutSync(home = resolveDshHome()) {
         }
     };
     // ① 更早的 hub 目录名（插件叫 dsh-skill-mcp-manager 的时期）：**先**逐项并入 hub，
-    //    让下面 ② 的改名也覆盖从旧目录搬进来的那些（同名保留 hub 里已有的那份）。
+    //    让下面 ② 的改名也覆盖从旧目录搬进来的那些（同名保留 hub 里已有的那份 ——
+    //    move 对已存在目标跳过且旧份不删：合并是「只进不覆盖」，滞留旧目录的条目
+    //    不丢失但也不可见，清掉旧目录即可整体放弃）。
     for (const legacyHub of ['dsh-plugin-tool-management', 'skill-mcp-manager']) {
         const from = join(home, legacyHub);
         try {
@@ -363,14 +371,34 @@ export async function listTrashEntries(kind) {
 export async function readTrashEntry(kind, id) {
     return await readManifest(kind, id);
 }
+/**
+ * 条目里的一个负载名是不是"就在这个条目目录里"。
+ *
+ * 为什么 id 与场景名都有谓词、这里还得多一道：`manifest.json` 的 `files[]` 是**磁盘上的数据**，
+ * 它跟 id 不一样 —— id 只由本模块生成（`isValidTrashId` 严格白名单），而 files 可能来自
+ * 用户手改、别的进程、或一份被塞进来的恶意档案包。不校验就 `join(dir, dest)` 等于给了
+ * "任意相对路径读源 + 任意绝对目录建目标"的能力（`mkdir(dirname(to))` 会顺手把目录建出来）。
+ */
+export function isValidTrashPayloadName(dest) {
+    const text = String(dest ?? '');
+    if (!text || text.startsWith('.') || text.includes('\0'))
+        return false;
+    if (/[\\/]/.test(text))
+        return false;
+    if (text === 'manifest.json')
+        return false;
+    return true;
+}
 /**
  * 把条目里的一个负载搬回 `to`。**不覆盖**：调用方必须先确认 `to` 不存在。
- * @throws 条目或负载缺失时抛错（调用方翻成人话）。
+ * @throws 条目、负载名或负载缺失时抛错（调用方翻成人话）。
  */
 export async function moveOutOfTrash(kind, id, dest, to) {
     const dir = trashEntryPath(kind, id);
     if (dir === null)
         throw new Error(`回收站条目 id 非法：${id}`);
+    if (!isValidTrashPayloadName(dest))
+        throw new Error(`回收站负载名非法：${dest}`);
     const from = join(dir, dest);
     await mkdir(dirname(to), { recursive: true });
     try {

package/lib/imports/parsers.js

@@ -18,19 +18,22 @@ export function extractText(content) {
             if (typeof part === 'string')
                 out += part;
             else if (part && typeof part === 'object') {
-                if (typeof part.text === 'string')
-                    out += part.text;
-                else if (typeof part.content === 'string')
-                    out += part.content;
+                // JSON 块的实际形状由下方 typeof 运行时比较决定，这里按记录形状读取字段
+                const record = part;
+                if (typeof record.text === 'string')
+                    out += record.text;
+                else if (typeof record.content === 'string')
+                    out += record.content;
             }
         }
         return out;
     }
     if (content && typeof content === 'object') {
-        if (typeof content.text === 'string')
-            return content.text;
-        if (typeof content.content === 'string')
-            return content.content;
+        const record = content;
+        if (typeof record.text === 'string')
+            return record.text;
+        if (typeof record.content === 'string')
+            return record.content;
     }
     return '';
 }
@@ -58,6 +61,7 @@ export function detectFormat(fileName, content) {
     const first = String(content || '').split(/\r?\n/).map((s) => s.trim()).find((s) => s) || '';
     if (first.startsWith('{')) {
         try {
+            // JSON 值实际形状未知；若为对象，type/role 字段由下方运行时比较判定
             const obj = JSON.parse(first);
             if (obj && typeof obj === 'object' && (obj.type === 'user' || obj.type === 'assistant' || obj.role === 'user' || obj.role === 'assistant'))
                 return 'jsonl';
@@ -83,6 +87,7 @@ export function parseJsonlTranscript(text) {
         const line = raw.trim();
         if (!line)
             continue;
+        // JSONL 每行的实际形状未知；字段有效性由下方运行时比较判定
         let obj;
         try {
             obj = JSON.parse(line);
@@ -95,7 +100,7 @@ export function parseJsonlTranscript(text) {
         let role = null;
         let content;
         if (obj.type === 'user' || obj.type === 'assistant') {
-            const message = obj.message && typeof obj.message === 'object' && !Array.isArray(obj.message) ? obj.message : null;
+            const message = (obj.message && typeof obj.message === 'object' && !Array.isArray(obj.message) ? obj.message : null);
             role = message && (message.role === 'user' || message.role === 'assistant') ? message.role : (obj.type === 'user' ? 'user' : 'assistant');
             content = message ? message.content : undefined;
         }
@@ -112,6 +117,7 @@ export function parseJsonlTranscript(text) {
             lastText += '\n' + piece;
         }
         else {
+            // lastText 非空 ⇒ lastRole 已随 lastText 同步赋值（非 null），类型层无法表达该不变式
             if (lastText)
                 turns.push({ role: lastRole, text: lastText });
             lastRole = role;

package/lib/imports/upload.js

@@ -3,12 +3,28 @@
 // 场景记忆（~/.dsh/tool-management/memories/<场景>/<名>.md；场景留空 = 保留场景 global）。
 // 约定：只认 .md；zip 内任意层级；隐藏项 / 绝对路径 / `..` 穿越 / 超限条目一律跳过并回报；
 //       重名策略（跳过 or 覆盖）不在这里实现——由调用方按文件系统现状裁决（本项目取「跳过并报告」）。
+//
+// 两条限额的**口径**要分清（2026-09-19 审计 T-09）：`MAX_IMPORT_TOTAL_BYTES` 管的是
+// **上传（编码后）**字节，管不住解压后的体积 —— 一个 8 MiB 条目 × 2000 条 ≈ 16 GiB 会在
+// 单次 `unzipSync` 里被实体化。所以另有 `MAX_IMPORT_UNCOMPRESSED_BYTES` 管**解压后**的
+// 累计量，在 filter 里按档案自报的 `info.originalSize` 累加。
 import { unzipSync } from 'fflate';
+import { isValidSegment } from '../paths.js';
 export const MAX_IMPORT_FILES = 200;
 export const MAX_IMPORT_ENTRY_BYTES = 8 * 1024 * 1024;
+/** 上传（编码后）总量：与传输层的 88 MiB 体限是同一层口径，防止一次请求塞进几百 MiB。 */
 export const MAX_IMPORT_TOTAL_BYTES = 32 * 1024 * 1024;
 export const MAX_IMPORT_ENTRIES = 2000;
 export const MAX_IMPORT_NAME_LENGTH = 64;
+/**
+ * 解压后累计上限（与技能上传器 `MAX_UPLOAD_TOTAL_BYTES = 64 MiB` 同层口径）。
+ *
+ * 为什么必须单列：单条目 8 MiB × 2000 条 ≈ 16 GiB 会在一次 `unzipSync` 里全部展开进内存 ——
+ * 传输层与 `MAX_IMPORT_TOTAL_BYTES` 都只数**压缩后**的字节，一个数不到。
+ * 已知前提：信任档案自报的 `info.originalSize`（fflate 不独立约束输出长度）；谎报只能让
+ * 解压产物比申报的大，**不会**绕过这个上限之前的条目数门禁。
+ */
+export const MAX_IMPORT_UNCOMPRESSED_BYTES = 64 * 1024 * 1024;
 const message = (e) => String((e && e.message) || e);
 /** base64 → 字节；容忍 `data:...;base64,` 前缀。 */
 export function decodeBase64(data) {
@@ -57,6 +73,8 @@ export function expandUploads(files) {
         problems.push({ name: `(其余 ${all.length - MAX_IMPORT_FILES} 个文件)`, reason: `一次最多导入 ${MAX_IMPORT_FILES} 个文件` });
     }
     let total = 0;
+    /** 解压后超限只报一次（与"超条目数"同口径，避免几千条问题刷屏）。 */
+    let uncompressedReported = false;
     for (const raw of list) {
         const file = (raw || {});
         const name = String(file.name || '').trim() || '(未命名)';
@@ -76,6 +94,7 @@ export function expandUploads(files) {
         }
         if (isZipBytes(bytes)) {
             let unzipped;
+            let uncompressed = 0;
             try {
                 let count = 0;
                 unzipped = unzipSync(bytes, {
@@ -95,6 +114,18 @@ export function expandUploads(files) {
                             problems.push({ name: info.name, reason: `zip 内单条目超过 ${MAX_IMPORT_ENTRY_BYTES >> 20} MiB，已跳过` });
                             return false;
                         }
+                        // 解压后累计：单条目与条目数都挡不住「2000 × 8 MiB」这种组合，只有累计量挡得住。
+                        // 目录条目不占解压预算（originalSize 为 0 且不产出内容）。
+                        if (!info.name.endsWith('/')) {
+                            uncompressed += info.originalSize;
+                            if (uncompressed > MAX_IMPORT_UNCOMPRESSED_BYTES) {
+                                if (!uncompressedReported) {
+                                    uncompressedReported = true;
+                                    problems.push({ name: info.name, reason: `zip 解压后合计超过 ${MAX_IMPORT_UNCOMPRESSED_BYTES >> 20} MiB，该条目及其后条目已忽略` });
+                                }
+                                return false;
+                            }
+                        }
                         return true;
                     },
                 });
@@ -120,14 +151,22 @@ export function expandUploads(files) {
             problems.push({ name, reason: '只支持 .md 或 .zip' });
             continue;
         }
-        entries.push({ path: name, bytes });
+        // 非 zip 分支同样要走 `normalizeEntryPath`：客户端给的文件名是**外部输入**，
+        // `"../../x.md"` / `".hidden/x.md"` 直接进 `RawEntry[]` 就把"隐藏项/穿越一律跳过"
+        // 这条承诺交给下游 planner 兜着 —— 本模块的文件头正是这么承诺的（审计 T-10）。
+        // 不变量该由承诺方强制：新增的第三个消费者不该靠"运气好下游也查了"才安全。
+        const normalized = normalizeEntryPath(name);
+        if (!normalized) {
+            problems.push({ name, reason: '路径非法或隐藏项，已跳过' });
+            continue;
+        }
+        entries.push({ path: normalized, bytes });
     }
     return { entries, problems };
 }
-/** 单个名字段（人设名 / 记忆名 / 场景路径的一段）合法性：与宿主侧校验同口径。 */
+/** 单个名字段（人设名 / 记忆名 / 场景路径的一段）合法性：谓词收敛到 `../paths.ts`。 */
 export function isValidImportName(name) {
-    const s = String(name || '');
-    return s.length > 0 && s.length <= MAX_IMPORT_NAME_LENGTH && s === s.trim() && !s.startsWith('.') && !/[\\/<>:"|?*]/.test(s);
+    return isValidSegment(String(name || ''), MAX_IMPORT_NAME_LENGTH);
 }
 /** 场景/分组路径合法性：逐段校验（空串 = 根/全局，合法）。 */
 export function isValidImportGroup(group) {