mdk-skills 2.4.19 → 2.4.21

package/scripts/web-ui/server/routes/skills.js

@@ -9,6 +9,20 @@ const { buildContext } = require("../context");
 
 const ctx = buildContext(utils);
 
+// 跨平台打开文件管理器
+function openInExplorer(dirPath) {
+  const cmd = process.platform === "win32"
+    ? `start "" "${dirPath}"`
+    : process.platform === "darwin"
+      ? `open "${dirPath}"`
+      : `xdg-open "${dirPath}"`;
+  execSync(cmd, { stdio: "ignore" });
+}
+
+async function pathExists(p) {
+  try { await fs.promises.access(p); return true; } catch { return false; }
+}
+
 function requireSource(res) {
   if (!ctx.skillsSource || !ctx.pkgSkillsSource) {
     utils.sendJSON(res, { error: "未设置技能目录，请在设置中连接" }, 400);
@@ -17,11 +31,11 @@ function requireSource(res) {
   return true;
 }
 
-function cleanPullCache() {
+async function cleanPullCache() {
   const now = Date.now();
   for (const [url, entry] of ctx.pullCache) {
     if (now - entry.createdAt > 10 * 60 * 1000) {
-      try { fs.rmSync(entry.tmpDir, { recursive: true, force: true }); } catch {}
+      try { await fs.promises.rm(entry.tmpDir, { recursive: true, force: true }); } catch {}
       ctx.pullCache.delete(url);
     }
   }
@@ -80,20 +94,20 @@ function register(router) {
   // ----------------------------------------------------------------
   router.get("/api/skills", async (req, res) => {
     if (!requireSource(res)) return;
-    const pkgSkills = core.getPackageSkills(ctx.skillsSource);
+    const pkgSkills = await core.getPackageSkills(ctx.skillsSource);
     const pkgNames = new Set(pkgSkills.map((s) => s.name));
-    const userSkills = core.getUserSkills(ctx.claudeDest);
+    const userSkills = await core.getUserSkills(ctx.claudeDest);
     let cleaned = false;
     for (const us of userSkills) {
       if (!pkgNames.has(us.name)) {
         const dest = path.join(ctx.skillsDest, us.name);
-        if (fs.existsSync(dest)) {
-          const r = utils.safeRmSync(dest, us.name);
+        if (await pathExists(dest)) {
+          const r = await utils.safeRm(dest, us.name);
           if (r.removed) cleaned = true;
         }
       }
     }
-    const settings = ctx.readSettings();
+    const settings = await ctx.readSettings();
     let settingsChanged = cleaned;
     for (const name of Object.keys(settings.skills || {})) {
       if (!pkgNames.has(name)) {
@@ -101,10 +115,10 @@ function register(router) {
         settingsChanged = true;
       }
     }
-    if (settingsChanged) ctx.writeSettings(settings);
-    const refreshed = core.getUserSkills(ctx.claudeDest);
+    if (settingsChanged) await ctx.writeSettings(settings);
+    const refreshed = await core.getUserSkills(ctx.claudeDest);
     const userMap = new Map(refreshed.map((s) => [s.name, s]));
-    const pullSource = ctx.readPullSource();
+    const pullSource = await ctx.readPullSource();
     const result = pkgSkills.map((s) => ({
       ...s,
       enabled: userMap.has(s.name) ? userMap.get(s.name).enabled : false,
@@ -125,22 +139,22 @@ function register(router) {
     const src = path.join(ctx.pkgSkillsSource, name);
     const dest = path.join(ctx.skillsDest, name);
     if (enabled) {
-      if (fs.existsSync(src) && !fs.existsSync(dest)) {
-        utils.copyDirSync(src, dest);
+      if (await pathExists(src) && !(await pathExists(dest))) {
+        await utils.copyDir(src, dest);
       }
     } else {
-      if (fs.existsSync(dest)) {
-        const r = utils.safeRmSync(dest, name);
+      if (await pathExists(dest)) {
+        const r = await utils.safeRm(dest, name);
         if (!r.removed && r.reason === "locked") {
           return utils.sendJSON(res, { error: `技能 "${name}" 正被其他程序使用，无法停用` }, 409);
         }
       }
     }
-    const settings = ctx.readSettings();
+    const settings = await ctx.readSettings();
     if (!settings.skills) settings.skills = {};
     if (!settings.skills[name]) settings.skills[name] = {};
     settings.skills[name].enabled = enabled;
-    ctx.writeSettings(settings);
+    await ctx.writeSettings(settings);
     return utils.sendJSON(res, { ok: true, name, enabled: !!enabled });
   });
 
@@ -153,7 +167,7 @@ function register(router) {
     const { selected } = body;
     if (!Array.isArray(selected))
       return utils.sendJSON(res, { error: "参数错误" }, 400);
-    const result = ctx.installSelectedSkills(selected);
+    const result = await ctx.installSelectedSkills(selected);
     return utils.sendJSON(res, { ok: true, ...result });
   });
 
@@ -169,28 +183,28 @@ function register(router) {
 
     // ---------- 预览模式 ----------
     if (!Array.isArray(names) || names.length === 0) {
-      cleanPullCache();
+      await cleanPullCache();
       const cached = ctx.pullCache.get(url);
       if (cached) {
         const skillsDir = path.join(cached.tmpDir, ".claude", "skills");
-        const skills = fs.existsSync(skillsDir) ? core.listSkillDirs(skillsDir) : [];
+        const skills = await pathExists(skillsDir) ? await core.listSkillDirs(skillsDir) : [];
         return utils.sendJSON(res, { ok: true, skills, total: skills.length });
       }
       const tmpDir = path.join(os.tmpdir(), "mdk-preview-" + Date.now());
-      fs.mkdirSync(path.join(tmpDir, ".claude", "skills"), { recursive: true });
+      await fs.promises.mkdir(path.join(tmpDir, ".claude", "skills"), { recursive: true });
       try {
-        await runAsync(ctx.skillsBin + " add \"" + url + "\" --copy -y -a claude-code", { cwd: tmpDir, taskId: "skills-pull-preview" });
+        await runAsync(ctx.skillsBin + " add " + utils.escapeShellArg(url) + " --copy -y -a claude-code", { cwd: tmpDir, taskId: "skills-pull-preview" });
       } catch (e) {
-        utils.cleanNpxTemp();
-        utils.safeRmSync(tmpDir, "临时目录");
+        await utils.cleanNpxTemp();
+        await utils.safeRm(tmpDir, "临时目录");
         if (e.killed) return utils.sendJSON(res, { cancelled: true }, 499);
         return utils.sendJSON(res, { error: "预览失败：" + (e.stderr || e.message) }, 400);
       }
-      utils.cleanNpxTemp();
+      await utils.cleanNpxTemp();
       const skillsDir = path.join(tmpDir, ".claude", "skills");
-      const skills = fs.existsSync(skillsDir) ? core.listSkillDirs(skillsDir) : [];
+      const skills = await pathExists(skillsDir) ? await core.listSkillDirs(skillsDir) : [];
       if (skills.length === 0) {
-        utils.safeRmSync(tmpDir, "临时目录");
+        await utils.safeRm(tmpDir, "临时目录");
         return utils.sendJSON(res, { error: "未找到有效技能" }, 400);
       }
       ctx.pullCache.set(url, { tmpDir, createdAt: Date.now() });
@@ -208,25 +222,25 @@ function register(router) {
     const skillsDir = path.join(tmpDir, ".claude", "skills");
     for (const name of names) {
       const skillPath = path.join(skillsDir, name);
-      if (!fs.existsSync(path.join(skillPath, "SKILL.md"))) {
+      if (!(await pathExists(path.join(skillPath, "SKILL.md")))) {
         skipped.push(name);
         continue;
       }
       const dest = path.join(ctx.pkgSkillsSource, name);
-      if (fs.existsSync(dest)) {
-        const r = utils.safeRmSync(dest, name + "(源目录)");
+      if (await pathExists(dest)) {
+        const r = await utils.safeRm(dest, name + "(源目录)");
         if (!r.removed && r.reason === "locked") {
           skipped.push(name);
           continue;
         }
       }
-      utils.copyDirSync(skillPath, dest);
-      utils.writeSkillMeta(dest, false);
-      ctx.addPullSource(name, url);
+      await utils.copyDir(skillPath, dest);
+      await utils.writeSkillMeta(dest, false);
+      await ctx.addPullSource(name, url);
       imported.push(name);
     }
     ctx.pullCache.delete(url);
-    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+    try { await fs.promises.rm(tmpDir, { recursive: true, force: true }); } catch {}
     if (imported.length === 0) {
       return utils.sendJSON(res, { error: "所选技能均无效（需包含 SKILL.md）", skipped }, 400);
     }
@@ -237,9 +251,9 @@ function register(router) {
   // GET /api/source-names — 获取别名映射
   // ----------------------------------------------------------------
   router.get("/api/source-names", async (req, res) => {
-    const settings = ctx.readSettings();
+    const settings = await ctx.readSettings();
     const sourceNames = settings._sourceNames || {};
-    const pullSource = ctx.readPullSource();
+    const pullSource = await ctx.readPullSource();
     const knownUrls = [...new Set(Object.values(pullSource).map(v => v.url))].filter(Boolean);
     return utils.sendJSON(res, { names: sourceNames, knownUrls });
   });
@@ -247,9 +261,9 @@ function register(router) {
   // POST /api/source-names — 保存别名映射
   router.post("/api/source-names", async (req, res) => {
     const body = await utils.parseBody(req);
-    const settings = ctx.readSettings();
+    const settings = await ctx.readSettings();
     settings._sourceNames = body.names || {};
-    ctx.writeSettings(settings);
+    await ctx.writeSettings(settings);
     return utils.sendJSON(res, { ok: true });
   });
 
@@ -261,17 +275,17 @@ function register(router) {
     const body = await utils.parseBody(req);
     const { names, enabled } = body;
     if (!Array.isArray(names)) return utils.sendJSON(res, { error: "参数错误" }, 400);
-    const settings = ctx.readSettings();
+    const settings = await ctx.readSettings();
     if (!settings.skills) settings.skills = {};
     const locked = [];
     for (const name of names) {
       const src = path.join(ctx.pkgSkillsSource, name);
       const dest = path.join(ctx.skillsDest, name);
       if (enabled) {
-        if (fs.existsSync(src) && !fs.existsSync(dest)) utils.copyDirSync(src, dest);
+        if (await pathExists(src) && !(await pathExists(dest))) await utils.copyDir(src, dest);
       } else {
-        if (fs.existsSync(dest)) {
-          const r = utils.safeRmSync(dest, name);
+        if (await pathExists(dest)) {
+          const r = await utils.safeRm(dest, name);
           if (!r.removed && r.reason === "locked") {
             locked.push(name);
             continue;
@@ -286,7 +300,7 @@ function register(router) {
         settings.skills[name].enabled = false;
       }
     }
-    ctx.writeSettings(settings);
+    await ctx.writeSettings(settings);
     return utils.sendJSON(res, { ok: true, locked });
   });
 
@@ -298,14 +312,14 @@ function register(router) {
     const body = await utils.parseBody(req);
     const { names } = body;
     if (!Array.isArray(names) || names.length === 0) return utils.sendJSON(res, { error: "参数错误" }, 400);
-    const settings = ctx.readSettings();
+    const settings = await ctx.readSettings();
     const locked = [];
     const deleted = [];
     for (const name of names) {
       const sourceDir = path.join(ctx.pkgSkillsSource, name);
       const destDir = path.join(ctx.skillsDest, name);
-      const r1 = utils.safeRmSync(sourceDir, name + "(源目录)");
-      const r2 = utils.safeRmSync(destDir, name + "(项目目录)");
+      const r1 = await utils.safeRm(sourceDir, name + "(源目录)");
+      const r2 = await utils.safeRm(destDir, name + "(项目目录)");
       if (r1.reason === "locked" || r2.reason === "locked") {
         locked.push(name);
         continue;
@@ -313,7 +327,7 @@ function register(router) {
       if (settings.skills && settings.skills[name] !== undefined) delete settings.skills[name];
       deleted.push(name);
     }
-    ctx.writeSettings(settings);
+    await ctx.writeSettings(settings);
     return utils.sendJSON(res, { ok: true, deleted, locked });
   });
 
@@ -326,7 +340,7 @@ function register(router) {
     if (url && ctx.pullCache.has(url)) {
       const entry = ctx.pullCache.get(url);
       ctx.pullCache.delete(url);
-      try { fs.rmSync(entry.tmpDir, { recursive: true, force: true }); } catch {}
+      try { await fs.promises.rm(entry.tmpDir, { recursive: true, force: true }); } catch {}
     }
     return utils.sendJSON(res, { ok: true });
   });
@@ -337,12 +351,12 @@ function register(router) {
   router.get("/api/skills/:name/source", async (req, res, params) => {
     if (!requireSource(res)) return;
     const name = params.name;
-    const pullSource = ctx.readPullSource();
+    const pullSource = await ctx.readPullSource();
     if (pullSource[name]) {
       return utils.sendJSON(res, { type: "remote", ...pullSource[name] });
     }
     const skillDir = path.join(ctx.pkgSkillsSource, name);
-    if (fs.existsSync(skillDir)) {
+    if (await pathExists(skillDir)) {
       return utils.sendJSON(res, { type: "local", path: skillDir });
     }
     return utils.sendJSON(res, null);
@@ -354,58 +368,58 @@ function register(router) {
   router.post("/api/skills/:name/update", async (req, res, params) => {
     if (!requireSource(res)) return;
     const name = params.name;
-    const pullSource = ctx.readPullSource();
+    const pullSource = await ctx.readPullSource();
     const source = pullSource[name];
     if (!source) return utils.sendJSON(res, { error: "该技能无远程来源，无法更新" }, 400);
 
     const tmpDir = path.join(os.tmpdir(), "mdk-update-" + Date.now());
-    fs.mkdirSync(path.join(tmpDir, ".claude", "skills"), { recursive: true });
+    await fs.promises.mkdir(path.join(tmpDir, ".claude", "skills"), { recursive: true });
     try {
-      await runAsync(ctx.skillsBin + " add \"" + source.url + "\" --copy -y -a claude-code", { cwd: tmpDir, taskId: "skills-update-" + name });
+      await runAsync(ctx.skillsBin + " add " + utils.escapeShellArg(source.url) + " --copy -y -a claude-code", { cwd: tmpDir, taskId: "skills-update-" + name });
     } catch (e) {
-      utils.cleanNpxTemp();
-      utils.safeRmSync(tmpDir, "临时目录");
+      await utils.cleanNpxTemp();
+      await utils.safeRm(tmpDir, "临时目录");
       if (e.killed) return utils.sendJSON(res, { cancelled: true }, 499);
       return utils.sendJSON(res, { error: "重新拉取失败：" + (e.stderr || e.message) }, 400);
     }
-    utils.cleanNpxTemp();
+    await utils.cleanNpxTemp();
     const skillPath = path.join(tmpDir, ".claude", "skills", name);
-    if (!fs.existsSync(path.join(skillPath, "SKILL.md"))) {
-      utils.safeRmSync(tmpDir, "临时目录");
+    if (!(await pathExists(path.join(skillPath, "SKILL.md")))) {
+      await utils.safeRm(tmpDir, "临时目录");
       return utils.sendJSON(res, { error: "远程仓库中未找到该技能" }, 400);
     }
 
     const dest = path.join(ctx.pkgSkillsSource, name);
-    const oldFingerprint = utils.calcSkillFingerprint(dest);
-    const newFingerprint = utils.calcSkillFingerprint(skillPath);
+    const oldFingerprint = await utils.calcSkillFingerprint(dest);
+    const newFingerprint = await utils.calcSkillFingerprint(skillPath);
     if (oldFingerprint === newFingerprint) {
-      utils.safeRmSync(tmpDir, "临时目录");
+      await utils.safeRm(tmpDir, "临时目录");
       return utils.sendJSON(res, { ok: true, updated: false });
     }
 
-    const rSrc = utils.safeRmSync(dest, name + "(源目录)");
+    const rSrc = await utils.safeRm(dest, name + "(源目录)");
     if (!rSrc.removed && rSrc.reason === "locked") {
-      utils.safeRmSync(tmpDir, "临时目录");
+      await utils.safeRm(tmpDir, "临时目录");
       return utils.sendJSON(res, { error: `技能"${name}"被其他程序占用，无法更新`, locked: true }, 409);
     }
-    utils.copyDirSync(skillPath, dest);
+    await utils.copyDir(skillPath, dest);
 
     const projectSkill = path.join(ctx.skillsDest, name);
-    if (fs.existsSync(projectSkill)) {
-      const rProj = utils.safeRmSync(projectSkill, name + "(项目目录)");
+    if (await pathExists(projectSkill)) {
+      const rProj = await utils.safeRm(projectSkill, name + "(项目目录)");
       if (!rProj.removed && rProj.reason === "locked") {
-        utils.safeRmSync(tmpDir, "临时目录");
+        await utils.safeRm(tmpDir, "临时目录");
         return utils.sendJSON(res, { error: `技能"${name}"项目目录被其他程序占用，无法更新`, locked: true }, 409);
       }
-      utils.copyDirSync(skillPath, projectSkill);
+      await utils.copyDir(skillPath, projectSkill);
     }
 
-    utils.writeSkillMeta(dest, true);
+    await utils.writeSkillMeta(dest, true);
     source.pulledAt = new Date().toISOString();
-    ctx.writePullSource(pullSource);
+    await ctx.writePullSource(pullSource);
     const siblings = Object.keys(pullSource).filter(k => k !== name && pullSource[k].url === source.url);
 
-    utils.safeRmSync(tmpDir, "临时目录");
+    await utils.safeRm(tmpDir, "临时目录");
     return utils.sendJSON(res, { ok: true, name, updatedAt: source.pulledAt, siblings });
   });
 
@@ -439,42 +453,42 @@ function register(router) {
     if (!repo || !skillName) return utils.sendJSON(res, { error: "参数错误" }, 400);
 
     const tmpDir = path.join(os.tmpdir(), "mdk-market-" + Date.now());
-    fs.mkdirSync(path.join(tmpDir, ".claude", "skills"), { recursive: true });
+    await fs.promises.mkdir(path.join(tmpDir, ".claude", "skills"), { recursive: true });
     try {
-      await runAsync(ctx.skillsBin + " add " + repo + " --skill \"" + skillName + "\" --copy -y -a claude-code", {
+      await runAsync(ctx.skillsBin + " add " + utils.escapeShellArg(repo) + " --skill " + utils.escapeShellArg(skillName) + " --copy -y -a claude-code", {
         cwd: tmpDir,
         taskId: "skills-install-" + skillName,
       });
     } catch (e) {
-      utils.cleanNpxTemp();
-      utils.safeRmSync(tmpDir, "临时目录");
+      await utils.cleanNpxTemp();
+      await utils.safeRm(tmpDir, "临时目录");
       if (e.killed) return utils.sendJSON(res, { cancelled: true }, 499);
       return utils.sendJSON(res, { error: "安装失败：" + (e.stderr || e.message) }, 400);
     }
-    utils.cleanNpxTemp();
+    await utils.cleanNpxTemp();
 
     const skillPath = path.join(tmpDir, ".claude", "skills", skillName);
-    if (!fs.existsSync(path.join(skillPath, "SKILL.md"))) {
-      utils.safeRmSync(tmpDir, "临时目录");
+    if (!(await pathExists(path.join(skillPath, "SKILL.md")))) {
+      await utils.safeRm(tmpDir, "临时目录");
       return utils.sendJSON(res, { error: "未找到技能文件" }, 400);
     }
 
     const dest = path.join(ctx.pkgSkillsSource, skillName);
-    utils.safeRmSync(dest, skillName + "(源目录)");
-    utils.copyDirSync(skillPath, dest);
-    utils.writeSkillMeta(dest, true);
+    await utils.safeRm(dest, skillName + "(源目录)");
+    await utils.copyDir(skillPath, dest);
+    await utils.writeSkillMeta(dest, true);
 
     const projectSkill = path.join(ctx.skillsDest, skillName);
-    utils.safeRmSync(projectSkill, skillName + "(项目目录)");
-    utils.copyDirSync(skillPath, projectSkill);
-    const settings = ctx.readSettings();
+    await utils.safeRm(projectSkill, skillName + "(项目目录)");
+    await utils.copyDir(skillPath, projectSkill);
+    const settings = await ctx.readSettings();
     if (!settings.skills) settings.skills = {};
     settings.skills[skillName] = { enabled: true };
-    ctx.writeSettings(settings);
+    await ctx.writeSettings(settings);
 
-    ctx.addPullSource(skillName, repo);
+    await ctx.addPullSource(skillName, repo);
 
-    utils.safeRmSync(tmpDir, "临时目录");
+    await utils.safeRm(tmpDir, "临时目录");
     return utils.sendJSON(res, { ok: true, name: skillName });
   });
 
@@ -490,16 +504,16 @@ function register(router) {
     }
 
     const tmpDir = path.join(os.tmpdir(), "mdk-batch-" + Date.now());
-    fs.mkdirSync(path.join(tmpDir, ".claude", "skills"), { recursive: true });
+    await fs.promises.mkdir(path.join(tmpDir, ".claude", "skills"), { recursive: true });
     try {
-      await runAsync(ctx.skillsBin + " add \"" + url + "\" --copy -y -a claude-code", { cwd: tmpDir, taskId: "skills-batch" });
+      await runAsync(ctx.skillsBin + " add " + utils.escapeShellArg(url) + " --copy -y -a claude-code", { cwd: tmpDir, taskId: "skills-batch" });
     } catch (e) {
-      utils.cleanNpxTemp();
-      utils.safeRmSync(tmpDir, "临时目录");
+      await utils.cleanNpxTemp();
+      await utils.safeRm(tmpDir, "临时目录");
       if (e.killed) return utils.sendJSON(res, { cancelled: true }, 499);
       return utils.sendJSON(res, { error: "拉取失败：" + (e.stderr || e.message) }, 400);
     }
-    utils.cleanNpxTemp();
+    await utils.cleanNpxTemp();
 
     const updated = [];
     const unchanged = [];
@@ -507,47 +521,47 @@ function register(router) {
     const locked = [];
     for (const name of names) {
       const skillPath = path.join(tmpDir, ".claude", "skills", name);
-      if (!fs.existsSync(path.join(skillPath, "SKILL.md"))) {
+      if (!(await pathExists(path.join(skillPath, "SKILL.md")))) {
         notFound.push(name);
         continue;
       }
       const dest = path.join(ctx.pkgSkillsSource, name);
-      const newFingerprint = utils.calcSkillFingerprint(skillPath);
-      const oldFingerprint = utils.calcSkillFingerprint(dest);
+      const newFingerprint = await utils.calcSkillFingerprint(skillPath);
+      const oldFingerprint = await utils.calcSkillFingerprint(dest);
       if (oldFingerprint === newFingerprint) {
         unchanged.push(name);
         continue;
       }
-      const rSrc = utils.safeRmSync(dest, name + "(源目录)");
+      const rSrc = await utils.safeRm(dest, name + "(源目录)");
       if (!rSrc.removed && rSrc.reason === "locked") {
         locked.push(name);
         continue;
       }
-      utils.copyDirSync(skillPath, dest);
+      await utils.copyDir(skillPath, dest);
 
       const projectSkill = path.join(ctx.skillsDest, name);
-      if (fs.existsSync(projectSkill)) {
-        const rProj = utils.safeRmSync(projectSkill, name + "(项目目录)");
+      if (await pathExists(projectSkill)) {
+        const rProj = await utils.safeRm(projectSkill, name + "(项目目录)");
         if (!rProj.removed && rProj.reason === "locked") {
           locked.push(name);
           continue;
         }
-        utils.copyDirSync(skillPath, projectSkill);
+        await utils.copyDir(skillPath, projectSkill);
       }
 
-      utils.writeSkillMeta(dest, true);
+      await utils.writeSkillMeta(dest, true);
       updated.push(name);
     }
 
-    const pullSource = ctx.readPullSource();
+    const pullSource = await ctx.readPullSource();
     for (const name of updated) {
       if (pullSource[name]) {
         pullSource[name].pulledAt = new Date().toISOString();
       }
     }
-    ctx.writePullSource(pullSource);
+    await ctx.writePullSource(pullSource);
 
-    utils.safeRmSync(tmpDir, "临时目录");
+    await utils.safeRm(tmpDir, "临时目录");
     return utils.sendJSON(res, { ok: true, updated, unchanged, notFound, locked });
   });
 
@@ -558,11 +572,11 @@ function register(router) {
     if (!requireSource(res)) return;
     const name = params.name;
     const skillDir = path.join(ctx.pkgSkillsSource, name);
-    if (!fs.existsSync(skillDir)) {
+    if (!(await pathExists(skillDir))) {
       return utils.sendJSON(res, { error: "技能目录不存在" }, 404);
     }
     try {
-      execSync("start \"\" \"" + skillDir + "\"", { stdio: "ignore" });
+      openInExplorer(skillDir);
       return utils.sendJSON(res, { ok: true });
     } catch {
       return utils.sendJSON(res, { error: "打开目录失败" }, 500);
@@ -576,8 +590,8 @@ function register(router) {
     if (!requireSource(res)) return;
     const name = params.name;
     const dest = path.join(ctx.skillsDest, name);
-    if (!fs.existsSync(dest)) return utils.sendJSON(res, { ok: true, name, skipped: true });
-    const r = utils.safeRmSync(dest, name);
+    if (!(await pathExists(dest))) return utils.sendJSON(res, { ok: true, name, skipped: true });
+    const r = await utils.safeRm(dest, name);
     if (r.removed) return utils.sendJSON(res, { ok: true, name });
     if (r.reason === "locked") return utils.sendJSON(res, { error: `技能"${name}"被其他程序占用，无法删除`, locked: true }, 409);
     return utils.sendJSON(res, { error: `删除"${name}"失败: ${r.message || "未知错误"}` }, 500);
@@ -591,13 +605,13 @@ function register(router) {
     const name = params.name;
     const src = path.join(ctx.pkgSkillsSource, name);
     const dest = path.join(ctx.skillsDest, name);
-    if (fs.existsSync(dest)) {
-      const r = utils.safeRmSync(dest, name);
+    if (await pathExists(dest)) {
+      const r = await utils.safeRm(dest, name);
       if (!r.removed) return utils.sendJSON(res, { error: `无法覆盖现有目录: ${r.reason}` }, r.reason === "locked" ? 409 : 500);
     }
-    if (!fs.existsSync(src)) return utils.sendJSON(res, { error: `源目录不存在: ${name}` }, 404);
+    if (!(await pathExists(src))) return utils.sendJSON(res, { error: `源目录不存在: ${name}` }, 404);
     try {
-      utils.copyDirSync(src, dest);
+      await utils.copyDir(src, dest);
       return utils.sendJSON(res, { ok: true, name });
     } catch (err) {
       return utils.sendJSON(res, { error: `安装"${name}"失败: ${err.message}` }, 500);
@@ -610,7 +624,7 @@ function register(router) {
   router.post("/api/skills-dest/open", async (req, res) => {
     if (!requireSource(res)) return;
     try {
-      execSync("start \"\" \"" + ctx.skillsDest + "\"", { stdio: "ignore" });
+      openInExplorer(ctx.skillsDest);
       return utils.sendJSON(res, { ok: true });
     } catch {
       return utils.sendJSON(res, { error: "打开目录失败" }, 500);
@@ -625,11 +639,11 @@ function register(router) {
     const name = params.name;
     const skillDir = path.join(ctx.skillsDest, name);
     const altDir = path.join(ctx.pkgSkillsSource, name);
-    const readmePath = [
-      path.join(skillDir, "SKILL.md"),
-      path.join(altDir, "SKILL.md"),
-    ].find((p) => fs.existsSync(p));
-    const content = readmePath ? fs.readFileSync(readmePath, "utf-8") : null;
+    let readmePath = null;
+    for (const p of [path.join(skillDir, "SKILL.md"), path.join(altDir, "SKILL.md")]) {
+      if (await pathExists(p)) { readmePath = p; break; }
+    }
+    const content = readmePath ? await fs.promises.readFile(readmePath, "utf-8") : null;
     return utils.sendJSON(res, { content, found: !!readmePath });
   });
 
@@ -640,13 +654,13 @@ function register(router) {
     if (!requireSource(res)) return;
     const name = params.name;
     const skillDir = path.join(ctx.pkgSkillsSource, name);
-    if (!fs.existsSync(skillDir)) {
+    if (!(await pathExists(skillDir))) {
       return utils.sendJSON(res, { error: "技能不存在" }, 404);
     }
     const metaPath = path.join(skillDir, ".meta.json");
     let meta = {};
-    if (fs.existsSync(metaPath)) {
-      try { meta = JSON.parse(fs.readFileSync(metaPath, "utf-8")); } catch {}
+    if (await pathExists(metaPath)) {
+      try { meta = JSON.parse(await fs.promises.readFile(metaPath, "utf-8")); } catch {}
     }
     const body = await utils.parseBody(req);
     if (body.version !== undefined) meta.version = String(body.version);
@@ -654,7 +668,7 @@ function register(router) {
     if (body.tags !== undefined) {
       meta.tags = Array.isArray(body.tags) ? body.tags.filter((t) => typeof t === "string") : [];
     }
-    fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf-8");
+    await fs.promises.writeFile(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf-8");
     return utils.sendJSON(res, { ok: true, meta });
   });
 
@@ -669,11 +683,11 @@ function register(router) {
     let deleted = [];
     let locked = false;
 
-    const r1 = utils.safeRmSync(sourceDir, name + "(源目录)");
+    const r1 = await utils.safeRm(sourceDir, name + "(源目录)");
     if (r1.removed) deleted.push("源目录");
     else if (r1.reason === "locked") locked = true;
 
-    const r2 = utils.safeRmSync(destDir, name + "(项目目录)");
+    const r2 = await utils.safeRm(destDir, name + "(项目目录)");
     if (r2.removed) deleted.push("项目目录");
     else if (r2.reason === "locked") locked = true;
 
@@ -681,10 +695,10 @@ function register(router) {
       return utils.sendJSON(res, { error: `技能"${name}"被其他程序占用，无法删除`, locked: true }, 409);
     }
 
-    const settings = ctx.readSettings();
+    const settings = await ctx.readSettings();
     if (settings.skills && settings.skills[name] !== undefined) {
       delete settings.skills[name];
-      ctx.writeSettings(settings);
+      await ctx.writeSettings(settings);
     }
 
     if (deleted.length === 0) {