dsh-skill-picker 0.5.21 → 0.5.23

package/lib/index.js

@@ -1,7 +1,7 @@
 // src/index.js
-import { readFile as readFile2, readdir as readdir2 } 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));
 }
@@ -361,11 +514,166 @@ function reportUiSkillPatches(report, io = console) {
     io.warn("[dsh-skill-picker] ui-skill patch errors:", JSON.stringify(errors));
   }
 }
+function sharedStateFile() {
+  return path4.join(dshHome(), "dsh-skill-picker-state.json");
+}
+function normalizeSharedState(value) {
+  const source = value !== null && typeof value === "object" ? value : {};
+  const pinned = Array.isArray(source.pinned) ? [...new Set(source.pinned.filter((name) => typeof name === "string" && name !== ""))] : [];
+  const usage = {};
+  const rawUsage = source.usage !== null && typeof source.usage === "object" ? source.usage : {};
+  for (const [name, entry] of Object.entries(rawUsage)) {
+    if (typeof name !== "string" || name === "") continue;
+    const record = entry !== null && typeof entry === "object" ? entry : {};
+    const count = Number.isFinite(record.count) ? Math.max(0, Math.trunc(record.count)) : 0;
+    const lastUsed = Number.isFinite(record.lastUsed) ? Math.max(0, Math.trunc(record.lastUsed)) : 0;
+    if (count === 0 && lastUsed === 0) continue;
+    usage[name] = { count, lastUsed };
+  }
+  return { pinned, usage };
+}
+async function readSharedState() {
+  try {
+    return normalizeSharedState(JSON.parse(await readFile3(sharedStateFile(), "utf8")));
+  } catch {
+    return null;
+  }
+}
+async function writeSharedState(state) {
+  const normal = normalizeSharedState(state);
+  const file = sharedStateFile();
+  await mkdir2(path4.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp`;
+  await writeFile3(tmp, `${JSON.stringify(normal, null, 2)}
+`, "utf8");
+  await rename3(tmp, file);
+  return normal;
+}
+function mergeSharedState(a, b) {
+  const left = normalizeSharedState(a);
+  const right = normalizeSharedState(b);
+  const pinned = [...left.pinned];
+  for (const name of right.pinned) if (!pinned.includes(name)) pinned.push(name);
+  const usage = { ...left.usage };
+  for (const [name, entry] of Object.entries(right.usage)) {
+    const previous = usage[name];
+    usage[name] = previous === void 0 ? entry : { count: Math.max(previous.count, entry.count), lastUsed: Math.max(previous.lastUsed, entry.lastUsed) };
+  }
+  return normalizeSharedState({ pinned, usage });
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > 1e6) throw new Error("shared state body too large");
+    chunks.push(chunk);
+  }
+  if (chunks.length === 0) return {};
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+async function handleSharedState(req, res, url) {
+  const json = (code, payload) => {
+    res.writeHead(code, { "content-type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify(payload));
+  };
+  try {
+    if (req.method === "PUT" || req.method === "POST") {
+      const incoming = normalizeSharedState(await readJsonBody(req));
+      const migrate = url.searchParams.get("migrate") === "1";
+      const stored = migrate ? await readSharedState() : null;
+      const next = stored === null ? await writeSharedState(incoming) : await writeSharedState(mergeSharedState(stored, incoming));
+      json(200, { ok: true, state: next });
+      return;
+    }
+    json(200, { ok: true, state: await readSharedState() });
+  } catch (error) {
+    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) => {
       try {
-        const cwd = req.url !== void 0 ? new URL(req.url, "http://dsh").searchParams.get("cwd") ?? void 0 : void 0;
+        const url = new URL(req.url ?? "/", "http://dsh");
+        if (url.pathname === "/dsh-skill-picker/state") {
+          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" });
         res.end(JSON.stringify({ ok: true, complete: true, skills }));