dsh-plugin-tool-management 0.10.0 → 0.12.0

package/lib/ops/candidates.js

@@ -0,0 +1,64 @@
+// 场景档案与候选源域的 HTTP ops（2026-09-19 从 index.ts 的 handlers 表抽出）。
+//
+// 三个 op 都是**只读候选源**：preset-tools（人设表单的工具候选）、model-candidates
+// （宿主 LLM 目录）、scene-inventory（场景档案勾选器的数据源 v2）。
+export function buildCandidateOps(deps) {
+    return {
+        // 人设表单的两个候选源之一（只读，均为「按需拉取」——不进 scene-inventory，避免每次开
+        // 档案弹窗都枚举预设）。
+        // preset-tools：全体 Agent 预设工具名并集 + 各工具所属预设 + 当前会话是否可见。
+        // `unavailable` = 本插件自己没注册上的工具：工具列表接口是唯一按名字枚举工具的地方，
+        // 注册失败只能在这里被如实回答。
+        'preset-tools': async () => ({
+            ok: true,
+            ...(await deps.presetToolCandidates()),
+            unavailable: deps.getToolFailures().map((f) => ({ ...f })),
+        }),
+        // model-candidates：宿主 LLM 目录里的 (provider, model) 对（不发网络请求）。
+        'model-candidates': async () => ({ ok: true, ...(await deps.modelCandidates()) }),
+        // 场景档案勾选器数据源 v2：全部 MCP 服务器（含未运行）+ 技能全集 + 人设清单。
+        'scene-inventory': async () => {
+            const [rowsR, tools, skills, subs] = await Promise.all([deps.mcpmListView(), deps.toolStates(), deps.skillRows(), deps.subagentList()]);
+            const disabledRaw = await deps.readDisabledTools();
+            const rows = (rowsR && rowsR.rows) || [];
+            const mcpServers = [];
+            const seen = new Set();
+            for (const row of rows) {
+                const name = String((row && row.serverName) || '');
+                if (!name || seen.has(name))
+                    continue;
+                seen.add(name);
+                const live = !!(row.live && row.live.enabled);
+                mcpServers.push({
+                    name,
+                    level: row.level || null,
+                    live,
+                    serverDisabled: !!row.disabled,
+                    // 停用表里的 ['*'] = 整台工具停用（勾选器据此预勾，避免把"全停"读成"全启用"）。
+                    allToolsDisabled: (disabledRaw[name] || []).indexOf('*') >= 0,
+                    // 未运行且没有任何已知工具 ⇒ null（客户端显示「工具数未知」并引导读取），
+                    // 不再给出误导性的 0。
+                    toolCount: live || Number(row.toolCount) > 0
+                        ? (typeof row.toolCount === 'number' ? row.toolCount : null)
+                        : null,
+                });
+            }
+            return {
+                ok: true,
+                mcpServers,
+                tools: Object.entries(tools).map(([key, enabled]) => ({ key, enabled })),
+                // 技能行：技能名与来源名分开给（早先只给 `<来源 key>/<技能名>`，自定义目录的
+                // 来源 key 是 `custom-<hash>`，于是导入的技能在场景里显示成一串哈希）。
+                skills,
+                // 人设行要显示"按模式配了什么限制"，所以把按模式名单一起带上；
+                // presets 只给名字与来源（不枚举工具，避免打开档案弹窗就挂载每个预设）。
+                subagents: subs.map((p) => ({ name: p.name, description: p.description, toolsByPreset: p.toolsByPreset ?? null })),
+                presets: await deps.presetNames(),
+                // 档案编辑器第 4 段「记忆」的候选：场景 + 每个场景里的记忆条数。
+                // 记忆正文不在这里返回（勾选集只存 id，渲染时才读盘）。
+                scenes: await deps.memorySceneCandidates(),
+                memories: await deps.memoryCandidates(),
+            };
+        },
+    };
+}

package/lib/ops/compat.js

@@ -0,0 +1,226 @@
+// 兼容 / 注入 / 备份域的 HTTP ops（2026-09-19 从 index.ts 的 handlers 表抽出）。
+//
+// 为什么抽出来：index.ts 的 apply() 闭包里塞了 40 个 op 的内联实现，改一处要在 700 行
+// 的对象字面量里找。这里按域收成一个 `buildCompatOps(deps)` —— 依赖全部显式传参，
+// 不再靠闭包隐式捕获，各域可以单独读、单独改。
+//
+// 边界纪律：本文件只负责「op 的实现」，不负责 ops 表之外的接线（MCP 写后刷新、场景锁定
+// 守卫仍作用在组装后的整张表上，见 index.ts）。
+import { EXPECTED_MIN_HOST_VERSION, EXPECTED_PEER_RANGE, VERIFIED_HOST_VERSION, routeFor, summarize, } from '../compat/probe.js';
+import { INJECT_DOMAIN_KEYS } from '../context-inject.js';
+import { assessPresetReach } from '../compat/preset-reach.js';
+import { runtimeNotes } from '../compat/runtime-notes.js';
+import { pluginLog } from '../skills/service.js';
+export function buildCompatOps(deps) {
+    return {
+        'compat-status': async (args) => {
+            const force = Boolean(args && args.refresh);
+            try {
+                const registry = deps.getSessionsRegistry();
+                const assessment = registry && typeof registry.capabilities === 'function'
+                    ? registry.capabilities(force)
+                    : undefined;
+                if (assessment === undefined) {
+                    return {
+                        ok: true,
+                        host: { version: 'unknown' },
+                        findings: [],
+                        degraded: [],
+                        blockers: ['归档服务未挂载：无法探测宿主能力'],
+                        summary: '宿主能力探测不可用（归档服务未挂载）',
+                    };
+                }
+                const summary = summarize(assessment);
+                // 运行时降级（A1 的补丁校验、A2 的投影缓存适配、B3 的装配层…）统一在这里并进
+                // findings/degraded：它们不是宿主能力，但必须各占一行 —— 否则用户只能在事故之后
+                // 才知道某道保险没生效。上报口径见 compat/runtime-notes.ts。
+                const extraFindings = runtimeNotes().map((note) => ({
+                    id: note.id,
+                    label: note.label,
+                    kind: note.kind,
+                    owner: 'plugin',
+                    fallback: note.fallback,
+                    state: 'not-available',
+                    missing: [],
+                    detail: note.detail,
+                }));
+                const findings = [...assessment.findings, ...extraFindings];
+                const degraded = [...assessment.degraded, ...extraFindings];
+                const merged = { ...assessment, findings, degraded };
+                const summaryMerged = extraFindings.length === 0 ? summary : summarize(merged);
+                // 每次刷新都留一条结构化日志：升级当天就能在日志里看到降级发生。
+                if (force || !deps.compatLog.version || deps.compatLog.version !== assessment.identity.version) {
+                    deps.compatLog.version = assessment.identity.version;
+                    void pluginLog()('compat/probe', {
+                        hostVersion: assessment.identity.version,
+                        summary: summaryMerged,
+                        degraded: degraded.map((item) => ({ id: item.id, state: item.state, detail: item.detail })),
+                        blockers: assessment.identity.blockers,
+                        sameAsHost: assessment.identity.sameAsHost,
+                    }).catch(() => { });
+                }
+                return {
+                    ok: true,
+                    host: { version: assessment.identity.version, modules: assessment.identity.modules },
+                    sameAsHost: assessment.identity.sameAsHost,
+                    unverified: assessment.identity.unverified,
+                    findings,
+                    degraded,
+                    blockers: assessment.identity.blockers,
+                    mayDelete: assessment.mayDelete,
+                    verifiedVersion: VERIFIED_HOST_VERSION,
+                    expectedPeerRange: EXPECTED_PEER_RANGE,
+                    minHostVersion: EXPECTED_MIN_HOST_VERSION,
+                    generatedAt: assessment.generatedAt,
+                    summary: summaryMerged,
+                };
+            }
+            catch (e) {
+                return { ok: false, error: deps.message(e) };
+            }
+        },
+        // 预设可达性矩阵：每个 Agent 预设下，本插件的注入类能力到不到得了模型。
+        // 只读预设组合文本，不挂载任何预设、不改任何数据。回答的是"面板上说注入了，
+        // 模型真的看得到吗" —— 压制型预设（persona complete / includeRuntimeContext:false，
+        // 如极简）默认不注入，可在「注入」设置里改成强制注入。
+        'preset-reach': async () => {
+            try {
+                // 宿主平面的 MCP 工具数：四个官方预设都不在组合里挂 MCP，MCP 由
+                // $DSH_HOME/cordis.patch.yml 这一层挂载，所以它对所有预设一视同仁；
+                // 这一列要回答的只是"现在有没有 MCP 工具可用"。探测失败 → 不传该字段，
+                // 矩阵那一格显示"判断不了"而不是猜。
+                let mcpTools;
+                try {
+                    const schemas = (await deps.tools.schemas());
+                    mcpTools = schemas.filter((s) => String(s && s.name || '').startsWith('mcp__')).length;
+                }
+                catch {
+                    mcpTools = undefined;
+                }
+                const settings = await deps.readInjectSettings();
+                const report = await assessPresetReach(deps.presetRoster(), {
+                    mcpTools,
+                    inject: { underSuppressingPresets: settings.underSuppressingPresets, domains: settings.domains },
+                });
+                return { ok: true, ...report };
+            }
+            catch (e) {
+                return { ok: false, error: deps.message(e) };
+            }
+        },
+        // 注入设置（读 / 写）：压制型预设下是否仍然注入 + 各域开关。界面在「兼容」页。
+        'inject-settings': (args) => deps.injectSettingsOp(args),
+        // 功能总览（B6）：**按功能点**回答"现在每一项到底能不能用"，三层合成 ——
+        //   ① 装配层（listener / provider / 适配是否真的挂上，来自运行时上报通道）
+        //   ② 宿主能力层（compat 探测的路由判定）
+        //   ③ 用户配置层（开关 / 令牌 / 场景锁定）
+        // 数据全部来自已有的缓存状态与运行时上报，**不新增宿主探测**（避免哨兵真调一类的开销）。
+        // 行内 `tab` 供界面跳转到对应页签；`state` 取值见下方约定。
+        'feature-overview': async () => {
+            try {
+                const registry = deps.getSessionsRegistry();
+                const assessment = registry && typeof registry.capabilities === 'function' ? registry.capabilities() : undefined;
+                const notes = new Map(runtimeNotes().map((note) => [note.id, note]));
+                const settings = await deps.readInjectSettings();
+                const domainsOn = INJECT_DOMAIN_KEYS.filter((key) => settings.domains[key] !== false);
+                const token = await deps.readTokenState();
+                const lockedScenes = await deps.lockedSceneNames();
+                const disabledTools = deps.disabledToolCount();
+                const routeOf = (operation) => assessment === undefined ? undefined : routeFor(assessment, operation);
+                /** 一行一个功能点：状态三层合成，`detail` 写明依据。 */
+                const rows = [];
+                const push = (key, label, tab, state, detail) => rows.push({ key, label, tab, state, detail });
+                // 前置项：插件挂载（这一行本身说明 12 个 inject 都解析了 —— 否则 apply 根本不会跑）；
+                // 启动期那段 `!!js` 表达式若抛错，插件同样不会挂上（它的 try/catch 就是为了不抛）。
+                const mountNote = notes.get('cordis-original-symbol');
+                push('mount', '插件挂载', 'compat', mountNote === undefined ? 'ok' : 'degraded', mountNote === undefined ? '12 个 inject 服务全部解析，插件已挂载（详见 doctor 的挂载心跳）' : mountNote.detail);
+                // 装配层：有上报就是降级，附上报里的原因；没有就是正常。
+                const assemblyRows = [
+                    ['patch-write-guard', '宿主配置写入（补丁校验）', 'mcp'],
+                    ['context-injection', '上下文注入通道', 'compat'],
+                    ['official-suppression', '官方注入的关域拦截', 'compat'],
+                    ['skills-provider', '技能 provider 装配', 'skills'],
+                    ['projection-cache-adapter', '投影缓存删除屏障', 'sessions'],
+                    ['mcp-tool-visibility', '停用工具的可见性', 'mcp'],
+                ];
+                for (const [noteId, label, tab] of assemblyRows) {
+                    const note = notes.get(noteId);
+                    push(noteId, label, tab, note === undefined ? 'ok' : 'degraded', note === undefined ? '装配正常，无降级上报' : note.detail);
+                }
+                // 宿主能力层：删除 / 归档 / 恢复 / 批量各自由路由判定回答（与服务端执行同源）。
+                const deleteRoute = routeOf('delete');
+                push('session-delete', '会话删除', 'sessions', deleteRoute === undefined ? 'unknown' : deleteRoute.via === 'none' ? 'unavailable' : 'ok', deleteRoute === undefined ? '能力探测不可用（归档服务未挂载）'
+                    : deleteRoute.via === 'none' ? '宿主缺少该路径所需能力：' + deleteRoute.refusals.map((item) => item.label).join('、')
+                        : `可用（路径：${deleteRoute.via}）`);
+                for (const [operation, label] of [['archive', '归档'], ['unarchive', '恢复'], ['batch', '批量操作'], ['list', '历史列表']]) {
+                    const decision = routeOf(operation);
+                    push('session-' + operation, `会话${label}`, 'sessions', decision === undefined ? 'unknown' : decision.via === 'none' ? 'unavailable' : 'ok', decision === undefined ? '能力探测不可用（归档服务未挂载）'
+                        : decision.via === 'none' ? '宿主缺少该路径所需能力：' + decision.refusals.map((item) => item.label).join('、')
+                            : `可用（路径：${decision.via}）`);
+                }
+                // 用户配置层：注入域 / 令牌 / 场景锁定 / 停用工具数。
+                push('injection-domains', '注入域开关', 'compat', domainsOn.length === 0 ? 'disabled' : 'ok', domainsOn.length === 0 ? '五个注入域全部关闭（用户设置）' : `${domainsOn.length}/5 个域开启：${domainsOn.join('、')}`);
+                push('token', '访问令牌', 'compat', !token.active ? 'disabled' : token.accepted ? 'ok' : 'locked', !token.active ? '未启用（宿主没配令牌，或令牌功能被关掉）'
+                    : token.accepted ? '已生效且本次启动已通过验证' : '已生效，本次启动尚未验证：写操作与对话会被拦住，到本页下方填写令牌');
+                push('scene-lock', '场景锁定', 'scenes', lockedScenes.length === 0 ? 'ok' : 'locked', lockedScenes.length === 0 ? '无锁定场景' : `锁定中：${lockedScenes.join('、')}（写门禁按锁定场景生效）`);
+                push('mcp-tools', 'MCP 工具停用', 'mcp', disabledTools === 0 ? 'ok' : 'partial', disabledTools === 0 ? '没有停用的工具' : `${disabledTools} 个工具处于停用态（执行拦截 + 可见性摘除）`);
+                push('native-delete', '宿主原生删除入口', 'compat', notes.has('workspace.delete-native') ? 'partial' : 'ok', notes.get('workspace.delete-native')?.detail ?? '宿主未提供原生删除入口（本插件自有完整序列）');
+                // 身份 / 版本：与 compat-status 同一份数据。
+                const identity = assessment?.identity;
+                const identityIssue = identity !== undefined && (identity.blockers.length > 0 || Object.values(identity.sameAsHost).some((same) => same === false));
+                push('host-identity', '宿主身份与模块', 'compat', assessment === undefined ? 'unknown' : identityIssue ? 'degraded' : 'ok', assessment === undefined ? '能力探测不可用（归档服务未挂载）'
+                    : identityIssue ? '存在阻塞项：' + (identity?.blockers ?? []).join('；')
+                        : `模块与宿主同源（宿主 DSH ${identity?.version ?? '?'}）`);
+                // 无独立装配点的域：没有上报就是正常（如实说明依据是"没有降级上报"）。
+                for (const [key, label, tab] of [['memory', '记忆', 'memory'], ['prompts', '提示词', 'prompts'], ['subagents', '子智能体', 'subagents'], ['scenes', '场景档案', 'scenes']]) {
+                    push(key, label, tab, 'ok', '无降级上报（装配失败会出现在这里）');
+                }
+                return { ok: true, rows, generatedAt: Date.now() };
+            }
+            catch (e) {
+                return { ok: false, error: deps.message(e) };
+            }
+        },
+        // patch 备份（改宿主配置前的整份副本）：列清单只读，清理按写门禁。
+        // 每份备份里都是**明文**凭据，所以给一个显式出口让人能删掉多余的副本（理由见
+        // cleanPatchBackups 的注释）。清单不带文件内容，只给名字 / 层级 / 时间 / 大小。
+        'backups-list': async () => {
+            const files = await deps.listPatchBackups();
+            return { ok: true, files, total: files.length, totalSize: files.reduce((s, f) => s + f.size, 0) };
+        },
+        'backups-clean': async (args) => {
+            // 口径是**每个层级各删最旧的几份**：`del` 是 `{ 层级: 份数 }`，键与 listPatchBackups
+            // 给的层级标签同源（global / profile:<名> / legacy）。认不出的键天然落空（没有这个
+            // 层级就没得删），非法值一律忽略 —— 参数畸形时**一份都不删**，这是安全的默认。
+            const raw = (args && args.del) || {};
+            const del = {};
+            if (raw && typeof raw === 'object') {
+                for (const key of Object.keys(raw)) {
+                    const n = Number(raw[key]);
+                    if (Number.isSafeInteger(n) && n >= 1 && n <= 20)
+                        del[key] = n;
+                }
+            }
+            const r = await deps.cleanPatchBackups(del);
+            // 失败原因（文件被占用等）由界面按当前语言拼：这里只回结构化字段。回中文串会让
+            // 英文界面原样露出中文（与 compat-status 的 summary 同一条纪律）。
+            return {
+                ok: true, removed: r.removed.length, kept: r.kept,
+                ...(r.failed.length ? { failedCount: r.failed.length, failedNames: r.failed } : {}),
+            };
+        },
+        // 注入实况（只读）：最近活跃会话里模型**真正看到**的五域文本 + 本次运行的投递统计。
+        // 回答"勾了开关到底送没送到"——界面配置与实际注入不一致时，这里一眼可见。
+        'injection-live': async () => {
+            const live = deps.getContextInjectorLive();
+            if (live === null)
+                return { ok: false, error: '注入通道未装配' };
+            try {
+                return { ok: true, ...live() };
+            }
+            catch (e) {
+                return { ok: false, error: deps.message(e) };
+            }
+        },
+    };
+}

package/lib/ops/ctx.js

@@ -0,0 +1,9 @@
+// 记忆域 op 的**显式上下文契约**（2026-09-19 抽出，配合 memories/service.ts 组装）。
+//
+// 为什么要有它：24 个 op 原先写在 createMemoriesService 闭包里，靠闭包隐式捕获读模型
+// （snapshot / sceneMemory / scenePrompt）、写管道（invalidateSnapshot）、入口
+// （parseId / locateRule / buildProjected）与三个路径配置。抽成独立文件后，这些依赖必须
+// 显式传入 —— 本文件就是那份清单，签名与原声明逐字对应（改这里等于改 op 的可见面）。
+//
+// 刻意不做成 `typeof rc`：那会把契约藏回 service.ts，域文件又得反向引它。
+export {};