dsh-toolbox-ui 1.6.4 → 1.6.6

package/lib/index.js

@@ -12,8 +12,9 @@ import { admitImportedServers } from "./import-admission.js";
 import { collectImportLocations, missingEnvNames, resolveImportLocation } from "./mcp-import-sources.js";
 import { deriveMcpPhase, formatMcpLog, sanitizeMcpLog } from "./mcp-observability.js";
 import { allMcpEntries, entriesForName, projectToolSchema, revisionOf, toolInventory } from "./mcp-registry.js";
-import { invocationOf, listSkillViews, resolveTargetReference, skillRowKey, skillTargetsView } from "./skills-registry.js";
-import { importSkill, readSkillDocument, removeSkill, resolveSkillTarget, scanDisabledSkills, setSkillEnabled, setSkillModelInvocable } from "./skills-file-ops.js";
+import { diagnoseSkill } from "./skills-frontmatter.js";
+import { invocationOf, listSkillViews, resolveSkillReference, resolveTargetReference, skillRowKey, skillTargetsView } from "./skills-registry.js";
+import { importSkill, readSkillDocument, removeSkill, scanDisabledSkills, setSkillEnabled, setSkillModelInvocable, setSkillUserInvocable } from "./skills-file-ops.js";
 import { downloadHubArchive, hubCategories, hubSkillDetail, searchHubSkills } from "./skillhub.js";
 import { setOwn } from "./own-property.js";
 import { WHATS_NEW } from "./whats-new.js";
@@ -1448,7 +1449,7 @@ let McpManagerGateway = (() => {
 let SkillsManagerGateway = (() => {
 	let _classSuper = TypertRemoteService;
 	let _instanceExtraInitializers = [];
-	let _list_decorators, _detail_decorators, _setEnabled_decorators, _setModelInvocable_decorators, _removeSkill_decorators, _importSkill_decorators, _skillTargets_decorators, _skillHubSearch_decorators, _skillHubDetail_decorators, _skillHubCategories_decorators, _skillHubInstall_decorators, _conflictingManager_decorators;
+	let _list_decorators, _detail_decorators, _setEnabled_decorators, _setModelInvocable_decorators, _setUserInvocable_decorators, _removeSkill_decorators, _importSkill_decorators, _skillTargets_decorators, _skillHubSearch_decorators, _skillHubDetail_decorators, _skillHubCategories_decorators, _skillHubInstall_decorators, _conflictingManager_decorators;
 	return class SkillsManagerGateway extends _classSuper {
 		static {
 			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
@@ -1460,6 +1461,8 @@ let SkillsManagerGateway = (() => {
 			__esDecorate(this, null, _setEnabled_decorators, { kind: "method", name: "setEnabled", static: false, private: false, access: { has: (obj) => "setEnabled" in obj, get: (obj) => obj.setEnabled }, metadata: _metadata }, null, _instanceExtraInitializers);
 			_setModelInvocable_decorators = [Remote("setModelInvocable")];
 			__esDecorate(this, null, _setModelInvocable_decorators, { kind: "method", name: "setModelInvocable", static: false, private: false, access: { has: (obj) => "setModelInvocable" in obj, get: (obj) => obj.setModelInvocable }, metadata: _metadata }, null, _instanceExtraInitializers);
+			_setUserInvocable_decorators = [Remote("setUserInvocable")];
+			__esDecorate(this, null, _setUserInvocable_decorators, { kind: "method", name: "setUserInvocable", static: false, private: false, access: { has: (obj) => "setUserInvocable" in obj, get: (obj) => obj.setUserInvocable }, metadata: _metadata }, null, _instanceExtraInitializers);
 			_removeSkill_decorators = [Remote("removeSkill")];
 			__esDecorate(this, null, _removeSkill_decorators, { kind: "method", name: "removeSkill", static: false, private: false, access: { has: (obj) => "removeSkill" in obj, get: (obj) => obj.removeSkill }, metadata: _metadata }, null, _instanceExtraInitializers);
 			_importSkill_decorators = [Remote("importSkill")];
@@ -1487,130 +1490,141 @@ let SkillsManagerGateway = (() => {
 		async list(payload) {
 			const workspaces = Array.isArray(payload?.workspaces) ? payload.workspaces.map(String) : [];
 			const rows = await listSkillViews(this.ctx, { workspaces });
-			// 已禁用技能是**独立一组**：宿主目录里看不到它们（SPEC 约束 3），只能扫各根下的 .disabled。
+			// ⚠️ 「已停用」不再是**另一个数组**，而是行上的派生态（enabled）。
 			//
-			// ⚠️ 待扫的根必须来自**能力**（skillTargetsView），不能从可见行反推：
-			// 某个根里的技能**全被停用**时，可见行里根本没有那个根 → 它永远不被扫 →
-			// 面板零显示、也无法恢复（与"启用判据写反"叠加就是永久失联）。
-			// 顺带：目标自带 source / projectPath，正是客户端分组、作用域标签与药丸需要的两样东西
-			// ——缺了它们，所有已停用技能会并成一个无名组，并弹出一个空标签的药丸。
+			// 旧版这里是 `{ skills, disabled }` 两组：停用 = 把 SKILL.md 改名成 .disabled，
+			// 宿主因此看不见它，面板只好自己扫盘补一份。那套做法有两个结构性代价，都已实际爆过：
+			//   ① 状态只存在于文件名里 → 现场扫盘比宿主缓存新 → 同一个身份在两组里各出现一次
+			//      → 客户端 React 重复 key（生产版不报警告，静默重复渲染 + 徽章挂错行）；
+			//   ② `.disabled` 不是任何规范认可的形态，而 `~/.agents/skills` 是 Agent Skills 标准的
+			//      共享位置（VS Code / Codex 都扫它）——改名等于把用户的技能在别的工具里弄坏。
+			//
+			// 现在停用 = 写宿主**原生的两个调用面字段**（disable-model-invocation + user-invocable），
+			// 而宿主的 list 是**调用无关**的：两个面都关掉的技能照样出现在目录里。
+			// 于是「面板看得见的东西」与「宿主报告的东西」重新变成同一件事——
+			// 不需要扫盘、不需要两组互斥、不可能双行。这是一个身份一行在结构上的保证。
+			const skills = rows.map((row) => ({ ...row, key: skillRowKey(row) }));
+			// 旧版约定（.disabled 改名）留下的条目：**一次性迁移读取**，不是第二个真值来源。
+			// 1.6.x 的用户磁盘上可能已经有这种文件（我们自己写进去的），必须列出来并能恢复，
+			// 否则那些技能永远回不来。用户恢复之后就走新机制；本段与它的 wire 字段可整体删除。
+			//
+			// 待扫的根必须来自**能力**（skillTargetsView），不能从可见行反推：某个根里的技能
+			// 全被旧机制停用时，可见行里根本没有那个根 → 它永远不被扫 → 面板零显示、也救不回来。
 			const { targets } = await skillTargetsView(this.ctx, { workspaces });
-			const disabled = [];
+			const migrated = [];
+			const seenKeys = new Set(skills.map((row) => row.key));
 			for (const target of targets) {
-				if (target.writable === false) continue; // bundled 根只读，没有可启用的 .disabled
+				if (target.writable === false) continue; // bundled 根只读：我们从不往那里写 .disabled
 				if (target.exists === false) continue;   // 目录还没建，扫它只会白挨一个 ENOENT
 				for (const row of await scanDisabledSkills({ root: target.root, scope: target.scope })) {
-					disabled.push({
-						...row,
+					// 技能名要**读那个文件**才知道（旧机制的条目名也不保证等于技能名）。
+					const document = await readSkillDocument(row).catch(() => undefined);
+					const diagnosed = document === undefined ? undefined : diagnoseSkill(document.text);
+					const name = diagnosed?.name ?? row.entry;
+					const identity = {
+						name,
 						source: target.source,
 						cwd: target.projectPath,
+						root: target.root,
+						entry: row.entry,
+						kind: row.kind,
+					};
+					const key = skillRowKey(identity);
+					// 同一个身份已经在可见行里（用户恢复了一半、或宿主也报了这一条）：可见行优先，
+					// 它是宿主认可的当前真相。这里只补宿主**看不见**的那些，仍然保证一个身份一行。
+					if (seenKeys.has(key)) continue;
+					seenKeys.add(key);
+					// ⚠️ 迁移行的权限推导**单独**兜住读失败：这里任何一个文件读不出来都不该让 list
+					// 整体 reject——那会让面板技能页整块打不开，连健康的技能都管不了。
+					// 注意这只兜「这个文件读不到」这一类（`invocationOf` 自己已经把「读不到」
+					// 压成 null），不是把 bug 藏起来：真正的实现错误照原样抛。
+					const invocation = await invocationOf({
+						entry: row.entry, root: target.root, kind: row.kind, scope: target.scope,
+					});
+					migrated.push({
+						...identity,
+						key,
+						description: diagnosed?.description ?? "",
+						...invocation,
+						enabled: false,
+						scope: target.scope,
+						provider: "filesystem",
+						path: row.path,
+						source: target.source,
 						writable: target.writable !== false,
-						// 调用权限与可见行走**同一处**推导（skills-registry 的 invocationOf）：宿主目录里
-						// 看不到停用件，这个文件是唯一能回答「能不能被模型调用」的地方。缺了它，客户端
-						// 会把「未知」渲染成「不可调用」——一个凭空的断言。
-						...(await invocationOf({ name: row.name, root: target.root, scope: target.scope })),
+						// 客户端据此把这一行标成「旧机制留下的」，并给出与新机制不同的操作文案。
+						migrated: true,
 					});
 				}
 			}
-			disabled.sort((left, right) => left.name.localeCompare(right.name));
-			// ⚠️ 两个数组必须**互斥**：同一个身份（source \0 cwd \0 name）只能出现在一边。
-			//
-			// 宿主视图来自它的发现缓存，而停用件是我们**现场扫盘**得到的。面板刚把 `SKILL.md`
-			// 改名成 `.disabled` 时，缓存里那份仍然报「已启用」（宿主不会因为一次 rename 就丢缓存），
-			// 于是同一个身份在 `skills` 与 `disabled` 里各出现一次。客户端按 `skillIdentity` 生成
-			// 行 key，两行 key 相同 → React **重复 key**：生产版不报警告，只是把那一行重复渲染，
-			// 并把「被遮蔽」徽章挂到**别的行**上（真机实测：停用一个技能后，它自己重复 3 份、
-			// 邻居被误标「被遮蔽」，详情里的状态也停在旧值）。
-			//
-			// 现场扫盘比缓存新，所以**停用件优先**：把同身份的可见行剔掉。这不是给客户端打的补丁
-			// ——「一个身份一行」是这两个数组的契约，就该在产出它们的地方成立。
-			const disabledKeys = new Set(disabled.map((row) => skillRowKey(row)));
-			const visible = rows.filter((row) => !disabledKeys.has(skillRowKey(row)));
+			migrated.sort((left, right) => left.name.localeCompare(right.name));
 			// 曾经这里还返回一个 `revision`（目录指纹）供面板轮询判断要不要重渲染——
 			// 但技能面从来没有轮询循环，那个字段没有任何消费者，已删（MCP 面有它自己的指纹与轮询）。
-			return { skills: visible, disabled };
+			return { skills: [...skills, ...migrated] };
 		}
 		async detail(payload) {
-			const name = String(payload?.name ?? "");
-			if (name === "") throw new Error("缺少技能名");
 			// ⚠️ 按**引用定位到的那个根**读正文，不再走 `ctx.skills.get(name)`：那个按 rank
-			// 返回**生效者**，而面板的模型是 (name, root) 精确操作（D8）——点「被遮蔽」那一行
+			// 返回**生效者**，而面板的模型是 (根, 条目) 精确操作（D8）——点「被遮蔽」那一行
 			// 会看到生效者的正文，用户以为自己在读被遮蔽的那份。
-			// 顺带把「已停用」的正文也读得出来：停用时 resolveSkillTarget 返回的是 `.disabled` 路径。
-			const target = await resolveTargetReference(this.ctx, {
-				source: payload?.source,
-				root: payload?.root,
-				projectPath: payload?.projectPath,
-			});
-			const resolved = await resolveSkillTarget({
-				name,
-				root: target.root,
-				scope: target.scope,
-				writable: target.writable !== false,
-			});
+			const resolved = await resolveSkillReference(this.ctx, payload);
 			// 正文与调用权限来自**同一次读**（readSkillDocument 的契约）：分两次读会配错版本，
 			// 用户看到的就是「这份正文 + 别人的权限」。
 			const document = await readSkillDocument(resolved);
+			// 技能名以**文件里**的 frontmatter 为准（磁盘条目名可以与之不同，见 resolveSkillTarget）。
+			const name = diagnoseSkill(document.text).name ?? String(payload?.name ?? "");
+			const modelInvocable = document.invocation?.modelInvocable ?? null;
+			const userInvocable = document.invocation?.userInvocable ?? null;
+			// ⚠️ `enabled` 必须与 `list` 的**同一套判据**（否则同一件事在两个 RPC 上结论相反）。
+			// 两条分支缺一不可：
+			//   · 旧机制残留：它的「停用」在**文件名**里（`.disabled`），不在 frontmatter 里，
+			//     所以恒为 false——照内容派生会把它说成「已启用」（真机实测过这个矛盾）。
+			//   · 普通技能：两个调用面都关掉才是停用；读不出来（null）就是不知道。
+			const migrated = resolved.migratedDisabled === true;
+			const enabled = migrated
+				? false
+				: modelInvocable === null || userInvocable === null
+					? null
+					: !(modelInvocable === false && userInvocable === false);
 			return {
 				skill: {
 					name,
 					content: document.text,
-					modelInvocable: document.invocation?.modelInvocable ?? null,
-					userInvocable: document.invocation?.userInvocable ?? null,
+					modelInvocable,
+					userInvocable,
+					enabled,
 					kind: resolved.kind,
+					entry: resolved.entry,
 					path: resolved.path,
-					enabled: resolved.disabled !== true,
-					source: target.source,
-					root: target.root,
-					scope: target.scope,
+					migrated,
+					source: payload?.source,
+					root: resolved.root,
+					scope: resolved.scope,
 				},
 			};
 		}
 		async setEnabled(payload) {
-			// ⚠️ `root` / `writable` **不再从载荷取**：wire 只送一个引用，服务端拿自己算出来的
-			// 目标核对（见 resolveTargetReference）。否则「写入限定在技能根内」只由客户端保证。
-			const target = await resolveTargetReference(this.ctx, {
-				source: payload?.source,
-				root: payload?.root,
-				projectPath: payload?.projectPath,
-			});
-			const resolved = await resolveSkillTarget({
-				name: String(payload?.name ?? ""),
-				root: target.root,
-				scope: target.scope,
-				writable: target.writable !== false,
-			});
+			const resolved = await resolveSkillReference(this.ctx, payload);
 			return await setSkillEnabled(resolved, payload?.enabled !== false);
 		}
 		async setModelInvocable(payload) {
 			// 「允许模型自动调用」的开关：写技能文件的 disable-model-invocation。纪律与 setEnabled
 			// 完全一致——wire 只送引用、服务端核对自己算出来的目标、只读根拒绝；改写的形状规则在
 			// lib/skills-frontmatter.js，读不准时那个错误原样上抛给用户。
-			const target = await resolveTargetReference(this.ctx, {
-				source: payload?.source,
-				root: payload?.root,
-				projectPath: payload?.projectPath,
-			});
-			const resolved = await resolveSkillTarget({
-				name: String(payload?.name ?? ""),
-				root: target.root,
-				scope: target.scope,
-				writable: target.writable !== false,
-			});
+			const resolved = await resolveSkillReference(this.ctx, payload);
 			return await setSkillModelInvocable(resolved, payload?.modelInvocable !== false);
 		}
+		async setUserInvocable(payload) {
+			// 「用户可调用」的开关：写技能文件的 user-invocable。
+			//
+			// ⚠️ 为什么这个面也要有开关，而不是只让它只读显示：宿主支持的是**两个**调用面，而
+			// 「停用」= 两个都关这一种组合。只暴露一个面的话，用户在面板里拨不回「仅手动可调用」
+			// 那一档——只能去编辑文件。补上之后面板与文件是 1:1 的，`setEnabled` 退回快捷动作。
+			// 与 setModelInvocable 共用同一个实现（setSkillInvocationFace），差别只在写哪个字段。
+			const resolved = await resolveSkillReference(this.ctx, payload);
+			return await setSkillUserInvocable(resolved, payload?.userInvocable !== false);
+		}
 		async removeSkill(payload) {
-			const target = await resolveTargetReference(this.ctx, {
-				source: payload?.source,
-				root: payload?.root,
-				projectPath: payload?.projectPath,
-			});
-			const resolved = await resolveSkillTarget({
-				name: String(payload?.name ?? ""),
-				root: target.root,
-				scope: target.scope,
-				writable: target.writable !== false,
-			});
+			const resolved = await resolveSkillReference(this.ctx, payload);
 			return await removeSkill(resolved);
 		}
 		async importSkill(payload) {