dsh-skill-picker 0.5.22 → 0.5.23

package/lib/index.js

@@ -1,7 +1,7 @@
 // src/index.js
-import { mkdir, readFile as readFile2, readdir as readdir2, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile3, readdir as readdir3, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
 import os2 from "node:os";
-import path3 from "node:path";
+import path4 from "node:path";
 
 // src/dir-entry.js
 import { stat } from "node:fs/promises";
@@ -242,17 +242,160 @@ async function healUiSkillPatches() {
   return { files: filesReport, errors };
 }
 
+// src/skill-ops.js
+import { spawn } from "node:child_process";
+import { mkdir, readFile as readFile2, readdir as readdir2, rename as rename2, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
+import path3 from "node:path";
+var ENTRY = "SKILL.md";
+var DISABLED_ENTRY = `${ENTRY}.disabled`;
+var CLIENT_HEADER = "x-dsh-skill-picker";
+function skillBackupDir() {
+  return path3.join(dshHome(), "skill-backups");
+}
+function resolveSkillPath(candidate, roots) {
+  if (typeof candidate !== "string" || candidate === "") return void 0;
+  const list = Array.isArray(roots) ? roots : [];
+  const resolved = path3.resolve(candidate);
+  for (const root of list) {
+    const base = path3.resolve(root);
+    const relative = path3.relative(base, resolved);
+    if (relative === "" || relative.startsWith("..") || path3.isAbsolute(relative)) continue;
+    if (relative.split(path3.sep).filter(Boolean).length !== 1) continue;
+    return resolved;
+  }
+  return void 0;
+}
+async function pathKind(target) {
+  try {
+    return (await stat2(target)).isDirectory() ? "dir" : "file";
+  } catch {
+    return void 0;
+  }
+}
+async function exists(candidate) {
+  try {
+    await stat2(candidate);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function setSkillDisabled(target, disabled) {
+  const kind = await pathKind(target);
+  if (kind === void 0) throw new Error(`skill not found: ${target}`);
+  const dir = kind === "dir" ? target : path3.dirname(target);
+  const base = kind === "dir" ? ENTRY : path3.basename(target);
+  const plain = path3.join(dir, base);
+  const off = path3.join(dir, `${base}.disabled`);
+  const hasPlain = await exists(plain);
+  const hasOff = await exists(off);
+  if (disabled) {
+    if (hasOff && !hasPlain) throw new Error("already disabled");
+    if (!hasPlain) throw new Error(`cannot disable: ${base} is not there`);
+    if (hasOff) throw new Error(`cannot disable: ${base} and ${base}.disabled both exist`);
+    await rename2(plain, off);
+    return { entry: `${base}.disabled`, disabled: true };
+  }
+  if (hasPlain && !hasOff) throw new Error("already enabled");
+  if (!hasOff) throw new Error(`cannot enable: ${base}.disabled is not there`);
+  if (hasPlain) throw new Error(`cannot enable: ${base} and ${base}.disabled both exist`);
+  await rename2(off, plain);
+  return { entry: base, disabled: false };
+}
+async function uninstallSkill(target) {
+  const kind = await pathKind(target);
+  if (kind === void 0) throw new Error(`skill not found: ${target}`);
+  const name = path3.basename(target);
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = path3.join(skillBackupDir(), `${stamp}-${name}`);
+  await mkdir(backupPath, { recursive: true });
+  await rename2(target, path3.join(backupPath, name));
+  await writeFile2(path3.join(backupPath, "manifest.json"), `${JSON.stringify({
+    name,
+    kind,
+    originalPath: target,
+    movedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }, null, 2)}
+`, "utf8");
+  return { backupPath, restoreTarget: target };
+}
+async function listSkillBackups(roots) {
+  let entries;
+  try {
+    entries = await readdir2(skillBackupDir(), { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const backups = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const dir = path3.join(skillBackupDir(), entry.name);
+    try {
+      const manifest = JSON.parse(await readFile2(path3.join(dir, "manifest.json"), "utf8"));
+      backups.push({
+        id: entry.name,
+        name: typeof manifest.name === "string" ? manifest.name : entry.name,
+        originalPath: typeof manifest.originalPath === "string" ? manifest.originalPath : void 0,
+        movedAt: typeof manifest.movedAt === "string" ? manifest.movedAt : void 0,
+        restorable: resolveSkillPath(manifest.originalPath, roots) !== void 0
+      });
+    } catch {
+    }
+  }
+  return backups.sort((a, b) => String(b.movedAt ?? "").localeCompare(String(a.movedAt ?? "")));
+}
+async function restoreSkillBackup(id, roots) {
+  if (typeof id !== "string" || id === "" || id.includes("/") || id.includes("\\") || id.includes("..")) {
+    throw new Error("invalid backup id");
+  }
+  const dir = path3.join(skillBackupDir(), id);
+  let manifest;
+  try {
+    manifest = JSON.parse(await readFile2(path3.join(dir, "manifest.json"), "utf8"));
+  } catch {
+    throw new Error("that backup is gone");
+  }
+  const original = resolveSkillPath(manifest.originalPath, roots);
+  if (original === void 0) throw new Error("that backup no longer points inside a skill root");
+  if (await exists(original)) {
+    throw new Error(`${path3.basename(original)} is occupied again \u2014 move it away first`);
+  }
+  await rename2(path3.join(dir, path3.basename(original)), original);
+  const done = path3.join(skillBackupDir(), ".restored");
+  await mkdir(done, { recursive: true });
+  await rename2(dir, path3.join(done, id)).catch(() => {
+  });
+  return { restored: original };
+}
+function revealSkill(target, revealPath) {
+  const show = typeof revealPath === "string" && revealPath !== "" ? revealPath : target;
+  try {
+    if (process.platform === "win32") {
+      spawn("explorer.exe", [`/select,${show}`], { detached: true, stdio: "ignore" }).unref();
+      return true;
+    }
+    if (process.platform === "darwin") {
+      spawn("open", ["-R", show], { detached: true, stdio: "ignore" }).unref();
+      return true;
+    }
+    spawn("xdg-open", [path3.dirname(show)], { detached: true, stdio: "ignore" }).unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/index.js
 var inject = ["webServer", "systemPrompt"];
 var SECTION_ORDER = 215;
 var SKILL_PICKER_GUIDANCE = "\u672C\u673A\u5DF2\u5B89\u88C5 dsh-skill-picker \u63D2\u4EF6\uFF08Web GUI \u7684\u6280\u80FD\u9009\u62E9\u5668\uFF09\uFF1A\u8F93\u5165\u6846\u65C1\u6709\u6280\u80FD\u6309\u94AE\uFF0C\u7528\u6237\u70B9\u9009\u6280\u80FD\u540E\u4F1A\u628A `/\u6280\u80FD\u540D`\uFF08\u5982 /duo-xuan-pi-gai\uFF09\u63D2\u5165\u53D1\u9001\u6846\u5E76\u968F\u6D88\u606F\u53D1\u51FA\u3002DSH \u5B98\u65B9\u673A\u5236\u4F1A\u628A\u7528\u6237\u6D88\u606F\u91CC\u7684 `/\u6280\u80FD\u540D` \u624B\u52BF\u5F53\u4F5C\u6280\u80FD\u76F4\u63A5\u8C03\u7528\u5E76\u81EA\u52A8\u52A0\u8F7D\u6280\u80FD\u5185\u5BB9\u2014\u2014\u4F60\u7167\u5E38\u6309\u52A0\u8F7D\u540E\u7684\u6280\u80FD\u6307\u4EE4\u6267\u884C\u5373\u53EF\uFF0C\u65E0\u9700\u989D\u5916\u64CD\u4F5C\u3002\u7528\u6237\u8BF4\u300C\u6280\u80FD\u9009\u62E9\u5668 / \u9009\u4E2A\u6280\u80FD / \u6280\u80FD\u5217\u8868\u300D\u65F6\u5373\u6307\u672C\u63D2\u4EF6\u3002";
 function userSkillsDir() {
-  const home = process.env.DSH_HOME ?? path3.join(os2.homedir(), ".dsh");
-  return path3.join(home, "skills");
+  const home = process.env.DSH_HOME ?? path4.join(os2.homedir(), ".dsh");
+  return path4.join(home, "skills");
 }
 function userAgentsSkillsDir() {
-  const agentsHome = process.env.DSH_AGENTS_HOME ?? path3.join(os2.homedir(), ".agents");
-  return path3.join(agentsHome, "skills");
+  const agentsHome = process.env.DSH_AGENTS_HOME ?? path4.join(os2.homedir(), ".agents");
+  return path4.join(agentsHome, "skills");
 }
 function frontmatterBlock(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
@@ -312,25 +455,35 @@ function isUserInvocableSkill(meta, content) {
 async function scanSkillsDirInto(map, dir) {
   let entries;
   try {
-    entries = await readdir2(dir, { withFileTypes: true });
+    entries = await readdir3(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (!await isDirectoryEntry(dir, entry)) continue;
-    const skillDir = path3.join(dir, entry.name);
+    const skillDir = path4.join(dir, entry.name);
     let content;
+    let entryFile = ENTRY;
+    let disabled = false;
     try {
-      content = await readFile2(path3.join(skillDir, "SKILL.md"), "utf8");
+      content = await readFile3(path4.join(skillDir, ENTRY), "utf8");
     } catch {
-      continue;
+      try {
+        content = await readFile3(path4.join(skillDir, DISABLED_ENTRY), "utf8");
+        entryFile = DISABLED_ENTRY;
+        disabled = true;
+      } catch {
+        continue;
+      }
     }
     const meta = parseFrontmatter(content);
     if (!isUserInvocableSkill(meta, content)) continue;
     map.set(meta.name ?? entry.name, {
       name: meta.name ?? entry.name,
       description: meta.description ?? "",
-      path: skillDir
+      path: skillDir,
+      entry: entryFile,
+      disabled
     });
   }
 }
@@ -339,8 +492,8 @@ async function scanSkills(cwd) {
   await scanSkillsDirInto(map, userAgentsSkillsDir());
   await scanSkillsDirInto(map, userSkillsDir());
   if (typeof cwd === "string" && cwd !== "") {
-    await scanSkillsDirInto(map, path3.join(cwd, ".agents", "skills"));
-    await scanSkillsDirInto(map, path3.join(cwd, ".dsh", "skills"));
+    await scanSkillsDirInto(map, path4.join(cwd, ".agents", "skills"));
+    await scanSkillsDirInto(map, path4.join(cwd, ".dsh", "skills"));
   }
   return [...map.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
@@ -362,7 +515,7 @@ function reportUiSkillPatches(report, io = console) {
   }
 }
 function sharedStateFile() {
-  return path3.join(dshHome(), "dsh-skill-picker-state.json");
+  return path4.join(dshHome(), "dsh-skill-picker-state.json");
 }
 function normalizeSharedState(value) {
   const source = value !== null && typeof value === "object" ? value : {};
@@ -381,7 +534,7 @@ function normalizeSharedState(value) {
 }
 async function readSharedState() {
   try {
-    return normalizeSharedState(JSON.parse(await readFile2(sharedStateFile(), "utf8")));
+    return normalizeSharedState(JSON.parse(await readFile3(sharedStateFile(), "utf8")));
   } catch {
     return null;
   }
@@ -389,11 +542,11 @@ async function readSharedState() {
 async function writeSharedState(state) {
   const normal = normalizeSharedState(state);
   const file = sharedStateFile();
-  await mkdir(path3.dirname(file), { recursive: true });
+  await mkdir2(path4.dirname(file), { recursive: true });
   const tmp = `${file}.tmp`;
-  await writeFile2(tmp, `${JSON.stringify(normal, null, 2)}
+  await writeFile3(tmp, `${JSON.stringify(normal, null, 2)}
 `, "utf8");
-  await rename2(tmp, file);
+  await rename3(tmp, file);
   return normal;
 }
 function mergeSharedState(a, b) {
@@ -438,6 +591,75 @@ async function handleSharedState(req, res, url) {
     json(500, { ok: false, error: String(error?.message ?? error) });
   }
 }
+function allSkillRoots(cwd) {
+  const roots = [userAgentsSkillsDir(), userSkillsDir()];
+  if (typeof cwd === "string" && cwd !== "") {
+    roots.push(path4.join(cwd, ".agents", "skills"), path4.join(cwd, ".dsh", "skills"));
+  }
+  return roots;
+}
+async function handleSkillOp(req, res, url) {
+  const json = (code, payload) => {
+    res.writeHead(code, { "content-type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify(payload));
+  };
+  if (req.method !== "POST") {
+    json(405, { ok: false, error: "POST only" });
+    return;
+  }
+  if (req.headers[CLIENT_HEADER] !== "1") {
+    json(403, { ok: false, error: "missing client header" });
+    return;
+  }
+  try {
+    const body = await readJsonBody(req);
+    const cwd = url.searchParams.get("cwd") ?? void 0;
+    const roots = allSkillRoots(cwd);
+    const action = String(body?.action ?? "");
+    if (action === "backups") {
+      json(200, { ok: true, backups: await listSkillBackups(roots) });
+      return;
+    }
+    if (action === "restore") {
+      json(200, { ok: true, ...await restoreSkillBackup(body?.id, roots) });
+      return;
+    }
+    const name = String(body?.name ?? "");
+    if (name === "") {
+      json(400, { ok: false, error: "name is required" });
+      return;
+    }
+    const known = (await scanSkills(cwd)).find((skill) => skill.name === name);
+    if (known === void 0) {
+      json(404, { ok: false, error: `no skill named "${name}"` });
+      return;
+    }
+    const target = resolveSkillPath(known.path, roots);
+    if (target === void 0) {
+      json(403, { ok: false, error: "that skill lives outside the skill roots" });
+      return;
+    }
+    if (action === "disable") {
+      json(200, { ok: true, ...await setSkillDisabled(target, true) });
+      return;
+    }
+    if (action === "enable") {
+      json(200, { ok: true, ...await setSkillDisabled(target, false) });
+      return;
+    }
+    if (action === "reveal") {
+      json(200, { ok: true, revealed: revealSkill(target) });
+      return;
+    }
+    if (action === "uninstall") {
+      json(200, { ok: true, ...await uninstallSkill(target) });
+      return;
+    }
+    json(400, { ok: false, error: `unknown action: ${action}` });
+  } catch (error) {
+    json(500, { ok: false, error: String(error?.message ?? error) });
+  }
+}
 function apply(ctx) {
   ctx.effect(() => {
     const handler = async (req, res) => {
@@ -447,6 +669,10 @@ function apply(ctx) {
           await handleSharedState(req, res, url);
           return;
         }
+        if (url.pathname === "/dsh-skill-picker/skill") {
+          await handleSkillOp(req, res, url);
+          return;
+        }
         const cwd = url.searchParams.get("cwd") ?? void 0;
         const skills = await scanSkills(cwd);
         res.writeHead(200, { "content-type": "application/json; charset=utf-8" });