@lijian-ui/dsh-skill-manage 0.1.0

package/lib/index.js

@@ -0,0 +1,1215 @@
+import Schema from "@deepseek-ai/schemastery";
+import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { z } from "zod";
+import { access, cp, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
+import { parse } from "yaml";
+//#region src/skill-files.ts
+const DISABLED_SUFFIX = ".disabled";
+const SKILL_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+async function pathExists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function findProjectRoot(cwd) {
+	let current = resolve(cwd);
+	while (true) {
+		if (await pathExists(join(current, ".git"))) return current;
+		const parent = dirname(current);
+		if (parent === current) return resolve(cwd);
+		current = parent;
+	}
+}
+function parseFrontmatter(raw) {
+	const text = raw.trimStart();
+	if (!text.startsWith("---")) return void 0;
+	const firstEnd = text.indexOf("\n");
+	if (firstEnd === -1) return void 0;
+	const closing = text.indexOf("\n---", firstEnd + 1);
+	const fmEnd = closing === -1 ? text.length : closing;
+	const fm = text.slice(3, fmEnd);
+	let body = "";
+	if (closing !== -1) {
+		const at = text.indexOf("\n", closing + 3);
+		if (at !== -1) body = text.slice(at + 1);
+	}
+	const pick = (key) => {
+		const m = new RegExp("^" + key + ":\\s*(.+)$", "m").exec(fm);
+		if (m === null) return void 0;
+		return m[1].trim().replace(/^["']|["']$/g, "");
+	};
+	const name = pick("name");
+	if (name === void 0 || !SKILL_NAME_RE.test(name)) return void 0;
+	return {
+		name,
+		description: pick("description") ?? "",
+		whenToUse: pick("whenToUse"),
+		body: body.trim()
+	};
+}
+function validateFrontmatter(raw) {
+	const text = raw.trimStart();
+	if (!text.startsWith("---")) return {
+		ok: false,
+		error: "缺少 YAML frontmatter（文件必须以 --- 开头）"
+	};
+	const firstEnd = text.indexOf("\n");
+	if (firstEnd === -1) return {
+		ok: false,
+		error: "frontmatter 未闭合"
+	};
+	const closing = text.indexOf("\n---", firstEnd + 1);
+	if (closing === -1) return {
+		ok: false,
+		error: "frontmatter 未闭合（缺少结尾的 ---）"
+	};
+	const fm = text.slice(firstEnd + 1, closing);
+	let data;
+	try {
+		data = parse(fm);
+	} catch (error) {
+		return {
+			ok: false,
+			error: "frontmatter 不是合法的 YAML：" + (error instanceof Error ? error.message : String(error))
+		};
+	}
+	if (data === null || typeof data !== "object" || Array.isArray(data)) return {
+		ok: false,
+		error: "frontmatter 必须是键值对（YAML 映射）"
+	};
+	const obj = data;
+	for (const key of [
+		"disableModelInvocation",
+		"modelInvocable",
+		"userInvocable"
+	]) if (key in obj) return {
+		ok: false,
+		error: "不支持旧字段 \"" + key + "\"，请改用 disable-model-invocation / user-invocable"
+	};
+	const name = obj.name;
+	if (typeof name !== "string" || name.length === 0) return {
+		ok: false,
+		error: "frontmatter 缺少 name（必须是非空字符串）"
+	};
+	if (!SKILL_NAME_RE.test(name)) return {
+		ok: false,
+		error: "技能名 \"" + name + "\" 不符合命名规则（仅小写字母、数字与连字符，如 my-skill）"
+	};
+	const description = obj.description;
+	if (typeof description !== "string" || description.trim().length === 0) return {
+		ok: false,
+		error: "frontmatter 缺少 description（必须是非空字符串）"
+	};
+	const whenToUse = obj.whenToUse;
+	if (whenToUse !== void 0 && typeof whenToUse !== "string") return {
+		ok: false,
+		error: "whenToUse 必须是字符串"
+	};
+	for (const key of ["disable-model-invocation", "user-invocable"]) {
+		const value = obj[key];
+		if (value !== void 0) {
+			const lower = String(value).toLowerCase();
+			if (![
+				"true",
+				"false",
+				"yes",
+				"no",
+				"on",
+				"off",
+				"1",
+				"0"
+			].includes(lower)) return {
+				ok: false,
+				error: key + " 必须是布尔值"
+			};
+		}
+	}
+	if (obj.metadata !== void 0 && (typeof obj.metadata !== "object" || obj.metadata === null || Array.isArray(obj.metadata))) return {
+		ok: false,
+		error: "metadata 必须是对象"
+	};
+	return {
+		ok: true,
+		skill: {
+			name,
+			description,
+			whenToUse: typeof whenToUse === "string" ? whenToUse : void 0,
+			body: ""
+		}
+	};
+}
+async function collectSkillEntries(roots) {
+	const entries = [];
+	for (const root of roots) {
+		let items;
+		try {
+			items = await readdir(root.path, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const item of items) if (item.isDirectory() || item.isSymbolicLink() && (await stat(join(root.path, item.name)).catch(() => void 0))?.isDirectory() === true) {
+			const md = join(root.path, item.name, "SKILL.md");
+			const disabled = md + DISABLED_SUFFIX;
+			if (await pathExists(md)) {
+				const parsed = parseFrontmatter(await readFile(md, "utf8").catch(() => ""));
+				entries.push({
+					name: parsed?.name ?? item.name,
+					description: parsed?.description ?? "",
+					whenToUse: parsed?.whenToUse,
+					enabled: true,
+					kind: "bundle",
+					file: md,
+					dirBundle: true,
+					source: root.source,
+					projectRoot: root.projectRoot
+				});
+			} else if (await pathExists(disabled)) {
+				const parsed = parseFrontmatter(await readFile(disabled, "utf8").catch(() => ""));
+				entries.push({
+					name: parsed?.name ?? item.name,
+					description: parsed?.description ?? "",
+					whenToUse: parsed?.whenToUse,
+					enabled: false,
+					kind: "bundle",
+					file: disabled,
+					dirBundle: true,
+					source: root.source,
+					projectRoot: root.projectRoot
+				});
+			}
+		} else if (item.isFile()) {
+			if (item.name.endsWith(".md.disabled")) {
+				const file = join(root.path, item.name);
+				const parsed = parseFrontmatter(await readFile(file, "utf8").catch(() => ""));
+				entries.push({
+					name: parsed?.name ?? item.name.slice(0, -12),
+					description: parsed?.description ?? "",
+					whenToUse: parsed?.whenToUse,
+					enabled: false,
+					kind: "flat",
+					file,
+					dirBundle: false,
+					source: root.source,
+					projectRoot: root.projectRoot
+				});
+			} else if (item.name.endsWith(".md")) {
+				const file = join(root.path, item.name);
+				const parsed = parseFrontmatter(await readFile(file, "utf8"));
+				entries.push({
+					name: parsed?.name ?? item.name.slice(0, -3),
+					description: parsed?.description ?? "",
+					whenToUse: parsed?.whenToUse,
+					enabled: true,
+					kind: "flat",
+					file,
+					dirBundle: false,
+					source: root.source,
+					projectRoot: root.projectRoot
+				});
+			}
+		}
+	}
+	return entries;
+}
+function winnerEntry(entries, name) {
+	const matches = entries.filter((entry) => entry.name === name);
+	if (matches.length === 0) return void 0;
+	matches.sort((a, b) => sourceRank(a.source) - sourceRank(b.source));
+	return matches[0];
+}
+function sourceRank(source) {
+	switch (source) {
+		case "project-dsh": return 1;
+		case "project-agents": return 2;
+		case "user-dsh": return 3;
+		case "user-agents": return 4;
+		default: return 9;
+	}
+}
+//#endregion
+//#region src/scope.ts
+function workspaceSkillRoot(projectRoot) {
+	return join(projectRoot, ".dsh", "skills");
+}
+function scopeRootOf(target, dshHome) {
+	return target === null || target === void 0 ? join(dshHome, "skills") : workspaceSkillRoot(target);
+}
+async function normalizeWorkspaces(paths) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const raw of paths) {
+		if (typeof raw !== "string" || raw.trim() === "") continue;
+		const absolute = resolve(raw.trim());
+		const info = await stat(absolute).catch(() => void 0);
+		if (info === void 0 || !info.isDirectory()) throw new Error("工作区不存在或不是目录：\"" + raw + "\"");
+		const project = await findProjectRoot(absolute);
+		const key = process.platform === "win32" ? project.toLowerCase() : project;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		result.push(project);
+	}
+	return result;
+}
+async function normalizeWorkspace(raw) {
+	const list = await normalizeWorkspaces([raw]);
+	if (list.length === 0) throw new Error("至少需要指定一个存在的工作区");
+	return list[0];
+}
+function isBusyError(error) {
+	return error !== null && typeof error === "object" && [
+		"EPERM",
+		"EBUSY",
+		"EACCES",
+		"ENOTEMPTY"
+	].includes(error.code ?? "");
+}
+async function removeRetry(path) {
+	for (let attempt = 0; attempt < 5; attempt++) try {
+		await rm(path, {
+			recursive: true,
+			force: true
+		});
+		return true;
+	} catch (error) {
+		if (!isBusyError(error)) throw error;
+		await new Promise((resolvePromise) => setTimeout(resolvePromise, 300 * (attempt + 1)));
+	}
+	return false;
+}
+async function migrateEntry(entry, targetRoot, mode) {
+	const sourceDir = entry.dirBundle ? dirname(entry.file) : entry.file;
+	const target = entry.dirBundle ? join(targetRoot, entry.name) : join(targetRoot, basename(entry.file));
+	if (resolve(sourceDir) === resolve(target)) throw new Error("技能 \"" + entry.name + "\" 已在此作用域中");
+	if (await pathExists(target)) throw new Error("目标位置已存在同名技能：\"" + target + "\"");
+	if (!await pathExists(sourceDir)) throw new Error("技能 \"" + entry.name + "\" 的源文件不存在：" + sourceDir);
+	await mkdir(targetRoot, { recursive: true });
+	if (mode === "move") try {
+		await rename(sourceDir, target);
+		return { target };
+	} catch (error) {
+		const code = error.code;
+		if (![
+			"EXDEV",
+			"EBUSY",
+			"EPERM",
+			"EACCES"
+		].includes(code)) throw new Error("移动技能文件失败：" + (error instanceof Error ? error.message : String(error)));
+	}
+	const staging = join(targetRoot, ".dsh-skill-staging-" + process.pid + "-" + Math.random().toString(36).slice(2, 8));
+	try {
+		if (entry.dirBundle) {
+			await cp(sourceDir, staging, { recursive: true });
+			await rename(staging, target);
+		} else {
+			await mkdir(staging, { recursive: true });
+			const stagedFile = join(staging, basename(entry.file));
+			await cp(entry.file, stagedFile);
+			await rename(stagedFile, target);
+			await rm(staging, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+		}
+	} catch (error) {
+		await rm(staging, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		throw new Error("复制技能文件失败（已回滚）：" + (error instanceof Error ? error.message : String(error)));
+	}
+	if (mode === "move") try {
+		if (!await removeRetry(sourceDir)) throw new Error("源文件删除超时");
+	} catch (error) {
+		await rm(target, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		throw new Error("技能 \"" + entry.name + "\" 已复制到目标，但无法删除源文件（可能被占用），已回滚新副本：" + (error instanceof Error ? error.message : String(error)));
+	}
+	return { target };
+}
+async function batchMigrateEntries(items, targetRoot, mode) {
+	const results = [];
+	for (const item of items) try {
+		await migrateEntry(item, targetRoot, mode);
+		results.push({
+			name: item.name,
+			ok: true
+		});
+	} catch (error) {
+		results.push({
+			name: item.name,
+			ok: false,
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+	return results;
+}
+//#endregion
+//#region src/remote.ts
+const SERVICE = "skillManage";
+const PACKAGE = "@lijian-ui/dsh-skill-manage";
+const sessionIdSchema = z.string().optional();
+const scopeSchema = z.object({
+	kind: z.enum(["global", "workspace"]),
+	path: z.string().optional(),
+	label: z.string().optional()
+});
+const skillSummarySchema = z.object({
+	name: z.string(),
+	description: z.string(),
+	whenToUse: z.string().optional(),
+	provider: z.string(),
+	source: z.string(),
+	enabled: z.boolean(),
+	modelInvocable: z.boolean(),
+	userInvocable: z.boolean(),
+	scope: scopeSchema.optional()
+});
+const listResultSchema = z.object({ skills: z.array(skillSummarySchema) });
+const workspacesResultSchema = z.object({ workspaces: z.array(z.object({
+	path: z.string(),
+	label: z.string(),
+	sessions: z.number()
+})) });
+const resourceBaseSchema = z.object({
+	kind: z.string(),
+	path: z.string().optional(),
+	url: z.string().optional(),
+	description: z.string().optional()
+}).optional();
+const skillContentSchema = z.object({
+	name: z.string(),
+	description: z.string(),
+	content: z.string(),
+	provider: z.string(),
+	whenToUse: z.string().optional(),
+	path: z.string().optional(),
+	resourceBase: resourceBaseSchema
+}).nullable();
+const setEnabledResultSchema = z.object({
+	name: z.string(),
+	enabled: z.boolean()
+});
+const deleteSkillResultSchema = z.object({ name: z.string() });
+const migratePayloadSchema = z.object({
+	target: z.string().nullable(),
+	mode: z.enum(["copy", "move"])
+});
+const migrateResultSchema = z.object({
+	name: z.string(),
+	scope: scopeSchema
+});
+const batchMigratePayloadSchema = z.object({
+	from: z.string().nullable(),
+	targets: z.array(z.string().nullable()).min(1),
+	mode: z.enum(["copy", "move"]),
+	names: z.array(z.string())
+});
+const batchMigrateResultSchema = z.object({ results: z.array(z.object({
+	name: z.string(),
+	target: z.string().nullable().optional(),
+	ok: z.boolean(),
+	error: z.string().optional()
+})) });
+const addFileSchema = z.object({
+	path: z.string(),
+	base64: z.string()
+});
+const addPayloadSchema = z.object({
+	kind: z.enum(["bundle", "flat"]),
+	files: z.array(addFileSchema).min(1),
+	workspace: z.string().nullable().optional()
+});
+const addResultSchema = z.object({
+	name: z.string(),
+	kind: z.enum(["bundle", "flat"]),
+	scope: scopeSchema
+});
+const MANIFEST = {
+	package: PACKAGE,
+	face: "host",
+	schemas: [],
+	invocations: [
+		{
+			id: `${PACKAGE}#${SERVICE}/list`,
+			service: SERVICE,
+			namespace: SERVICE,
+			method: "list",
+			invocation: { kind: "direct" },
+			parameters: [{
+				name: "sessionId",
+				wire: "sessionId",
+				source: "json",
+				acceptsUndefined: true,
+				codec: {
+					mode: "strict",
+					typeSymbol: `${PACKAGE}#sessionId`,
+					schema: sessionIdSchema
+				}
+			}],
+			result: {
+				mode: "strict",
+				typeSymbol: `${PACKAGE}#SkillListResult`,
+				schema: listResultSchema
+			}
+		},
+		{
+			id: `${PACKAGE}#${SERVICE}/workspaces`,
+			service: SERVICE,
+			namespace: SERVICE,
+			method: "workspaces",
+			invocation: { kind: "direct" },
+			parameters: [],
+			result: {
+				mode: "strict",
+				typeSymbol: `${PACKAGE}#WorkspacesResult`,
+				schema: workspacesResultSchema
+			}
+		},
+		{
+			id: `${PACKAGE}#${SERVICE}/content`,
+			service: SERVICE,
+			namespace: SERVICE,
+			method: "content",
+			invocation: { kind: "direct" },
+			parameters: [{
+				name: "name",
+				wire: "name",
+				source: "json",
+				codec: {
+					mode: "strict",
+					typeSymbol: `${PACKAGE}#SkillName`,
+					schema: z.string()
+				}
+			}, {
+				name: "sessionId",
+				wire: "sessionId",
+				source: "json",
+				acceptsUndefined: true,
+				codec: {
+					mode: "strict",
+					typeSymbol: `${PACKAGE}#sessionId`,
+					schema: sessionIdSchema
+				}
+			}],
+			result: {
+				mode: "strict",
+				typeSymbol: `${PACKAGE}#SkillContent`,
+				schema: skillContentSchema
+			}
+		},
+		{
+			id: `${PACKAGE}#${SERVICE}/setEnabled`,
+			service: SERVICE,
+			namespace: SERVICE,
+			method: "setEnabled",
+			invocation: { kind: "direct" },
+			parameters: [
+				{
+					name: "name",
+					wire: "name",
+					source: "json",
+					codec: {
+						mode: "strict",
+						typeSymbol: `${PACKAGE}#SkillName`,
+						schema: z.string()
+					}
+				},
+				{
+					name: "sessionId",
+					wire: "sessionId",
+					source: "json",
+					acceptsUndefined: true,
+					codec: {
+						mode: "strict",
+						typeSymbol: `${PACKAGE}#sessionId`,
+						schema: sessionIdSchema
+					}
+				},
+				{
+					name: "enabled",
+					wire: "enabled",
+					source: "json",
+					codec: {
+						mode: "strict",
+						typeSymbol: `${PACKAGE}#EnabledFlag`,
+						schema: z.boolean()
+					}
+				}
+			],
+			result: {
+				mode: "strict",
+				typeSymbol: `${PACKAGE}#SetEnabledResult`,
+				schema: setEnabledResultSchema
+			}
+		},
+		{
+			id: `${PACKAGE}#${SERVICE}/migrate`,
+			service: SERVICE,
+			namespace: SERVICE,
+			method: "migrate",
+			invocation: { kind: "direct" },
+			parameters: [
+				{
+					name: "name",
+					wire: "name",
+					source: "json",
+					codec: {
+						mode: "strict",
+						typeSymbol: `${PACKAGE}#SkillName`,
+						schema: z.string()
+					}
+				},
+				{
+					name: "sessionId",
+					wire: "sessionId",
+					source: "json",
+					acceptsUndefined: true,
+					codec: {
+						mode: "strict",
+						typeSymbol: `${PACKAGE}#sessionId`,
+						schema: sessionIdSchema
+					}
+				},
+				{
+					name: "payload",
+					wire: "payload",
+					source: "json",
+					codec: {
+						mode: "strict",
+						typeSymbol: `${PACKAGE}#MigratePayload`,
+						schema: migratePayloadSchema
+					}
+				}
+			],
+			result: {
+				mode: "strict",
+				typeSymbol: `${PACKAGE}#MigrateResult`,
+				schema: migrateResultSchema
+			}
+		},
+		{
+			id: `${PACKAGE}#${SERVICE}/batchMigrate`,
+			service: SERVICE,
+			namespace: SERVICE,
+			method: "batchMigrate",
+			invocation: { kind: "direct" },
+			parameters: [{
+				name: "sessionId",
+				wire: "sessionId",
+				source: "json",
+				acceptsUndefined: true,
+				codec: {
+					mode: "strict",
+					typeSymbol: `${PACKAGE}#sessionId`,
+					schema: sessionIdSchema
+				}
+			}, {
+				name: "payload",
+				wire: "payload",
+				source: "json",
+				codec: {
+					mode: "strict",
+					typeSymbol: `${PACKAGE}#BatchMigratePayload`,
+					schema: batchMigratePayloadSchema
+				}
+			}],
+			result: {
+				mode: "strict",
+				typeSymbol: `${PACKAGE}#BatchMigrateResult`,
+				schema: batchMigrateResultSchema
+			}
+		},
+		{
+			id: `${PACKAGE}#${SERVICE}/deleteSkill`,
+			service: SERVICE,
+			namespace: SERVICE,
+			method: "deleteSkill",
+			invocation: { kind: "direct" },
+			parameters: [{
+				name: "name",
+				wire: "name",
+				source: "json",
+				codec: {
+					mode: "strict",
+					typeSymbol: `${PACKAGE}#SkillName`,
+					schema: z.string()
+				}
+			}, {
+				name: "sessionId",
+				wire: "sessionId",
+				source: "json",
+				acceptsUndefined: true,
+				codec: {
+					mode: "strict",
+					typeSymbol: `${PACKAGE}#sessionId`,
+					schema: sessionIdSchema
+				}
+			}],
+			result: {
+				mode: "strict",
+				typeSymbol: `${PACKAGE}#DeleteSkillResult`,
+				schema: deleteSkillResultSchema
+			}
+		},
+		{
+			id: `${PACKAGE}#${SERVICE}/addSkill`,
+			service: SERVICE,
+			namespace: SERVICE,
+			method: "addSkill",
+			invocation: { kind: "direct" },
+			parameters: [{
+				name: "sessionId",
+				wire: "sessionId",
+				source: "json",
+				acceptsUndefined: true,
+				codec: {
+					mode: "strict",
+					typeSymbol: `${PACKAGE}#sessionId`,
+					schema: sessionIdSchema
+				}
+			}, {
+				name: "payload",
+				wire: "payload",
+				source: "json",
+				codec: {
+					mode: "strict",
+					typeSymbol: `${PACKAGE}#AddPayload`,
+					schema: addPayloadSchema
+				}
+			}],
+			result: {
+				mode: "strict",
+				typeSymbol: `${PACKAGE}#AddResult`,
+				schema: addResultSchema
+			}
+		}
+	],
+	model: {
+		services: [],
+		events: [],
+		objects: []
+	}
+};
+const MAX_ADD_FILES = 200;
+const MAX_ADD_TOTAL_BYTES = 8388608;
+var SkillManageApi = class extends TypertRemoteService {
+	constructor(ctx) {
+		super(ctx, SERVICE);
+	}
+	registryFor(sessionId) {
+		const live = sessionId === void 0 ? void 0 : this.ctx.agents.get(sessionId);
+		if (live !== void 0) {
+			const result = this.ctx.get("agentPresets")?.serviceFor?.(live, "skills");
+			if (result !== void 0) return result;
+		}
+		return this.ctx.skills;
+	}
+	viewFor(sessionId) {
+		const registry = this.registryFor(sessionId);
+		const session = sessionId === void 0 ? void 0 : this.ctx.sessions.get(sessionId);
+		const scope = sessionId === void 0 ? void 0 : this.ctx.agents.get(sessionId);
+		return {
+			registry,
+			cwd: session?.header?.cwd,
+			scope
+		};
+	}
+	homes() {
+		return {
+			dshHome: resolveDshHome(),
+			agentsHome: resolve(process.env.DSH_AGENTS_HOME?.trim() ? process.env.DSH_AGENTS_HOME : join(homedir(), ".agents"))
+		};
+	}
+	isWithin(baseDir, candidate) {
+		if (typeof candidate !== "string" || candidate === "") return false;
+		const base = resolve(baseDir);
+		const value = resolve(candidate);
+		if (value === base) return true;
+		const b = process.platform === "win32" ? base.toLowerCase() : base;
+		const v = process.platform === "win32" ? value.toLowerCase() : value;
+		const sep = process.platform === "win32" ? "\\" : "/";
+		return v.startsWith(b.endsWith(sep) ? b : b + sep);
+	}
+	async allRoots() {
+		const { dshHome, agentsHome } = this.homes();
+		const roots = [];
+		const seen = /* @__PURE__ */ new Set();
+		const push = (path, source, projectRoot) => {
+			const normalized = resolve(path);
+			const key = process.platform === "win32" ? normalized.toLowerCase() : normalized;
+			if (seen.has(key)) return;
+			seen.add(key);
+			roots.push({
+				path,
+				source,
+				projectRoot
+			});
+		};
+		push(join(dshHome, "skills"), "user-dsh", void 0);
+		push(join(agentsHome, "skills"), "user-agents", void 0);
+		for (const workspace of (await this.workspaces()).workspaces) {
+			push(join(workspace.path, ".dsh", "skills"), "project-dsh", workspace.path);
+			push(join(workspace.path, ".agents", "skills"), "project-agents", workspace.path);
+		}
+		return roots;
+	}
+	async fileEntriesAll() {
+		return collectSkillEntries(await this.allRoots());
+	}
+	workspaceOfPath(path, roots) {
+		if (typeof path !== "string" || path === "") return void 0;
+		for (const root of roots) {
+			if (root.projectRoot === void 0) continue;
+			if (this.isWithin(root.path, path)) return root.projectRoot;
+		}
+	}
+	scopeForEntry(entry) {
+		if (entry.projectRoot !== void 0) return {
+			kind: "workspace",
+			path: entry.projectRoot,
+			label: basename(entry.projectRoot) || entry.projectRoot
+		};
+		return { kind: "global" };
+	}
+	scopeForTarget(targetRoot, targetProject) {
+		const { dshHome } = this.homes();
+		if (resolve(targetRoot) === resolve(join(dshHome, "skills"))) return { kind: "global" };
+		return {
+			kind: "workspace",
+			path: targetProject ?? void 0,
+			label: targetProject !== void 0 && targetProject !== null ? basename(targetProject) || targetProject : void 0
+		};
+	}
+	async list(sessionId) {
+		const { registry, cwd, scope } = this.viewFor(sessionId);
+		const roots = await this.allRoots();
+		const listed = await registry.list({
+			cwd,
+			scope
+		});
+		const skills = [];
+		const seen = /* @__PURE__ */ new Set();
+		const seenKey = (name, scopePath) => name + "\0" + (scopePath ?? "global");
+		for (const skill of listed) {
+			if (this.workspaceOfPath(skill.path, roots) !== void 0) continue;
+			const source = skill.source ?? (skill.provider === "runtime" ? "runtime" : "");
+			skills.push({
+				name: skill.name,
+				description: skill.description,
+				...skill.whenToUse === void 0 ? {} : { whenToUse: skill.whenToUse },
+				provider: skill.provider,
+				source,
+				enabled: true,
+				modelInvocable: skill.invocation.modelInvocable,
+				userInvocable: skill.invocation.userInvocable,
+				scope: { kind: "global" }
+			});
+			seen.add(seenKey(skill.name, "global"));
+		}
+		for (const entry of await collectSkillEntries(roots)) {
+			const scopePath = entry.projectRoot ?? "global";
+			if (seen.has(seenKey(entry.name, scopePath))) continue;
+			seen.add(seenKey(entry.name, scopePath));
+			skills.push({
+				name: entry.name,
+				description: entry.description,
+				...entry.whenToUse === void 0 ? {} : { whenToUse: entry.whenToUse },
+				provider: "filesystem",
+				source: entry.source,
+				enabled: entry.enabled,
+				modelInvocable: false,
+				userInvocable: false,
+				scope: this.scopeForEntry(entry)
+			});
+		}
+		return { skills };
+	}
+	async workspaces() {
+		const map = /* @__PURE__ */ new Map();
+		const keyOf = (path) => process.platform === "win32" ? path.toLowerCase() : path;
+		const add = async (path, label, sessions) => {
+			if (typeof path !== "string" || path === "") return;
+			let project;
+			try {
+				project = await findProjectRoot(resolve(path));
+			} catch {
+				return;
+			}
+			const key = keyOf(project);
+			if (map.has(key)) return;
+			map.set(key, {
+				path: project,
+				label: label || basename(project) || project,
+				sessions: sessions ?? 0
+			});
+		};
+		try {
+			const registry = this.ctx.get("workspaceRegistry");
+			if (registry !== void 0 && typeof registry.list === "function") for (const workspace of registry.list()) {
+				try {
+					if (await workspace.status() !== "ok") continue;
+				} catch {}
+				await add(workspace.path, workspace.title, Array.isArray(workspace.sessionIds) ? workspace.sessionIds.length : 0);
+			}
+		} catch {}
+		try {
+			for (const session of this.ctx.sessions.list()) {
+				const cwd = session.header?.cwd;
+				if (cwd === void 0 || cwd === "") continue;
+				await add(resolve(cwd), void 0, 1);
+			}
+		} catch {}
+		return { workspaces: [...map.values()].sort((a, b) => a.label.localeCompare(b.label) || a.path.localeCompare(b.path)) };
+	}
+	async locate(name, sessionId) {
+		const { registry, cwd, scope } = this.viewFor(sessionId);
+		const skill = await registry.get(name, {
+			cwd,
+			scope
+		});
+		if (skill !== void 0 && this.workspaceOfPath(skill.path, await this.allRoots()) === void 0) return {
+			kind: "live",
+			skill
+		};
+		const entry = winnerEntry(await this.fileEntriesAll(), name);
+		if (entry !== void 0) return {
+			kind: "file",
+			entry
+		};
+		return { kind: "missing" };
+	}
+	async content(name, sessionId) {
+		const located = await this.locate(name, sessionId);
+		if (located.kind === "missing") return null;
+		if (located.kind === "file") {
+			const raw = await readFile(located.entry.file, "utf8");
+			return {
+				name: located.entry.name,
+				description: located.entry.description,
+				content: raw,
+				provider: "filesystem",
+				path: located.entry.file
+			};
+		}
+		const skill = located.skill;
+		return {
+			name: skill.name,
+			description: skill.description,
+			content: skill.content,
+			provider: skill.provider,
+			...skill.whenToUse === void 0 ? {} : { whenToUse: skill.whenToUse },
+			...skill.path === void 0 ? {} : { path: skill.path },
+			...skill.resourceBase === void 0 ? {} : { resourceBase: skill.resourceBase }
+		};
+	}
+	assertEditable(skill) {
+		if (skill.source === "bundled") throw new Error("技能 \"" + skill.name + "\" 随部署附带，不可修改");
+		if (typeof skill.path !== "string" || skill.path.length === 0) throw new Error("技能 \"" + skill.name + "\" 没有可修改的文件");
+	}
+	async setEnabled(name, sessionId, enabled) {
+		const located = await this.locate(name, sessionId);
+		if (located.kind === "missing") throw new Error("技能 \"" + name + "\" 不存在");
+		if (located.kind === "live") {
+			const skill = located.skill;
+			this.assertEditable(skill);
+			if (enabled) return {
+				name,
+				enabled: true
+			};
+			const target = skill.path + DISABLED_SUFFIX;
+			if (await pathExists(target)) throw new Error("目标文件已存在：" + target);
+			await rename(skill.path, target);
+			return {
+				name,
+				enabled: false
+			};
+		}
+		const entry = located.entry;
+		if (enabled === entry.enabled) return {
+			name,
+			enabled
+		};
+		const target = enabled ? entry.file.slice(0, -9) : entry.file + DISABLED_SUFFIX;
+		if (await pathExists(target)) throw new Error("目标文件已存在：" + target);
+		await rename(entry.file, target);
+		return {
+			name,
+			enabled
+		};
+	}
+	async deleteSkill(name, sessionId) {
+		const located = await this.locate(name, sessionId);
+		if (located.kind === "missing") throw new Error("技能 \"" + name + "\" 不存在");
+		if (located.kind === "live") {
+			const skill = located.skill;
+			this.assertEditable(skill);
+			if (basename(skill.path) === "SKILL.md") await rm(dirname(skill.path), {
+				recursive: true,
+				force: true
+			});
+			else await rm(skill.path, { force: true });
+			return { name };
+		}
+		const entry = located.entry;
+		if (entry.dirBundle) await rm(dirname(entry.file), {
+			recursive: true,
+			force: true
+		});
+		else await rm(entry.file, { force: true });
+		return { name };
+	}
+	async migratableEntry(name, sessionId) {
+		const entry = winnerEntry(await this.fileEntriesAll(), name);
+		if (entry !== void 0) return entry;
+		const located = await this.locate(name, sessionId);
+		if (located.kind !== "live") return void 0;
+		const skill = located.skill;
+		if (typeof skill.path !== "string" || skill.path === "") return void 0;
+		const { dshHome, agentsHome } = this.homes();
+		if (![join(dshHome, "skills"), join(agentsHome, "skills")].some((root) => this.isWithin(root, skill.path))) return void 0;
+		this.assertEditable(skill);
+		return {
+			name: skill.name,
+			file: skill.path,
+			dirBundle: basename(skill.path) === "SKILL.md",
+			enabled: true,
+			source: skill.source ?? "user-dsh"
+		};
+	}
+	async migrate(name, sessionId, payload) {
+		const { target: rawTarget, mode } = payload;
+		const { dshHome } = this.homes();
+		const targetProject = rawTarget === null || rawTarget === void 0 ? null : await normalizeWorkspace(rawTarget);
+		const targetRoot = scopeRootOf(targetProject, dshHome);
+		const entry = await this.migratableEntry(name, sessionId);
+		if (entry === void 0) throw new Error("技能 \"" + name + "\" 没有可迁移的文件（随部署附带或运行时内置的技能不可迁移）");
+		await migrateEntry(entry, targetRoot, mode);
+		return {
+			name,
+			scope: this.scopeForTarget(targetRoot, targetProject)
+		};
+	}
+	async batchMigrate(sessionId, payload) {
+		const { from: rawFrom, targets: rawTargets, mode, names } = payload;
+		if (mode === "move" && rawTargets.length > 1) throw new Error("移动模式只能选择一个目标作用域（多个目标请改用复制）");
+		const { dshHome, agentsHome } = this.homes();
+		const fromProject = rawFrom === null || rawFrom === void 0 ? null : await normalizeWorkspace(rawFrom);
+		const fromRoots = fromProject === null ? [{
+			path: join(dshHome, "skills"),
+			source: "user-dsh"
+		}, {
+			path: join(agentsHome, "skills"),
+			source: "user-agents"
+		}] : [{
+			path: workspaceSkillRoot(fromProject),
+			source: "project-dsh",
+			projectRoot: fromProject
+		}];
+		const byName = /* @__PURE__ */ new Map();
+		for (const entry of await collectSkillEntries(fromRoots)) if (!byName.has(entry.name)) byName.set(entry.name, entry);
+		const chosen = [];
+		const results = [];
+		for (const name of names) {
+			const entry = byName.get(name);
+			if (entry === void 0) results.push({
+				name,
+				ok: false,
+				error: "技能 \"" + name + "\" 不在源作用域中"
+			});
+			else chosen.push(entry);
+		}
+		for (const rawTarget of rawTargets) {
+			const targetRoot = scopeRootOf(rawTarget === null || rawTarget === void 0 ? null : await normalizeWorkspace(rawTarget), dshHome);
+			if (fromRoots.some((root) => resolve(root.path) === resolve(targetRoot))) {
+				for (const entry of chosen) results.push({
+					name: entry.name,
+					target: rawTarget ?? null,
+					ok: false,
+					error: "目标作用域与源作用域相同"
+				});
+				continue;
+			}
+			for (const item of await batchMigrateEntries(chosen, targetRoot, mode)) results.push({
+				name: item.name,
+				target: rawTarget ?? null,
+				ok: item.ok,
+				...item.error === void 0 ? {} : { error: item.error }
+			});
+		}
+		return { results };
+	}
+	async addSkill(sessionId, payload) {
+		const { kind, files, workspace: rawWorkspace } = payload;
+		if (files.length > MAX_ADD_FILES) throw new Error("文件数量过多（最多 200 个）");
+		const decoded = files.map((file) => {
+			const data = Buffer.from(file.base64, "base64");
+			if (data.length === 0 && file.base64.length > 0) throw new Error("文件内容解码失败：" + file.path);
+			return {
+				path: file.path.replaceAll("\\", "/"),
+				data
+			};
+		});
+		if (decoded.reduce((sum, file) => sum + file.data.length, 0) > MAX_ADD_TOTAL_BYTES) throw new Error("技能总大小超过 8MB 上限");
+		for (const file of decoded) if (file.path.startsWith("/") || file.path.split("/").some((segment) => segment === ".." || segment === ".")) throw new Error("非法文件路径：" + file.path);
+		const { dshHome } = this.homes();
+		let targetProject;
+		let targetRoot;
+		if (rawWorkspace === void 0 || rawWorkspace === null || rawWorkspace === "") targetRoot = join(dshHome, "skills");
+		else {
+			targetProject = await normalizeWorkspace(rawWorkspace);
+			targetRoot = workspaceSkillRoot(targetProject);
+		}
+		let name;
+		let writes;
+		if (kind === "bundle") {
+			const tops = new Set(decoded.map((file) => file.path.split("/")[0]));
+			if (tops.size !== 1 || decoded.some((file) => file.path.split("/").length < 2)) throw new Error("技能文件夹结构不正确：所有文件应位于同一个文件夹内");
+			const top = [...tops][0];
+			const skillFile = decoded.find((file) => file.path === top + "/SKILL.md");
+			if (skillFile === void 0) throw new Error("技能文件夹缺少顶层的 SKILL.md 文件");
+			const validation = validateFrontmatter(skillFile.data.toString("utf8"));
+			if (!validation.ok) throw new Error("技能格式不符合要求：" + validation.error);
+			name = validation.skill.name;
+			writes = decoded.map((file) => ({
+				relative: file.path.slice(top.length + 1),
+				data: file.data
+			}));
+		} else {
+			if (decoded.length !== 1) throw new Error("单个技能文件一次只能添加一个");
+			const file = decoded[0];
+			const flatName = file.path.split("/").filter(Boolean).pop() ?? "";
+			if (!flatName.toLowerCase().endsWith(".md")) throw new Error("技能文件必须是 .md 文件");
+			const validation = validateFrontmatter(file.data.toString("utf8"));
+			if (!validation.ok) throw new Error("技能格式不符合要求：" + validation.error);
+			name = validation.skill.name;
+			writes = [{
+				relative: flatName,
+				data: file.data
+			}];
+		}
+		const existing = winnerEntry(await this.fileEntriesAll(), name);
+		if (existing !== void 0) throw new Error("同名技能 \"" + name + "\" 已存在（" + (existing.enabled ? "已启用" : "已停用") + "，位于 " + (existing.projectRoot !== void 0 ? existing.projectRoot : "全局用户根") + "）");
+		const { registry, cwd, scope } = this.viewFor(sessionId);
+		if ((await registry.list({
+			cwd,
+			scope
+		})).some((skill) => skill.name === name)) throw new Error("同名技能 \"" + name + "\" 已存在");
+		const target = kind === "bundle" ? join(targetRoot, name) : join(targetRoot, writes[0].relative);
+		const staging = join(targetRoot, ".dsh-skill-staging-" + process.pid + "-" + Math.random().toString(36).slice(2, 8));
+		try {
+			if (kind === "bundle") {
+				for (const write of writes) {
+					const filePath = join(staging, write.relative);
+					await mkdir(dirname(filePath), { recursive: true });
+					await writeFile(filePath, write.data);
+				}
+				await rename(staging, target);
+			} else {
+				await mkdir(staging, { recursive: true });
+				const stagedFile = join(staging, writes[0].relative);
+				await writeFile(stagedFile, writes[0].data);
+				await rename(stagedFile, target);
+				await rm(staging, {
+					recursive: true,
+					force: true
+				}).catch(() => {});
+			}
+		} catch (error) {
+			await rm(staging, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+			await rm(target, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+			throw new Error("写入技能文件失败（已回滚）：" + (error instanceof Error ? error.message : String(error)));
+		}
+		if (!await this.waitForDiscovery(name, sessionId, targetProject ?? cwd)) {
+			await rm(target, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+			throw new Error("DSH 未接受该技能（格式校验未通过），已回滚。请检查 frontmatter 后重试");
+		}
+		return {
+			name,
+			kind,
+			scope: targetProject !== void 0 && targetProject !== null ? {
+				kind: "workspace",
+				path: targetProject,
+				label: basename(targetProject) || targetProject
+			} : { kind: "global" }
+		};
+	}
+	async waitForDiscovery(name, sessionId, probeCwd) {
+		const { registry, scope } = this.viewFor(sessionId);
+		for (let attempt = 0; attempt < 12; attempt++) {
+			await new Promise((resolvePromise) => setTimeout(resolvePromise, 500));
+			try {
+				if (await registry.get(name, {
+					cwd: probeCwd,
+					scope
+				}) !== void 0) return true;
+			} catch {
+				return true;
+			}
+		}
+		return false;
+	}
+};
+function registerSkillManageRemote(ctx) {
+	new SkillManageApi(ctx);
+	ctx.effect(() => ctx.typert.register(MANIFEST), "skill-manage: typert manifest");
+}
+//#endregion
+//#region src/index.ts
+const inject = [
+	"typert",
+	"settings",
+	"skills",
+	"sessions",
+	"agents"
+];
+const NS = settingsNamespace("skill-manage");
+const Config = Schema.object({});
+function apply(ctx) {
+	installConsoleLoggerExporter(ctx);
+	installSettingsSection(ctx, NS, Config, {}, {
+		setSource: () => {},
+		onChange: () => {}
+	});
+	registerSkillManageRemote(ctx);
+}
+function installConsoleLoggerExporter(ctx) {
+	try {
+		ctx.root.logger?.exporter?.({
+			colors: 0,
+			export: (message) => {
+				const { name = "skill-manage", type = "log", args = [] } = message;
+				const line = `[${name}] ${args.map((arg) => arg instanceof Error ? arg.stack ?? arg.message : typeof arg === "string" ? arg : (() => {
+					try {
+						return JSON.stringify(arg);
+					} catch {
+						return String(arg);
+					}
+				})()).join(" ")}`;
+				if (type === "error") console.error(line);
+				else if (type === "warn") console.warn(line);
+				else if (type === "debug") console.debug(line);
+				else console.info(line);
+			}
+		});
+	} catch {}
+}
+//#endregion
+export { Config, apply, inject };