dsh-plugin-tool-management 0.17.0 → 0.18.5

package/lib/exports/transcript.js

@@ -0,0 +1,223 @@
+// 会话转录导出：把宿主的 SessionEvent[] 提成可再导入的转录文本。
+//
+// 从 src/index.ts 剥出来（0.18.5），同时补上两件事：
+//
+// 1. **按块类型取文本**。宿主的内容块是带 type 标签的联合（dsh-llm types.d.ts:114-122）：
+//    `text` 是用户可见正文，`reasoning` 是思考，`tool-call` 是模型发起的调用。此前导出走
+//    `extractText`，它只判「这个对象有没有 text 字段」—— 而 `ReasoningBlock` 恰好就是
+//    `{type:'reasoning', text}`，所以**思考一直混在助手正文里导出去**。同一类缺陷 0.16.x
+//    已在子智能体侧用 `textOfBlocks` 修过（persona-parse.ts:275），导出侧是它的第二个出口。
+// 2. **导出分三档，且是累进的**：正文 → 另加工具 → 再加思考。每档都是上一档的超集，
+//    所以一个下拉就说得清（两个独立勾选框是另一种答案，用户不要）。
+//    三档仍是**可读转录，不是完整备份**：每块有上限并明说截断，token 统计与压缩结构不在里面。
+//
+// `extractText` 本身不动：它服务的是外部文件导入，那份宽松是故意的（外来转录稿没有
+// `reasoning` 词表可守）。
+import { textOfBlocks } from '../subagents/persona-parse.js';
+// 上限是**病态保护**：工具结果可以是一次几 MB 的文件读取，不设限的话一个会话就能
+// 导出上百 MB。取最靠前的那一段 —— 工具输出的头部几乎总是最有用的那部分。
+const REASONING_MAX = 6000;
+const TOOL_INPUT_MAX = 1000;
+const TOOL_RESULT_MAX = 2000;
+/** 裁到 max 个字符并留下标记。标记固定英文：op 跑在服务端，没有客户端词典可用。 */
+function cap(text, max) {
+    const s = String(text || '');
+    if (s.length <= max)
+        return s;
+    return `${s.slice(0, max)}\n[truncated: showing ${max} of ${s.length} chars]`;
+}
+function str(value) {
+    return typeof value === 'string' ? value : '';
+}
+function blocksOf(content) {
+    return Array.isArray(content) ? content : [];
+}
+function formatBytes(n) {
+    const v = Number(n);
+    if (!Number.isFinite(v) || v < 0)
+        return 'unknown size';
+    if (v < 1024)
+        return `${v} B`;
+    if (v < 1024 * 1024)
+        return `${Math.round(v / 1024)} KB`;
+    return `${(Math.round((v / 1024 / 1024) * 10) / 10).toFixed(1)} MB`;
+}
+/** 附件只报名字 / 类型 / 尺寸 / 字节数 —— `attachmentId` 官方定义为不透明串，进了转录稿只是噪声。 */
+function attachmentLines(content) {
+    const lines = [];
+    for (const block of blocksOf(content)) {
+        const ref = (block.attachment && typeof block.attachment === 'object' ? block.attachment : {});
+        if (block.type === 'image') {
+            const media = str(ref.mediaType) || 'image';
+            const w = Number(ref.width);
+            const h = Number(ref.height);
+            const dims = Number.isFinite(w) && Number.isFinite(h) ? ` ${w}×${h}` : '';
+            const name = str(ref.name);
+            lines.push(`image: ${name ? name + ' — ' : ''}${media}${dims} (${formatBytes(ref.bytes)})`);
+        }
+        else if (block.type === 'file') {
+            lines.push(`file: ${str(ref.name) || '(未命名)'} (${formatBytes(ref.bytes)})`);
+        }
+    }
+    return lines.join('\n');
+}
+function toolLabel(name, kind, failed = false) {
+    return `Tool: ${name} — ${kind}${failed ? ' (failed)' : ''}`;
+}
+/**
+ * 把会话事件提成导出用的轮次。
+ *
+ * 工具的**发起**在两处都有记录：`assistant/message` 里的 `tool-call` 块（模型可见真相），
+ * 与 log-only 的 `tool/call` 事件（持久化记录）。两边都收、按 call id 去重 —— 只认一边
+ * 会在某种宿主形状下静默丢掉全部工具调用，而"导出里看不见工具调用"正是这份文件此前的毛病。
+ * 配不上任何调用的 `tool/result` 也照样单独成段，同样不静默丢。
+ */
+export function extractExportTurns(events, detail) {
+    const wantTools = detail !== 'simple';
+    const wantThinking = detail === 'full';
+    const turns = [];
+    const namesByCallId = new Map();
+    const emittedCallIds = new Set();
+    let current = null;
+    const flush = () => {
+        // 空正文 + 空附加段 = 这一轮什么都没有，不占位。
+        if (current && (current.text || current.details.length))
+            turns.push(current);
+        current = null;
+    };
+    /** 工具细节总归属于助手轮；正文已经翻篇时就另起一轮。 */
+    const openAssistant = () => {
+        if (!current || current.role !== 'assistant') {
+            flush();
+            current = { role: 'assistant', text: '', details: [] };
+        }
+        return current;
+    };
+    for (const event of events || []) {
+        if (!event || typeof event !== 'object')
+            continue;
+        const e = event;
+        const data = (e.data && typeof e.data === 'object' ? e.data : {});
+        if (e.type === 'user/message') {
+            flush();
+            const turn = { role: 'user', text: textOfBlocks(data.content, 'text'), details: [] };
+            // 附件跟工具一起进中间档：它是「对话里出现过什么」的一部分，不是「模型想了什么」。
+            if (wantTools) {
+                const attachments = attachmentLines(data.content);
+                if (attachments)
+                    turn.details.push({ label: 'Attachment', text: attachments });
+            }
+            current = turn;
+            continue;
+        }
+        if (e.type === 'assistant/message') {
+            flush();
+            const message = (data.message && typeof data.message === 'object' ? data.message : {});
+            const turn = { role: 'assistant', text: textOfBlocks(message.content, 'text'), details: [] };
+            // 顺序即模型产出的顺序：先思考、后调用。两档都开时（full）这个次序天然成立，
+            // 因为 full 必然也开 wantTools。
+            if (wantThinking) {
+                const reasoning = textOfBlocks(message.content, 'reasoning');
+                if (reasoning)
+                    turn.details.push({ label: 'Thinking', text: cap(reasoning, REASONING_MAX) });
+            }
+            if (wantTools) {
+                for (const block of blocksOf(message.content)) {
+                    if (block.type !== 'tool-call')
+                        continue;
+                    const id = str(block.id);
+                    const name = str(block.name) || '(unnamed)';
+                    if (id) {
+                        namesByCallId.set(id, name);
+                        emittedCallIds.add(id);
+                    }
+                    turn.details.push({ label: toolLabel(name, 'in'), text: cap(str(block.arguments), TOOL_INPUT_MAX) });
+                }
+            }
+            current = turn;
+            continue;
+        }
+        // 往下只剩工具与结果两类事件，中间档就要，只有简洁档跳过。
+        if (!wantTools)
+            continue;
+        if (e.type === 'tool/call') {
+            const id = str(data.callId);
+            const name = str(data.name) || namesByCallId.get(id) || '(unnamed)';
+            if (id)
+                namesByCallId.set(id, name);
+            // assistant 块里已经列过同一个调用，就别重复成段。
+            if (id && emittedCallIds.has(id))
+                continue;
+            if (id)
+                emittedCallIds.add(id);
+            openAssistant().details.push({ label: toolLabel(name, 'in'), text: cap(str(data.arguments), TOOL_INPUT_MAX) });
+            continue;
+        }
+        if (e.type === 'tool/result') {
+            const message = (data.message && typeof data.message === 'object' ? data.message : {});
+            const id = str(message.toolCallId);
+            const name = namesByCallId.get(id) || '(unknown)';
+            const failed = message.isError === true;
+            const body = textOfBlocks(message.content, 'text');
+            const blocks = blocksOf(message.content);
+            openAssistant().details.push({
+                label: toolLabel(name, 'out', failed),
+                text: cap(body || (blocks.length ? `(无文本输出，${blocks.length} 个内容块)` : '(无输出)'), TOOL_RESULT_MAX),
+            });
+            // `error` 官方注释明说它在模型可见消息之外 —— 带工具的那两档是用户唯一能看到它的地方。
+            const err = (data.error && typeof data.error === 'object' ? data.error : undefined);
+            if (err) {
+                const reason = str(err.reason) || str(err.code) || str(err.name);
+                if (reason)
+                    openAssistant().details.push({ label: toolLabel(name, 'error'), text: cap(`${str(err.name)}/${str(err.code)} — ${reason}`, TOOL_RESULT_MAX) });
+            }
+            continue;
+        }
+    }
+    flush();
+    return turns;
+}
+/**
+ * 把载荷整段缩进 4 空格。
+ *
+ * 这是**回流保护**，不是排版：工具结果可以是任意文件内容，读进一份 markdown 转录稿就会把
+ * 里面的 `## User` 原样吐进助手正文，再导入时把轮次劈开。缩进同时废掉 `HEADING_RE` 与
+ * `BOLD_PREFIX_RE` 两个行首锚点（两者都不允许前导空白）。空行保持真空，不留尾随空格。
+ */
+function indentBlock(text) {
+    return String(text || '')
+        .split('\n')
+        .map((line) => (line.trim() ? `    ${line}` : ''))
+        .join('\n');
+}
+/**
+ * 序列化为可再导入的转录文本：Codex 风格 Markdown 或 Claude Code 风格 JSONL。
+ *
+ * 签名与 0.18.5 之前一致 —— 附加信息全在 `turn.details` 里，所以 `details` 为空时两种输出
+ * 与旧版逐字节相同。`## User` / `### Assistant` 两级标题不能改：导入侧靠它切轮次与嗅探格式。
+ */
+export function serializeTranscript(turns, format) {
+    const list = Array.isArray(turns) ? turns : [];
+    if (format === 'jsonl') {
+        // content 保持**字符串**：改成类型化块数组的话，导入侧的 extractText 会把 reasoning
+        // 又拼回正文（正是我们在修的那个泄漏），并让 tool-call 无声消失 —— 严格劣于字符串。
+        return list
+            .map((turn) => {
+            let content = turn.text;
+            for (const item of turn.details)
+                content += `${content ? '\n\n' : ''}[${item.label}]\n${item.text}`;
+            return JSON.stringify({ type: turn.role, message: { role: turn.role, content } });
+        })
+            .join('\n');
+    }
+    return list
+        .map((turn) => {
+        const head = turn.role === 'user' ? '## User' : '### Assistant';
+        const blocks = [turn.text ? `${head}\n${turn.text}` : head];
+        // 四级标题：`#{1,3}` 匹配不到，所以附加段再导入时只会并入所属轮次，不会伪装成边界。
+        for (const item of turn.details)
+            blocks.push(`#### ${item.label}\n${indentBlock(item.text)}`);
+        return blocks.join('\n\n');
+    })
+        .join('\n\n');
+}

package/lib/http-api.js

@@ -0,0 +1,229 @@
+import { noteRuntime } from './compat/runtime-notes.js';
+import { recordOpAudit } from './audit-log.js';
+import { isReadCall } from './op-registry.js';
+import { TOKEN_CODE_BAD, TOKEN_MSG, fenceRejection, secretOpRejection } from './http-fence.js';
+export function installHttpApi(deps) {
+    // ---------- HTTP API route (UI half), registered defensively ----------
+    if (deps.webServer) {
+        // Cap request bodies (88 MiB): skill-upload carries Base64 folder/ZIP
+        // payloads (64 MiB of raw content). Reachability is decided by
+        // fenceRejection() below — the host's Host/Origin + browser-session fence
+        // (or a correct explicit token). `config.maxBodyBytes` overrides the cap
+        // (tests use a small value).
+        const configuredMaxBody = Number(deps.config?.maxBodyBytes);
+        // 默认 88 MiB：够塞下一份带多张大附件（图片 / PDF）的技能或记忆打包体，又不至于让
+        // 一个失控的客户端把进程内存吃光。`config.maxBodyBytes` 可覆盖（测试用小值）。
+        const DEFAULT_MAX_BODY_BYTES = 88 * 1024 * 1024;
+        const MAX_BODY = Number.isFinite(configuredMaxBody) && configuredMaxBody > 0 ? configuredMaxBody : DEFAULT_MAX_BODY_BYTES;
+        const readBody = (req) => new Promise((resolve, reject) => {
+            // 先看 content-length：注定超限的请求在**读第一个字节之前**就拒掉。以前只能边收边数，
+            // 一个 5 GB 的上传会先让我们缓冲满 88 MiB 才回错。读取流照旧 drain（一个字节都不留），
+            // 否则响应写完后服务端会直接拆连接，客户端可能在上传中途拿到网络错误而不是下面这句 JSON。
+            // 错误消息必须含 `body too large` —— 后面的 catch 靠这个子串分流。
+            const declared = Number(req.headers && req.headers['content-length']);
+            if (Number.isFinite(declared) && declared > MAX_BODY) {
+                const drain = req.resume;
+                if (typeof drain === 'function')
+                    drain.call(req);
+                reject(new Error('request body too large'));
+                return;
+            }
+            // Accumulate Buffers and decode ONCE at the end: decoding each chunk
+            // separately corrupts multi-byte UTF-8 characters that straddle a
+            // chunk boundary (e.g. long Chinese skill bodies).
+            const chunks = [];
+            let size = 0;
+            req.on('data', (c) => {
+                const buf = Buffer.isBuffer(c) ? c : Buffer.from(String(c));
+                size += buf.length;
+                if (size > MAX_BODY) {
+                    reject(new Error('request body too large'));
+                    return;
+                }
+                chunks.push(buf);
+            });
+            req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+            req.on('error', reject);
+        });
+        // 宿主 BrowserAuth 栅栏。宿主的鉴权**只包在它自己注册的路由上**——dsh-host-webserver
+        // 没有全局中间件，既定约定是每个注册方自己调 connection.requestRejection(req)：
+        // 它先做 Host/Origin 栅栏（Host 必须是回环或 deployment 派生的 LAN IP 字面量，
+        // 这是 DNS rebinding 唯一伪造不了的头），再叠加 browser-session cookie 鉴权。
+        // 本插件此前只查公开常量 x-dsh-plugin 与自比对（Origin.host === Host）的 "同源"，
+        // 两者都挡不住 rebind 后的网页或本机任意进程 —— 等于没鉴权。现在优先走宿主栅栏。
+        const connection = (() => {
+            try {
+                return deps.ctx.get('connection');
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        try {
+            // ctx.effect wires the route's disposer into this plugin's scope, so an
+            // unload (HMR removal, disable, update) unregisters the route — the
+            // documented cleanup contract (webServer.register does not auto-scope).
+            deps.ctx.effect(() => deps.webServer.register({
+                kind: 'exact',
+                path: '/dsh-plugin-tool-management/api',
+                handler: async (req, res) => {
+                    // 鉴权顺序：POST-only → 插件门禁头（防误触，不是凭证）→ 宿主栅栏
+                    // （Host/Origin + browser-session cookie）→ 可选访问令牌。令牌是本地工具与
+                    // LAN 部署的逃生门：**令牌正确即视为已授权**，可越过浏览器鉴权。
+                    //
+                    // 「未配置令牌时」别读成"仍有门禁"：下面的写 op 判据是
+                    // `if (TOKEN && WRITE_OPS.has(op))` —— `TOKEN === ''` 时整条短路，79 个写 op
+                    // 只剩 `fenceRejection` 一道。而它自身有两种形态：宿主栅栏在场时含 cookie 鉴权；
+                    // 栅栏缺席或抛错时退回本地判定，**只查回环 Host 与（若给了）Origin 自比对**，
+                    // 没有 cookie 那一层 —— 本机任意进程都能调写 op。所以准确说法是：
+                    // 未配置令牌时不再有「**无栅栏**放行」的缺口，但进程级边界只有配了令牌才有。
+                    const hdr = (name) => {
+                        const v = req.headers?.[name];
+                        return Array.isArray(v) ? v[0] ?? '' : v ?? '';
+                    };
+                    if (String(req.method || 'POST').toUpperCase() !== 'POST') {
+                        res.writeHead(405, { 'content-type': 'application/json' });
+                        res.end(JSON.stringify({ ok: false, error: 'method not allowed' }));
+                        return;
+                    }
+                    if (hdr('x-dsh-plugin') !== 'dsh-plugin-tool-management') {
+                        res.writeHead(403, { 'content-type': 'application/json' });
+                        res.end(JSON.stringify({ ok: false, error: 'missing plugin gate header' }));
+                        return;
+                    }
+                    // 「本次带的这串对不对」比的是**存量**令牌：关掉令牌功能之后仍然要凭它才能开回来、
+                    // 换掉、或看明文（要求 9）。
+                    const tokenAccepted = deps.CONFIG_TOKEN !== '' && deps.tokenMatches(hdr('x-dsh-token'));
+                    // 验过就置闩（本次进程一次即可）。`agent/pre-step` 的令牌门禁读的就是它 ——
+                    // 那一边看不到请求头，只能由这里告诉它"这台机器已经有人验过令牌了"。
+                    if (tokenAccepted)
+                        deps.markAccepted();
+                    if (!tokenAccepted) {
+                        const fence = fenceRejection(req, connection);
+                        if (fence) {
+                            res.writeHead(fence.status, { 'content-type': 'application/json' });
+                            res.end(JSON.stringify({ ok: false, error: fence.error }));
+                            return;
+                        }
+                    }
+                    res.writeHead(200, { 'content-type': 'application/json' });
+                    try {
+                        let payload = {};
+                        try {
+                            payload = JSON.parse((await readBody(req)) || '{}');
+                        }
+                        catch (e) {
+                            if (String(e?.message).includes('body too large')) {
+                                res.end(JSON.stringify({ ok: false, error: '请求体过大' }));
+                                return;
+                            }
+                            /* otherwise fall through with {} */
+                        }
+                        const op = String(payload.op || '');
+                        // 敏感 op（会吐明文密钥与完整配置）：**配了令牌就必须带对的**，没配令牌则不设防
+                        // （判定与理由见 http-fence.ts 的 secretOpRejection —— 用户裁定 2026-09-19：
+                        // 没配令牌时那道门没有出路，用户无从填一个不存在的令牌）。
+                        // 之前这里只查"有没有 Origin 头"，而 token 为空时它形同虚设 —— 任何能
+                        // 打开 GUI 的浏览器都拿得到全部密钥原文。
+                        if (deps.SENSITIVE_OPS.has(op)) {
+                            // 明文门禁看的是**存量**令牌（CONFIG_TOKEN 而不是生效值 TOKEN）：关掉令牌
+                            // 功能之后仍然"要凭存量令牌才给明文"—— 那条路是通的（填对就能看），
+                            // 与"从来没配过"不同。
+                            const gate = secretOpRejection({ tokenConfigured: deps.CONFIG_TOKEN !== '', tokenAccepted });
+                            if (gate) {
+                                res.end(JSON.stringify({ ok: false, error: gate.error, code: gate.code }));
+                                return;
+                            }
+                        }
+                        // 「读改写」两态 op（`inject-settings` / `tool-table` / `scene-settings` /
+                        // `mcpm-settings`）：同一个名字既读又写，于是整条 op 被列进 WRITE_OPS —— 读侧也
+                        // 一起被拦，界面表现是"没填令牌时整块设置消失、填了还要刷新才出现"（2026-09-19
+                        // 用户报的）。判据是**这次调用要不要写**，不是 op 名在不在名单里。
+                        // 判据本身在登记表（`writeWhen`），这里不再手写一份 —— 手写那份只认 `set:true`，
+                        // 于是 `tool-table` 的 `presetSave` / `presetDelete` 被当成读放行，配了令牌也能
+                        // 只凭宿主栅栏改侧车（审查 F2，0.17.0 修）。
+                        const readOnlyCall = isReadCall(op, payload.args);
+                        if (deps.TOKEN && deps.WRITE_OPS.has(op) && !readOnlyCall && !deps.tokenMatches(hdr('x-dsh-token'))) {
+                            // 文案与明文门禁同源（http-fence.ts），code 也统一 —— 界面据此在最右侧挂
+                            // 「去填令牌」跳转按钮。这条错误会出现在**任意**页面，而入口只有一个。
+                            res.end(JSON.stringify({ ok: false, code: TOKEN_CODE_BAD, error: TOKEN_MSG }));
+                            return;
+                        }
+                        // 令牌状态（只读，**不需要**令牌本身）：回答"宿主配没配"、"本次带的这串对不对"、
+                        // "配置文件里的改动是不是还没重启生效"、"本次进程的标识"。就地回答而不是进 handlers 表：
+                        // 前者的答案来自本次请求头与进程状态，而后者的 handlers 只拿得到 args。
+                        // 不返回令牌、也不返回它的任何片段 —— 泄给同源页面等于把最后一道门交出去。
+                        if (op === 'token-status') {
+                            const state = await deps.tokenConfigState();
+                            res.end(JSON.stringify({
+                                ok: true,
+                                // 「宿主配置了令牌」= 配置里**有**值（关掉也算有：随时能开回来）。
+                                hostConfigured: deps.CONFIG_TOKEN !== '',
+                                // 当前进程里令牌功能是开还是关（关掉 = 写操作不要求令牌）。
+                                disabled: deps.TOKEN_DISABLED,
+                                // 「当前进程里令牌**在生效**」= 写操作要不要令牌。关掉或没配都是 false。
+                                // 界面据此判断"填令牌"这件事有没有意义（没生效时填了也没人验，还会把
+                                // 一句无处可填的提示挂在屏幕上 —— 用户 2026-09-19 报的就是这个）。
+                                active: deps.TOKEN !== '',
+                                accepted: tokenAccepted,
+                                bootId: deps.BOOT_ID,
+                                configHasToken: state.configHasToken,
+                                configDisabled: state.configDisabled,
+                                configFound: state.found,
+                                pendingRestart: state.pendingRestart,
+                            }));
+                            return;
+                        }
+                        // 设置 / 关闭令牌：同样就地处理（理由见 tokenConfigure 的注释 —— 也正因为不进
+                        // handlers，模型侧没有任何工具能间接关掉它）。
+                        if (op === 'token-configure') {
+                            res.end(JSON.stringify(deps.withPatchWarnings(await deps.tokenConfigure(payload.args || {}, tokenAccepted))));
+                            return;
+                        }
+                        // 「清除令牌」的配套：把「本次启动已验过」的闩重新挂上。没有它，解锁一次之后
+                        // 清除令牌 + 强刷新，浏览器里已无令牌，闩却挂着 —— pre-step 门禁读闩
+                        // （tokenGateActive），整个启动期都放行对话（2026-09-19 用户实测的漏洞）。
+                        // 不要求凭证：它只会收紧（要求重新验令牌），给不了任何人任何权限；同样不进
+                        // handlers —— 模型不该有能力拨这颗闩。
+                        if (op === 'token-unaccept') {
+                            deps.unmarkAccepted();
+                            res.end(JSON.stringify({ ok: true }));
+                            return;
+                        }
+                        const fn = deps.handlers[op];
+                        if (!fn) {
+                            res.end(JSON.stringify({ ok: false, error: '未知操作: ' + op }));
+                            return;
+                        }
+                        const result = await fn(payload.args || {});
+                        // 「最近改动」流水：来源 = 面板（这条 HTTP 路由是界面唯一的入口）。
+                        // 「这次算不算写」的判据在 recordOpAudit 里（与写门禁同源：登记表的 `writeWhen`）
+                        // —— 不在这里再传一次 `readOnlyCall`，两处各判一次迟早会分家。
+                        recordOpAudit(op, payload.args || {}, 'panel', result);
+                        res.end(JSON.stringify(deps.withPatchWarnings(result === undefined ? { ok: true } : result)));
+                    }
+                    catch (e) {
+                        res.end(JSON.stringify({ ok: false, error: deps.message(e) }));
+                    }
+                },
+            }), 'dsh-plugin-tool-management: api route');
+        }
+        catch (e) {
+            // A registration failure must never take down the whole entry: log and continue.
+            console.error('[dsh-plugin-tool-management] webServer route registration failed:', deps.message(e));
+            // 结构性弱点（2026-09-30 审查 §5 F4）：compat-status **本身就走这条路由**，所以路由没注册上
+            // 时兼容页也拿不到这条降级行 —— 面板是**整页失联**，不是"少一行"。这里至少把它写进运行期
+            // 上报通道（日志里必然有一条，进程内可查），并在 README 里写明"面板空白先看宿主日志"。
+            // 之所以不是"必然可见"的告警：可见的通道就是这条路由，它自己挂了就没得显示。
+            noteRuntime({
+                id: 'web-server-route',
+                label: 'HTTP 路由注册',
+                kind: 'write',
+                fallback: 'inform-only',
+                detail: '向宿主 webServer 注册 API 路由失败（' + deps.message(e) + '）：插件面板与全部 HTTP op 不可用（兼容页也走这条路由，所以它也打不开）。宿主日志里有同一条记录；模型工具不受影响。',
+                detailKey: 'web-server-route.register-failed',
+                params: { reason: deps.message(e) },
+            });
+        }
+    }
+}

package/lib/hub.js

@@ -245,6 +245,8 @@ const LEGACY_TRASH_KINDS = {
     prompts: ['agents-md'],
     subagents: ['agents'],
     scenes: [],
+    // 0.18.0 才有的域，没有旧名字要认。
+    'quick-prompts': [],
 };
 /** 某一类回收站的根目录：`hub/trash/<kind>-trash`。 */
 export function trashKindDir(kind) {