@kwonye/mcpx 0.1.104 → 0.1.106

package/dist/chunk-4xym942z.js

@@ -0,0 +1,36 @@
+import {
+  buildDaemonChildEnv,
+  getDaemonStatus,
+  readDaemonLogs,
+  resolveGatewayPort,
+  restartDaemon,
+  runDaemonForeground,
+  startDaemon,
+  stopDaemon
+} from "./chunk-wvzap0na.js";
+import"./chunk-1mrkz29t.js";
+import"./chunk-4aafp444.js";
+import"./chunk-a2gen8bn.js";
+import"./chunk-wztmp5b4.js";
+import"./chunk-8v13hqrp.js";
+import"./chunk-t20f49g3.js";
+import"./chunk-hahs24dv.js";
+import"./chunk-chaj8a8b.js";
+import"./chunk-7rq88hb3.js";
+import"./chunk-brxwa30j.js";
+import"./chunk-p7yzyt87.js";
+import"./chunk-grkz21sq.js";
+import"./chunk-bjw71y54.js";
+import"./chunk-wj4tjacg.js";
+export {
+  buildDaemonChildEnv,
+  getDaemonStatus,
+  readDaemonLogs,
+  resolveGatewayPort,
+  restartDaemon,
+  runDaemonForeground,
+  startDaemon,
+  stopDaemon
+};
+
+//# debugId=7E85224A0D63747064756E2164756E21

package/dist/{chunk-tnhekcpv.js → chunk-56z18csx.js}

@@ -1484,4 +1484,4 @@ var require_src = __commonJS(function(exports) {
 
 export { require_src };
 
-//# debugId=6F7C2FCF52BCCAE864756E2164756E21
+//# debugId=695EAAE1C53734E664756E2164756E21

package/dist/{chunk-bnbz55g6.js → chunk-65kshh9w.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-c7zg7ey3.js";
 import {
   require_src
-} from "./chunk-tnhekcpv.js";
+} from "./chunk-56z18csx.js";
 import {
   __commonJS,
   __require

package/dist/{chunk-xydajvzg.js → chunk-7ky3rsw9.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-c7zg7ey3.js";
 import {
   require_src
-} from "./chunk-tnhekcpv.js";
+} from "./chunk-56z18csx.js";
 import {
   __commonJS
 } from "./chunk-wj4tjacg.js";

package/dist/chunk-7rq88hb3.js

@@ -0,0 +1,563 @@
+import {
+  loadConfig
+} from "./chunk-brxwa30j.js";
+import {
+  exports_external
+} from "./chunk-p7yzyt87.js";
+import {
+  ensureDir,
+  getPluginCacheRoot,
+  getSkillPackagesRoot,
+  getSkillStatePath,
+  getSkillsDir
+} from "./chunk-grkz21sq.js";
+
+// src/core/skills.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+
+// src/core/identifiers.ts
+var skillIdSchema = exports_external.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/);
+function validateSkillId(id) {
+  const result = skillIdSchema.safeParse(id);
+  if (!result.success) {
+    throw new Error(`Invalid skill id "${id}". Use letters, numbers, dots, underscores, and hyphens.`);
+  }
+  return id;
+}
+function normalizePluginName(name) {
+  const normalized = name.replace(/[\\/]/g, "_").replace(/^\.+/, "").replace(/[^a-zA-Z0-9._-]/g, "_");
+  if (!normalized) {
+    throw new Error(`Invalid plugin name "${name}"`);
+  }
+  return normalized;
+}
+
+// src/core/plugin-source.ts
+var GITHUB_RE = /^(?:github\.com\/)?([a-zA-Z0-9][\w.-]*\/[a-zA-Z0-9][\w.-]*?)(?:@([\w./-]+))?$/;
+var GIT_URL_RE = /^https?:\/\/.*\.git(?:\?.*)?(?:\/\/.*)?$/;
+var SCP_GIT_RE = /^[\w.-]+@[\w.-]+:[\w./-]+$/;
+var NPM_RE = /^npm:(@?[\w.-]+(?:\/[\w.-]+)?)(?:@([\w.-]+))?$/;
+var MARKETPLACE_RE = /^marketplace:([\w.-]+)$/;
+function parseSource(source) {
+  const github = source.match(GITHUB_RE);
+  if (github) {
+    return {
+      type: "github",
+      original: source,
+      ref: github[2] || undefined
+    };
+  }
+  if (NPM_RE.test(source)) {
+    const npm = source.match(NPM_RE);
+    return {
+      type: "npm",
+      original: source,
+      ref: npm[2] || undefined
+    };
+  }
+  if (MARKETPLACE_RE.test(source)) {
+    return {
+      type: "marketplace",
+      original: source
+    };
+  }
+  if (source.startsWith("/") || source.startsWith("./") || source.startsWith("../") || source === "." || source === "..") {
+    return {
+      type: "local",
+      original: source
+    };
+  }
+  if (GIT_URL_RE.test(source) || SCP_GIT_RE.test(source)) {
+    return {
+      type: "git",
+      original: source
+    };
+  }
+  throw new Error(`Unrecognized plugin source: ${source}`);
+}
+
+// src/core/plugin-cache.ts
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var TMP_PREFIX = "mcpx-acquire-";
+var execFileAsync = promisify(execFile);
+
+class PluginCache {
+  cacheRoot;
+  constructor() {
+    this.cacheRoot = getPluginCacheRoot();
+    ensureDir(this.cacheRoot);
+  }
+  sourceDir(source) {
+    const key = source.type === "github" ? `github_${source.original.split("@")[0].replace(/[^a-zA-Z0-9_/-]/g, "_")}` : source.type === "npm" ? `npm_${source.original.replace(/^npm:/, "").split("@")[0].replace(/[^a-zA-Z0-9_/-]/g, "_")}` : source.type === "local" ? `local_${source.original.replace(/[^a-zA-Z0-9_/-]/g, "_")}` : source.type === "git-subdir" ? `git_subdir_${`${source.original}/${source.path ?? ""}`.replace(/[^a-zA-Z0-9_./@-]/g, "_")}` : `git_${source.original.replace(/[^a-zA-Z0-9_./@-]/g, "_")}`;
+    return path.join(this.cacheRoot, key);
+  }
+  refPath(srcDir) {
+    return path.join(srcDir, "ref.json");
+  }
+  shaDir(srcDir, sha) {
+    return path.join(srcDir, sha);
+  }
+  async resolveSha(source) {
+    const srcDir = this.sourceDir(source);
+    if (source.type === "github") {
+      const repo = source.original.replace(/^github\.com\//, "").split("@")[0];
+      const ref = source.ref || "HEAD";
+      const { stdout } = await execFileAsync("git", ["ls-remote", `https://github.com/${repo}.git`, ref], { timeout: 30000 });
+      const sha = stdout.split("\t")[0]?.trim();
+      if (!sha)
+        throw new Error(`Could not resolve ref ${ref} for ${repo}`);
+      return sha;
+    }
+    if (source.type === "git" || source.type === "git-subdir") {
+      const ref = source.ref || "HEAD";
+      const { stdout } = await execFileAsync("git", ["ls-remote", source.original, ref], { timeout: 30000 });
+      const sha = stdout.split("\t")[0]?.trim();
+      if (!sha)
+        throw new Error(`Could not resolve ref ${ref} for ${source.original}`);
+      return sha;
+    }
+    if (source.type === "local") {
+      const resolved = path.resolve(source.original);
+      if (!fs.existsSync(resolved)) {
+        throw new Error(`Local path not found: ${resolved}`);
+      }
+      return computeTreeHash(resolved);
+    }
+    if (source.type === "npm") {
+      const pkg = source.original.replace(/^npm:/, "");
+      const spec = source.ref ? `${pkg}@${source.ref}` : pkg;
+      const { stdout } = await execFileAsync("npm", ["view", spec, "version", "dist.integrity", "--json"], { timeout: 30000 });
+      const metadata = JSON.parse(stdout);
+      if (!metadata.version)
+        throw new Error(`Could not resolve npm package ${spec}`);
+      return `npm-${metadata.version}-${metadata.dist?.integrity ?? metadata["dist.integrity"] ?? "unverified"}`;
+    }
+    throw new Error(`Cannot resolve SHA for source type: ${source.type}`);
+  }
+  async fetch(source, pluginName) {
+    const sha = source.resolvedSha || await this.resolveSha(source);
+    const srcDir = this.sourceDir(source);
+    const destDir = this.shaDir(srcDir, sha);
+    if (fs.existsSync(destDir)) {
+      this.updateRef(srcDir, sha);
+      return { source: source.original, name: pluginName, sha, root: destDir };
+    }
+    ensureDir(srcDir);
+    if (source.type === "github" || source.type === "git" || source.type === "git-subdir") {
+      const remote = source.type === "github" ? `https://github.com/${source.original.replace(/^github\.com\//, "").split("@")[0]}.git` : source.original;
+      const target = source.resolvedSha || source.ref || "HEAD";
+      const tmpDir = fs.mkdtempSync(path.join(this.cacheRoot, TMP_PREFIX));
+      try {
+        await execFileAsync("git", ["init"], { cwd: tmpDir, timeout: 1e4 });
+        await execFileAsync("git", ["remote", "add", "origin", remote], { cwd: tmpDir, timeout: 1e4 });
+        await execFileAsync("git", ["fetch", "--depth", "1", "origin", target], {
+          cwd: tmpDir,
+          timeout: 60000
+        });
+        await execFileAsync("git", ["checkout", "--detach", "FETCH_HEAD"], { cwd: tmpDir, timeout: 1e4 });
+        const { stdout } = await execFileAsync("git", ["rev-parse", "HEAD"], {
+          cwd: tmpDir,
+          timeout: 1e4
+        });
+        const actualSha = stdout.trim();
+        fs.rmSync(path.join(tmpDir, ".git"), { recursive: true, force: true });
+        const finalDest = this.shaDir(srcDir, actualSha);
+        if (fs.existsSync(finalDest)) {
+          fs.rmSync(tmpDir, { recursive: true, force: true });
+          this.updateRef(srcDir, actualSha);
+          return { source: source.original, name: pluginName, sha: actualSha, root: finalDest };
+        }
+        if (source.type === "git-subdir") {
+          if (!source.path)
+            throw new Error("git-subdir source is missing a path");
+          const subdir = path.resolve(tmpDir, source.path);
+          if (!subdir.startsWith(path.resolve(tmpDir) + path.sep) || !fs.existsSync(subdir)) {
+            throw new Error(`Plugin subdirectory not found: ${source.path}`);
+          }
+          try {
+            fs.renameSync(subdir, finalDest);
+          } catch (error) {
+            if (!fs.existsSync(finalDest))
+              throw error;
+          }
+          fs.rmSync(tmpDir, { recursive: true, force: true });
+        } else {
+          try {
+            fs.renameSync(tmpDir, finalDest);
+          } catch (error) {
+            if (!fs.existsSync(finalDest))
+              throw error;
+            return { source: source.original, name: pluginName, sha: actualSha, root: finalDest };
+          }
+        }
+        this.updateRef(srcDir, actualSha);
+        return { source: source.original, name: pluginName, sha: actualSha, root: finalDest };
+      } catch (e) {
+        if (fs.existsSync(tmpDir))
+          fs.rmSync(tmpDir, { recursive: true, force: true });
+        throw e;
+      }
+    }
+    if (source.type === "local") {
+      const resolved = path.resolve(source.original);
+      if (!fs.existsSync(resolved)) {
+        throw new Error(`Local path not found: ${resolved}`);
+      }
+      copyDirSync(resolved, destDir);
+      this.updateRef(srcDir, sha);
+      return { source: source.original, name: pluginName, sha, root: destDir };
+    }
+    if (source.type === "npm") {
+      const pkg = source.original.replace(/^npm:/, "");
+      const spec = source.ref ? `${pkg}@${source.ref}` : pkg;
+      const tmpDir = fs.mkdtempSync(path.join(this.cacheRoot, TMP_PREFIX));
+      try {
+        const { stdout } = await execFileAsync("npm", ["pack", spec, "--ignore-scripts", "--json", "--pack-destination", tmpDir], { timeout: 120000 });
+        const packed = JSON.parse(stdout);
+        const filename = packed[0]?.filename;
+        if (!filename)
+          throw new Error(`npm did not produce an archive for ${spec}`);
+        const archive = path.join(tmpDir, filename);
+        const actualSha = `npm-${packed[0]?.version ?? source.ref ?? "latest"}-${crypto.createHash("sha256").update(fs.readFileSync(archive)).digest("hex")}`;
+        const finalDest = this.shaDir(srcDir, actualSha);
+        if (!fs.existsSync(finalDest)) {
+          ensureDir(finalDest);
+          await execFileAsync("tar", ["-xzf", archive, "--strip-components=1", "-C", finalDest], { timeout: 30000 });
+        }
+        this.updateRef(srcDir, actualSha);
+        return { source: source.original, name: pluginName, sha: actualSha, root: finalDest };
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    }
+    throw new Error(`Cannot fetch source type: ${source.type}`);
+  }
+  updateRef(srcDir, sha) {
+    const refs = {};
+    if (fs.existsSync(this.refPath(srcDir))) {
+      try {
+        const existing = JSON.parse(fs.readFileSync(this.refPath(srcDir), "utf8"));
+        Object.assign(refs, existing);
+      } catch {}
+    }
+    refs.latest = sha;
+    fs.writeFileSync(this.refPath(srcDir), JSON.stringify(refs, null, 2));
+  }
+  listCached() {
+    const results = [];
+    try {
+      const sourceDirs = fs.readdirSync(this.cacheRoot);
+      for (const dir of sourceDirs) {
+        const srcDir = path.join(this.cacheRoot, dir);
+        if (!fs.statSync(srcDir).isDirectory())
+          continue;
+        const entries = fs.readdirSync(srcDir);
+        for (const entry of entries) {
+          if (entry === "ref.json")
+            continue;
+          const shaDir = path.join(srcDir, entry);
+          if (!fs.statSync(shaDir).isDirectory())
+            continue;
+          const refs = {};
+          if (fs.existsSync(this.refPath(srcDir))) {
+            try {
+              Object.assign(refs, JSON.parse(fs.readFileSync(this.refPath(srcDir), "utf8")));
+            } catch {}
+          }
+          results.push({
+            source: dir,
+            name: entry,
+            sha: entry,
+            root: shaDir
+          });
+        }
+      }
+    } catch {}
+    return results;
+  }
+  remove(source, sha) {
+    const srcDir = this.sourceDir(source);
+    const target = this.shaDir(srcDir, sha);
+    if (fs.existsSync(target)) {
+      fs.rmSync(target, { recursive: true, force: true });
+    }
+  }
+  removeAll(source) {
+    const srcDir = this.sourceDir(source);
+    if (fs.existsSync(srcDir)) {
+      fs.rmSync(srcDir, { recursive: true, force: true });
+    }
+  }
+}
+function computeTreeHash(dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  const hash = crypto.createHash("sha256");
+  for (const entry of entries) {
+    if (entry.name.startsWith(".git"))
+      continue;
+    if (entry.name === ".DS_Store")
+      continue;
+    if (entry.isDirectory()) {
+      hash.update(entry.name);
+      hash.update(computeTreeHash(path.join(dir, entry.name)));
+    } else if (entry.isFile()) {
+      hash.update(entry.name);
+      hash.update(fs.readFileSync(path.join(dir, entry.name)));
+    }
+  }
+  return hash.digest("hex");
+}
+function copyDirSync(src, dest) {
+  ensureDir(dest);
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith(".git"))
+      continue;
+    if (entry.name === ".DS_Store")
+      continue;
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// src/core/skills.ts
+var skillStateSchema = exports_external.record(exports_external.string(), exports_external.object({ source: exports_external.string(), skillName: exports_external.string().optional(), pinned: exports_external.boolean().default(false), previousPath: exports_external.string().optional() }));
+function readSkillState() {
+  const statePath = getSkillStatePath();
+  if (!fs2.existsSync(statePath))
+    return {};
+  try {
+    return skillStateSchema.parse(JSON.parse(fs2.readFileSync(statePath, "utf8")));
+  } catch {
+    return {};
+  }
+}
+function writeSkillState(state) {
+  ensureDir(path2.dirname(getSkillStatePath()));
+  fs2.writeFileSync(getSkillStatePath(), JSON.stringify(state, null, 2) + `
+`, "utf8");
+}
+function validateSkillPackage(root) {
+  const skillPath = path2.join(root, "SKILL.md");
+  if (!fs2.existsSync(skillPath))
+    throw new Error(`Agent Skill is missing SKILL.md: ${root}`);
+  const content = fs2.readFileSync(skillPath, "utf8");
+  const match = content.match(/^---\s*[\s\S]*?^name:\s*([^\r\n]+)[\s\S]*?^description:\s*([^\r\n]+)[\s\S]*?^---/m);
+  if (!match || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(match[1].trim()) || !match[2].trim()) {
+    throw new Error(`Invalid Agent Skill frontmatter in ${skillPath}; name and description are required`);
+  }
+}
+function installedSkills() {
+  const root = getSkillPackagesRoot();
+  if (!fs2.existsSync(root))
+    return [];
+  return fs2.readdirSync(root, { withFileTypes: true }).flatMap((entry) => {
+    if (!entry.isDirectory())
+      return [];
+    const packageRoot = path2.join(root, entry.name);
+    const skillFile = path2.join(packageRoot, "SKILL.md");
+    if (!fs2.existsSync(skillFile))
+      return [];
+    return [{ id: entry.name, content: fs2.readFileSync(skillFile, "utf8"), root: packageRoot, source: "installed", readOnly: true }];
+  });
+}
+function listSkills() {
+  const skillsDir = getSkillsDir();
+  const skills = [];
+  const files = fs2.existsSync(skillsDir) ? fs2.readdirSync(skillsDir, { withFileTypes: true }) : [];
+  const authoredDirectories = new Set(files.filter((file) => file.isDirectory()).map((file) => file.name));
+  for (const file of files) {
+    const id = file.isDirectory() ? file.name : file.name.endsWith(".md") ? path2.basename(file.name, ".md") : null;
+    if (id && (file.isDirectory() || !authoredDirectories.has(id))) {
+      try {
+        const root = file.isDirectory() ? path2.join(skillsDir, id) : skillsDir;
+        const filePath = file.isDirectory() ? path2.join(root, "SKILL.md") : path2.join(skillsDir, file.name);
+        if (!fs2.existsSync(filePath))
+          continue;
+        const content = fs2.readFileSync(filePath, "utf-8");
+        skills.push({ id, content, root: file.isDirectory() ? root : undefined, source: "authored" });
+      } catch {
+        console.error(`[mcpx] Warning: could not read skill ${file.name}`);
+      }
+    }
+  }
+  const authoredIds = new Set(skills.map((skill) => skill.id));
+  const native = [];
+  for (const pkg of Object.values(loadConfig().packages ?? {}))
+    for (const skill of pkg.skills ?? []) {
+      const root = path2.resolve(pkg.root, skill.path);
+      if (!root.startsWith(path2.resolve(pkg.root) + path2.sep))
+        continue;
+      const file = path2.join(root, "SKILL.md");
+      if (fs2.existsSync(file))
+        native.push({ id: skill.id, root, content: fs2.readFileSync(file, "utf8"), projectionPath: skill.projectionPath, scope: pkg.scope, ownerHarness: pkg.harness, source: "installed", readOnly: true });
+    }
+  return [...skills, ...installedSkills().filter((skill) => !authoredIds.has(skill.id)), ...native];
+}
+function getSkill(id) {
+  validateSkillId(id);
+  const skillsDir = getSkillsDir();
+  const directory = path2.join(skillsDir, id);
+  const packagePath = path2.join(directory, "SKILL.md");
+  const legacyPath = path2.join(skillsDir, `${id}.md`);
+  const filePath = fs2.existsSync(packagePath) ? packagePath : legacyPath;
+  if (!fs2.existsSync(filePath)) {
+    const installedPath = path2.join(getSkillPackagesRoot(), id, "SKILL.md");
+    if (!fs2.existsSync(installedPath))
+      return listSkills().find((skill) => skill.id === id) ?? null;
+    const installedRoot = path2.dirname(installedPath);
+    return { id, content: fs2.readFileSync(installedPath, "utf8"), root: installedRoot, source: "installed", readOnly: true };
+  }
+  const content = fs2.readFileSync(filePath, "utf-8");
+  return { id, content, root: fs2.existsSync(packagePath) ? directory : undefined, source: "authored" };
+}
+function saveSkill(id, content) {
+  validateSkillId(id);
+  const skillsDir = getSkillsDir();
+  ensureDir(skillsDir);
+  const directory = path2.join(skillsDir, id);
+  const filePath = path2.join(directory, "SKILL.md");
+  ensureDir(directory);
+  fs2.writeFileSync(filePath, content, "utf-8");
+  const legacyPath = path2.join(skillsDir, `${id}.md`);
+  if (fs2.existsSync(legacyPath)) {
+    if (fs2.readFileSync(filePath, "utf-8") === fs2.readFileSync(legacyPath, "utf-8"))
+      fs2.unlinkSync(legacyPath);
+    else
+      console.error(`[mcpx] Warning: preserving conflicting legacy skill file: ${legacyPath}`);
+  }
+}
+function deleteSkill(id) {
+  validateSkillId(id);
+  const skillsDir = getSkillsDir();
+  const directory = path2.join(skillsDir, id);
+  const filePath = path2.join(directory, "SKILL.md");
+  const legacyPath = path2.join(skillsDir, `${id}.md`);
+  const hadAuthored = fs2.existsSync(directory) || fs2.existsSync(legacyPath);
+  if (fs2.existsSync(directory))
+    fs2.rmSync(directory, { recursive: true, force: true });
+  if (fs2.existsSync(legacyPath))
+    fs2.unlinkSync(legacyPath);
+  if (!hadAuthored) {
+    const installedPath = path2.join(getSkillPackagesRoot(), id);
+    if (fs2.existsSync(installedPath))
+      fs2.rmSync(installedPath, { recursive: true, force: true });
+    const state = readSkillState();
+    delete state[id];
+    writeSkillState(state);
+  }
+}
+function customizeSkill(id, targetId = id) {
+  validateSkillId(id);
+  validateSkillId(targetId);
+  const existing = getSkill(id);
+  if (!existing)
+    throw new Error(`Skill "${id}" not found`);
+  saveSkill(targetId, existing.content);
+  return getSkill(targetId);
+}
+async function installSkillFromSource(source, skillName) {
+  const parsed = parseSource(source);
+  const cache = new PluginCache;
+  const cached = await cache.fetch(parsed, skillName ?? "skill");
+  const candidates = [];
+  const declaredName = (root) => {
+    try {
+      const content = fs2.readFileSync(path2.join(root, "SKILL.md"), "utf8");
+      const frontmatter = content.match(/^---\s*[\s\S]*?^name:\s*([^\r\n]+)[\s\S]*?^---/m)?.[1]?.trim();
+      return frontmatter && /^[a-z0-9][a-z0-9-]*$/.test(frontmatter) ? frontmatter : undefined;
+    } catch {
+      return;
+    }
+  };
+  const addCandidate = (root, id = path2.basename(root)) => {
+    if (fs2.existsSync(path2.join(root, "SKILL.md"))) {
+      validateSkillPackage(root);
+      candidates.push({ id: declaredName(root) ?? id, root });
+    }
+  };
+  addCandidate(cached.root);
+  const skillsRoot = path2.join(cached.root, "skills");
+  if (fs2.existsSync(skillsRoot)) {
+    for (const entry of fs2.readdirSync(skillsRoot, { withFileTypes: true })) {
+      if (entry.isDirectory())
+        addCandidate(path2.join(skillsRoot, entry.name), entry.name);
+    }
+  }
+  if (candidates.length === 0)
+    throw new Error(`No Agent Skill package found in ${source}`);
+  const selected = skillName ? candidates.find((candidate) => candidate.id === skillName) : candidates[0];
+  if (!selected)
+    throw new Error(`Skill "${skillName}" was not found in ${source}`);
+  validateSkillId(selected.id);
+  const destination = path2.join(getSkillPackagesRoot(), selected.id);
+  ensureDir(path2.dirname(destination));
+  const state = readSkillState();
+  const stateSource = parsed.type === "local" ? path2.resolve(source) : source;
+  if (fs2.existsSync(destination)) {
+    if (state[selected.id]?.pinned)
+      throw new Error(`Skill "${selected.id}" is pinned; unpin it before updating`);
+    const previousPath = `${destination}.previous`;
+    if (fs2.existsSync(previousPath))
+      fs2.rmSync(previousPath, { recursive: true, force: true });
+    fs2.renameSync(destination, previousPath);
+    state[selected.id] = { ...state[selected.id], source: stateSource, skillName: selected.id, pinned: false, previousPath };
+  } else {
+    state[selected.id] = { source: stateSource, skillName: selected.id, pinned: false };
+  }
+  fs2.cpSync(selected.root, destination, { recursive: true, dereference: true });
+  writeSkillState(state);
+  return { id: selected.id, content: fs2.readFileSync(path2.join(destination, "SKILL.md"), "utf8"), root: destination, source: "installed", readOnly: true };
+}
+function pinSkill(id) {
+  const state = readSkillState();
+  if (!state[id])
+    throw new Error(`Skill "${id}" is not installed`);
+  state[id].pinned = true;
+  writeSkillState(state);
+}
+function unpinSkill(id) {
+  const state = readSkillState();
+  if (!state[id])
+    throw new Error(`Skill "${id}" is not installed`);
+  state[id].pinned = false;
+  writeSkillState(state);
+}
+async function updateSkill(id) {
+  const state = readSkillState();
+  const entry = state[id];
+  if (!entry)
+    throw new Error(`Skill "${id}" is not installed`);
+  if (entry.pinned)
+    throw new Error(`Skill "${id}" is pinned; unpin it before updating`);
+  return installSkillFromSource(entry.source, entry.skillName ?? id);
+}
+function rollbackSkill(id) {
+  const state = readSkillState();
+  const entry = state[id];
+  if (!entry?.previousPath || !fs2.existsSync(entry.previousPath))
+    throw new Error(`Skill "${id}" has no previous revision`);
+  const destination = path2.join(getSkillPackagesRoot(), id);
+  const failedPath = `${destination}.failed`;
+  if (fs2.existsSync(failedPath))
+    fs2.rmSync(failedPath, { recursive: true, force: true });
+  fs2.renameSync(destination, failedPath);
+  fs2.renameSync(entry.previousPath, destination);
+  entry.previousPath = failedPath;
+  writeSkillState(state);
+  return { id, content: fs2.readFileSync(path2.join(destination, "SKILL.md"), "utf8"), root: destination, source: "installed", readOnly: true };
+}
+
+export { validateSkillId, normalizePluginName, parseSource, PluginCache, validateSkillPackage, listSkills, getSkill, saveSkill, deleteSkill, customizeSkill, installSkillFromSource, pinSkill, unpinSkill, updateSkill, rollbackSkill };
+
+//# debugId=43A9FAB87FA4420064756E2164756E21