mdk-skills 2.4.18 → 2.4.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mdk-skills",
-  "version": "2.4.18",
+  "version": "2.4.20",
   "description": "mdk-engineer - 沉稳靠谱的前端开发助手 Claude Skills 配置包，一键注入 .claude/ 技能目录和 CLAUDE.md 人设配置",
   "author": "XiaoMa",
   "license": "MIT",
@@ -11,7 +11,8 @@
     "scripts/cli.js",
     "scripts/core.js",
     "scripts/web-ui/server.js",
-    "scripts/web-ui/dist/"
+    "scripts/web-ui/dist/",
+    "scripts/web-ui/server/"
   ],
   "bin": {
     "mdk-skills": "./scripts/cli.js"

package/scripts/cli.js

@@ -2,7 +2,7 @@
 
 const fs = require("fs");
 const path = require("path");
-const { getPackageSkills, getUserSkills, getSkillsSource, backupDir, listSkillDirs } = require("./core");
+const { getPackageSkills, getUserSkills, getSkillsSource, backupDir, listSkillDirs, copyDirSync } = require("./core");
 
 // npx 运行时：process.cwd() 是用户项目目录
 // __dirname 是包内 scripts/ 目录
@@ -47,20 +47,6 @@ function writeSettings(settings) {
 
 // ---------- 安装勾选的技能 ----------
 
-// 手动递归拷贝目录，绕开 Windows 中文路径下 fs.cpSync({ recursive: true }) 死锁的 bug
-function copyDirSync(src, dest) {
-  fs.mkdirSync(dest, { recursive: true });
-  for (const item of fs.readdirSync(src)) {
-    const srcPath = path.join(src, item);
-    const destPath = path.join(dest, item);
-    if (fs.statSync(srcPath).isDirectory()) {
-      copyDirSync(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
 function installSelectedSkills(selectedNames) {
   // 创建 .claude/ 和 skills/ 目录
   if (!fs.existsSync(skillsDest)) {

package/scripts/web-ui/server/context.js

@@ -0,0 +1,277 @@
+const fs = require("fs");
+const path = require("path");
+const core = require("../../core");
+
+// ---------- 路径（与 cli.js 保持一致） ----------
+
+const projectRoot = (() => {
+  try {
+    return fs.realpathSync.native(process.cwd());
+  } catch {
+    return process.cwd();
+  }
+})();
+
+let skillsSource = core.getSkillsSource(projectRoot);
+const claudeDest = path.join(projectRoot, ".claude");
+const skillsDest = path.join(claudeDest, "skills");
+const settingsPath = path.join(claudeDest, "settings.json");
+let pkgSkillsSource = skillsSource ? path.join(skillsSource, ".claude", "skills") : null;
+
+// skills 包二进制路径
+const skillsBin = (() => {
+  try {
+    const skillsPkg = require.resolve("skills/package.json");
+    const nmDir = path.dirname(path.dirname(skillsPkg));
+    for (const name of ["skills.cmd", "skills.ps1", "skills"]) {
+      const full = path.join(nmDir, ".bin", name);
+      if (fs.existsSync(full)) return `"${full}"`;
+    }
+  } catch {}
+  const binDir = path.join(projectRoot, "node_modules", ".bin");
+  for (const name of ["skills.cmd", "skills.ps1", "skills"]) {
+    const full = path.join(binDir, name);
+    if (fs.existsSync(full)) return `"${full}"`;
+  }
+  return `"${path.join(binDir, process.platform === "win32" ? "skills.cmd" : "skills")}"`;
+})();
+
+function refreshSource() {
+  skillsSource = core.getSkillsSource(projectRoot);
+  pkgSkillsSource = skillsSource ? path.join(skillsSource, ".claude", "skills") : null;
+}
+
+// ---------- Settings（异步）----------
+
+async function readSettings() {
+  if (!(await pathExists(settingsPath)))
+    return { skills: {}, always_apply_skills: [] };
+  try {
+    return JSON.parse(await fs.promises.readFile(settingsPath, "utf-8"));
+  } catch {
+    return { skills: {}, always_apply_skills: [] };
+  }
+}
+
+async function writeSettings(settings) {
+  if (!(await pathExists(claudeDest))) {
+    await fs.promises.mkdir(claudeDest, { recursive: true });
+  }
+  await fs.promises.writeFile(
+    settingsPath,
+    JSON.stringify(settings, null, 2) + "\n",
+    "utf-8",
+  );
+}
+
+// ---------- pull-source 存储 ----------
+
+function getPullSourcePath() {
+  return path.join(pkgSkillsSource, ".pull-source.json");
+}
+
+async function readPullSource() {
+  if (!pkgSkillsSource) return {};
+  const filePath = getPullSourcePath();
+  if (!(await pathExists(filePath))) return {};
+  try {
+    return JSON.parse(await fs.promises.readFile(filePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+async function writePullSource(data) {
+  await fs.promises.writeFile(getPullSourcePath(), JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+
+async function addPullSource(skillName, url) {
+  const data = await readPullSource();
+  data[skillName] = { url, pulledAt: new Date().toISOString() };
+  await writePullSource(data);
+}
+
+// 检查技能源是否已设置
+function requireSource(res, utils) {
+  if (!skillsSource || !pkgSkillsSource) {
+    utils.sendJSON(res, { error: "未设置技能目录，请在设置中连接" }, 400);
+    return false;
+  }
+  return true;
+}
+
+// ---------- profiles ----------
+
+async function loadProfiles() {
+  const profilesPath = path.join(skillsSource, ".claude", "profiles.json");
+  if (!(await pathExists(profilesPath))) return null;
+  try {
+    return JSON.parse(await fs.promises.readFile(profilesPath, "utf-8")).profiles;
+  } catch {
+    return null;
+  }
+}
+
+// ---------- 异步 npx 管理 ----------
+
+const runningTasks = new Map();
+
+// ---------- pull 缓存 ----------
+
+const pullCache = new Map();
+
+// ---------- 路径检查工具 ----------
+
+async function pathExists(p) {
+  try { await fs.promises.access(p); return true; } catch { return false; }
+}
+
+// ---------- 应用场景 / 安装（异步）----------
+
+async function applyProfile(profile, { copyDir, safeRm }) {
+  const pkgSkills = core.listSkillDirs(pkgSkillsSource);
+  const failedDelete = [];
+  const failedInstall = [];
+
+  let selected;
+  if (profile.skills === null) {
+    return { selected: [], message: "自定义场景，不做自动切换" };
+  } else if (profile.skills.length === 0) {
+    selected = [];
+  } else {
+    selected = profile.skills.filter((s) => pkgSkills.includes(s));
+  }
+
+  if (!(await pathExists(skillsDest))) {
+    await fs.promises.mkdir(skillsDest, { recursive: true });
+  }
+  for (const name of pkgSkills) {
+    const src = path.join(pkgSkillsSource, name);
+    const dest = path.join(skillsDest, name);
+    if (selected.includes(name)) {
+      if (!(await pathExists(dest))) {
+        try { await copyDir(src, dest); } catch (err) {
+          console.error(`安装技能 "${name}" 失败:`, err.message);
+          failedInstall.push(name);
+        }
+      }
+    } else {
+      if (await pathExists(dest)) {
+        const r = await safeRm(dest, name);
+        if (!r.removed) failedDelete.push(name);
+      }
+    }
+  }
+
+  const hasFailed = failedDelete.length > 0 || failedInstall.length > 0;
+  if (!hasFailed) {
+    const settings = await readSettings();
+    if (!settings.skills) settings.skills = {};
+    for (const name of selected) {
+      if (!settings.skills[name]) settings.skills[name] = {};
+      settings.skills[name].enabled = true;
+    }
+    for (const name of Object.keys(settings.skills)) {
+      if (!selected.includes(name) && name[0] !== '_') {
+        delete settings.skills[name];
+      }
+    }
+    if (profile.always_apply) {
+      settings.always_apply_skills = profile.always_apply;
+    }
+    settings._active_profile = profile.id;
+    await writeSettings(settings);
+
+    const profilesSource = path.join(skillsSource, ".claude", "profiles.json");
+    const profilesDest = path.join(claudeDest, "profiles.json");
+    if (await pathExists(profilesSource)) {
+      await fs.promises.copyFile(profilesSource, profilesDest);
+    }
+
+    const mdSource = path.join(skillsSource, "CLAUDE.md");
+    const mdDest = path.join(projectRoot, "CLAUDE.md");
+    if (await pathExists(mdSource) && !(await pathExists(mdDest))) {
+      await fs.promises.copyFile(mdSource, mdDest);
+    }
+  }
+
+  return {
+    selected,
+    enabled: selected.length,
+    disabled: pkgSkills.length - selected.length,
+    failedDelete,
+    failedInstall,
+  };
+}
+
+async function installSelectedSkills(selectedNames, { copyDir, safeRm }) {
+  if (!(await pathExists(pkgSkillsSource))) return { installed: 0, locked: [] };
+  if (!(await pathExists(skillsDest))) {
+    await fs.promises.mkdir(skillsDest, { recursive: true });
+  }
+  const allPkgSkills = core.listSkillDirs(pkgSkillsSource);
+  let installedCount = 0;
+  const locked = [];
+
+  for (const name of allPkgSkills) {
+    const src = path.join(pkgSkillsSource, name);
+    const dest = path.join(skillsDest, name);
+    if (selectedNames.includes(name)) {
+      if (!(await pathExists(dest))) {
+        try { await copyDir(src, dest); installedCount++; } catch (err) {
+          console.error(`安装技能 "${name}" 失败:`, err.message);
+        }
+      }
+    } else {
+      if (await pathExists(dest)) {
+        const r = await safeRm(dest, name);
+        if (!r.removed && r.reason === 'locked') locked.push(name);
+      }
+    }
+  }
+
+  const settings = await readSettings();
+  if (!settings.skills) settings.skills = {};
+  for (const name of allPkgSkills) {
+    const enabled = selectedNames.includes(name);
+    if (!settings.skills[name]) settings.skills[name] = {};
+    settings.skills[name].enabled = enabled;
+  }
+  await writeSettings(settings);
+
+  const mdSource = path.join(skillsSource, "CLAUDE.md");
+  const mdDest = path.join(projectRoot, "CLAUDE.md");
+  if (await pathExists(mdSource) && !(await pathExists(mdDest))) {
+    await fs.promises.copyFile(mdSource, mdDest);
+  }
+
+  return { installed: installedCount, locked };
+}
+
+// ---------- 回调函数注册 ----------
+
+function buildContext(utils) {
+  return {
+    projectRoot,
+    claudeDest,
+    skillsDest,
+    settingsPath,
+    get skillsSource() { return skillsSource; },
+    get pkgSkillsSource() { return pkgSkillsSource; },
+    skillsBin,
+    refreshSource,
+    readSettings,
+    writeSettings,
+    readPullSource,
+    writePullSource,
+    addPullSource,
+    loadProfiles,
+    requireSource: (res) => requireSource(res, utils),
+    applyProfile: (profile) => applyProfile(profile, { copyDir: utils.copyDir, safeRm: utils.safeRm }),
+    installSelectedSkills: (names) => installSelectedSkills(names, { copyDir: utils.copyDir, safeRm: utils.safeRm }),
+    runningTasks,
+    pullCache,
+  };
+}
+
+module.exports = { buildContext };

package/scripts/web-ui/server/router.js

@@ -0,0 +1,69 @@
+/**
+ * 轻量级路由注册器
+ * 支持精确路径和正则路径匹配两种模式
+ * XiaoMa
+ */
+class Router {
+  constructor() {
+    this._routes = [];
+  }
+
+  /**
+   * 注册精确路径路由（支持 :name 参数占位符）
+   * /api/skills/:name/source → /^\/api\/skills\/([^/]+)\/source$/
+   */
+  _register(method, pattern, handler) {
+    if (pattern.includes(":")) {
+      const paramNames = [];
+      const regexStr = pattern.replace(/:([^/]+)/g, (_, name) => {
+        paramNames.push(name);
+        return "([^/]+)";
+      });
+      this._routes.push({
+        method,
+        regex: new RegExp("^" + regexStr + "$"),
+        paramNames,
+        handler,
+      });
+    } else {
+      this._routes.push({ method, path: pattern, handler });
+    }
+  }
+
+  get(pattern, handler) { this._register("GET", pattern, handler); return this; }
+  post(pattern, handler) { this._register("POST", pattern, handler); return this; }
+  patch(pattern, handler) { this._register("PATCH", pattern, handler); return this; }
+  delete(pattern, handler) { this._register("DELETE", pattern, handler); return this; }
+
+  /**
+   * 匹配路由并执行
+   * @returns {boolean} 是否匹配到路由
+   */
+  async dispatch(method, pathname, req, res) {
+    for (const route of this._routes) {
+      if (route.method !== method) continue;
+
+      if (route.path) {
+        // 精确路径匹配
+        if (route.path === pathname) {
+          await route.handler(req, res);
+          return true;
+        }
+      } else if (route.regex) {
+        // 正则路径匹配（含参数）
+        const match = pathname.match(route.regex);
+        if (match) {
+          const params = {};
+          route.paramNames.forEach((name, i) => {
+            params[name] = decodeURIComponent(match[i + 1]);
+          });
+          await route.handler(req, res, params);
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+}
+
+module.exports = { Router };

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

@@ -0,0 +1,249 @@
+const path = require("path");
+const fs = require("fs");
+const core = require("../../../core");
+const utils = require("../utils");
+const { buildContext } = require("../context");
+
+const ctx = buildContext(utils);
+
+async function pathExists(p) {
+  try { await fs.promises.access(p); return true; } catch { return false; }
+}
+
+function register(router) {
+
+  // ----------------------------------------------------------------
+  // GET /api/readme — 获取根目录 README.md
+  // ----------------------------------------------------------------
+  router.get("/api/readme", async (req, res) => {
+    if (!ctx.skillsSource) return utils.sendJSON(res, { content: null, found: false });
+    const p = path.join(ctx.skillsSource, "README.md");
+    let content = null;
+    if (await pathExists(p)) {
+      content = await fs.promises.readFile(p, "utf-8");
+    }
+    return utils.sendJSON(res, { content, found: !!content });
+  });
+
+  // ----------------------------------------------------------------
+  // GET /api/skills-readme — 获取技能目录 README.md
+  // ----------------------------------------------------------------
+  router.get("/api/skills-readme", async (req, res) => {
+    if (!ctx.skillsSource) return utils.sendJSON(res, { content: null, found: false });
+    const p = path.join(ctx.skillsSource, ".claude", "skills", "README.md");
+    let content = null;
+    if (await pathExists(p)) {
+      content = await fs.promises.readFile(p, "utf-8");
+    }
+    return utils.sendJSON(res, { content, found: !!content });
+  });
+
+  // ----------------------------------------------------------------
+  // GET /api/claudemd — 获取 CLAUDE.md 内容
+  // ----------------------------------------------------------------
+  router.get("/api/claudemd", async (req, res) => {
+    const paths = ctx.skillsSource
+      ? [path.join(ctx.skillsSource, "CLAUDE.md"), path.join(ctx.projectRoot, "CLAUDE.md")]
+      : [path.join(ctx.projectRoot, "CLAUDE.md")];
+    let content = null;
+    for (const p of paths) {
+      if (await pathExists(p)) {
+        content = await fs.promises.readFile(p, "utf-8");
+        break;
+      }
+    }
+    return utils.sendJSON(res, { content, found: !!content });
+  });
+
+  // ----------------------------------------------------------------
+  // POST /api/readme/create — 创建 README.md 文档
+  // ----------------------------------------------------------------
+  router.post("/api/readme/create", async (req, res) => {
+    const body = await utils.parseBody(req);
+    const settings = await ctx.readSettings();
+    const sourcePath = settings._skill_source;
+    if (!sourcePath) return utils.sendJSON(res, { error: "未绑定本地源" }, 400);
+
+    const { root, skills, projectName, teamName } = body;
+    const name = projectName || "我的技能仓库";
+    const team = teamName || "未设定";
+    const created = [];
+    const skipped = [];
+
+    const skillsDir = path.join(sourcePath, ".claude", "skills");
+    const skillNames = await pathExists(skillsDir)
+      ? core.listSkillDirs(skillsDir)
+      : [];
+    const skillsList = skillNames.length
+      ? skillNames.map((s) => `- \`${s}\``).join("\n")
+      : "<!-- 暂无技能 -->";
+
+    // 根目录 README.md
+    if (root) {
+      const rootPath = path.join(sourcePath, "README.md");
+      if (!(await pathExists(rootPath))) {
+        const tmpl = `# ${name}
+
+> 维护团队：${team}
+
+## 简介
+
+<!--
+在这里写这个技能仓库的简介。
+
+示例：
+本仓库包含面向 mdk-engineer 的前端开发技能集，涵盖 Vue3 组件开发、Chrome DevTools 使用、性能优化等方向。
+-->
+
+## 技能列表
+
+${skillsList}
+
+## 使用方式
+
+本仓库通过 mdk-skills 管理技能，连接本地源后即可在 Web UI 中查看和安装技能。
+
+## License
+
+<!-- 许可证信息 -->
+`;
+        await fs.promises.writeFile(rootPath, tmpl, "utf-8");
+        created.push("README.md");
+      } else {
+        skipped.push("README.md");
+      }
+    }
+
+    // skills/README.md
+    if (skills) {
+      const skillsReadmePath = path.join(skillsDir, "README.md");
+      if (!(await pathExists(skillsReadmePath))) {
+        const tmpl = `# 技能说明
+
+## 快速开始
+
+<!--
+安装 mdk-skills 后连接本仓库，即可在 Web UI 中查看所有技能。
+-->
+
+## 场景建议
+
+<!--
+这里可以写哪些技能适合一起使用，不同开发场景下的推荐组合。
+
+示例：
+- 日常开发：启用代码格式化、ESLint 校验、Git 辅助
+- 性能优化：启用 Lighthouse、Bundle Analysis
+-->
+
+## 注意事项
+
+<!--
+技能使用过程中的注意事项。
+-->
+`;
+        await fs.promises.writeFile(skillsReadmePath, tmpl, "utf-8");
+        created.push("skills/README.md");
+      } else {
+        skipped.push("skills/README.md");
+      }
+    }
+
+    return utils.sendJSON(res, { ok: true, created, skipped });
+  });
+
+  // ----------------------------------------------------------------
+  // GET /api/diagnose — 健康检查
+  // ----------------------------------------------------------------
+  router.get("/api/diagnose", async (req, res) => {
+    if (!ctx.skillsSource || !ctx.pkgSkillsSource) {
+      return utils.sendJSON(res, { error: "未设置技能目录，请在设置中连接" }, 400);
+    }
+    const results = [];
+    const pkgSkills = core.getPackageSkills(ctx.skillsSource);
+    for (const skill of pkgSkills) {
+      const skillDir = path.join(ctx.skillsDest, skill.name);
+      const issues = [];
+      if (!(await pathExists(skillDir))) {
+        issues.push("未安装");
+      } else {
+        if (!(await pathExists(path.join(skillDir, "SKILL.md")))) {
+          issues.push("缺少 SKILL.md");
+        } else if (!core.parseFrontmatter(skillDir)) {
+          issues.push("SKILL.md frontmatter 格式异常");
+        }
+      }
+      results.push({
+        name: skill.name,
+        healthy: issues.length === 0,
+        issues,
+      });
+    }
+    return utils.sendJSON(res, results);
+  });
+
+  // ----------------------------------------------------------------
+  // POST /api/tasks/cancel — 取消正在执行的 npx 操作
+  // ----------------------------------------------------------------
+  router.post("/api/tasks/cancel", async (req, res) => {
+    const body = await utils.parseBody(req);
+    if (body.taskId) {
+      const proc = ctx.runningTasks.get(body.taskId);
+      if (proc) { proc.kill(); ctx.runningTasks.delete(body.taskId); }
+    }
+    return utils.sendJSON(res, { ok: true });
+  });
+
+  // ----------------------------------------------------------------
+  // POST /api/fs/list — 列出指定路径下的子目录
+  // ----------------------------------------------------------------
+  router.post("/api/fs/list", async (req, res) => {
+    const body = await utils.parseBody(req);
+    const dirPath = body.path || "";
+    let entries = [];
+
+    if (!dirPath || dirPath === "") {
+      if (process.platform === "win32") {
+        entries = await utils.getWindowsDrives();
+      } else {
+        entries = [{ name: "/", isDir: true }];
+      }
+    } else {
+      try {
+        const items = await fs.promises.readdir(dirPath, { withFileTypes: true });
+        entries = items
+          .filter((item) => item.isDirectory())
+          .map((item) => ({ name: item.name, isDir: true }))
+          .sort((a, b) => a.name.localeCompare(b.name));
+      } catch {
+        return utils.sendJSON(res, { ok: false, error: "无法读取目录" }, 400);
+      }
+    }
+    return utils.sendJSON(res, { ok: true, entries, path: dirPath });
+  });
+
+  // ----------------------------------------------------------------
+  // POST /api/fs/validate — 验证路径是否为有效技能目录
+  // ----------------------------------------------------------------
+  router.post("/api/fs/validate", async (req, res) => {
+    const body = await utils.parseBody(req);
+    const dirPath = body.path;
+    if (!dirPath) return utils.sendJSON(res, { error: "缺少路径" }, 400);
+
+    const skillsDir = path.join(dirPath, ".claude", "skills");
+    const valid = await pathExists(skillsDir);
+    let skillCount = 0;
+    if (valid) {
+      skillCount = core.listSkillDirs(skillsDir).length;
+    }
+    return utils.sendJSON(res, {
+      ok: true,
+      valid,
+      hasClaudeDir: valid,
+      skillCount,
+      path: dirPath,
+    });
+  });
+}
+
+module.exports = { register };