@kwonye/mcpx 0.1.99 → 0.1.101

package/dist/{cli-b0xrqsjc.js → cli-9k3wmag6.js}

@@ -3,11 +3,11 @@ import {
   loadProjectConfig,
   saveConfig,
   saveProjectConfig
-} from "./cli-dy7x0zrg.js";
+} from "./cli-6zq2fd6h.js";
 import {
   SecretsManager,
   ensureGatewayToken
-} from "./cli-1ewrsfj4.js";
+} from "./cli-hh7rthhx.js";
 import {
   ensureDir,
   findProjectConfigPath,
@@ -20,7 +20,7 @@ import {
   readJsonFile,
   sha256,
   writeJsonAtomic
-} from "./cli-28g7x9rn.js";
+} from "./cli-6wh8qx2y.js";
 import {
   __require,
   isServerEnabled
@@ -33,8 +33,10 @@ import path21 from "node:path";
 // src/core/plugin-cache.ts
 import fs from "node:fs";
 import path from "node:path";
-import { execFileSync } from "node:child_process";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 var TMP_PREFIX = "mcpx-acquire-";
+var execFileAsync = promisify(execFile);
 
 class PluginCache {
   cacheRoot;
@@ -55,24 +57,18 @@ class PluginCache {
   async resolveSha(source) {
     const srcDir = this.sourceDir(source);
     if (source.type === "github") {
-      const repo = source.original.split("@")[0];
+      const repo = source.original.replace(/^github\.com\//, "").split("@")[0];
       const ref = source.ref || "HEAD";
-      const output = execFileSync("git", ["ls-remote", `https://github.com/${repo}.git`, ref], {
-        encoding: "utf8",
-        timeout: 30000
-      });
-      const sha = output.split("\t")[0]?.trim();
+      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 output = execFileSync("git", ["ls-remote", source.original, ref], {
-        encoding: "utf8",
-        timeout: 30000
-      });
-      const sha = output.split("\t")[0]?.trim();
+      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;
@@ -99,23 +95,22 @@ class PluginCache {
     }
     ensureDir(srcDir);
     if (source.type === "github" || source.type === "git" || source.type === "git-subdir") {
-      const remote = source.type === "github" ? `https://github.com/${source.original.split("@")[0]}.git` : source.original;
+      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 {
-        execFileSync("git", ["init"], { cwd: tmpDir, stdio: "pipe", timeout: 1e4 });
-        execFileSync("git", ["remote", "add", "origin", remote], { cwd: tmpDir, stdio: "pipe", timeout: 1e4 });
-        execFileSync("git", ["fetch", "--depth", "1", "origin", target], {
+        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,
-          stdio: "pipe",
           timeout: 60000
         });
-        execFileSync("git", ["checkout", "--detach", "FETCH_HEAD"], { cwd: tmpDir, stdio: "pipe", timeout: 1e4 });
-        const actualSha = execFileSync("git", ["rev-parse", "HEAD"], {
+        await execFileAsync("git", ["checkout", "--detach", "FETCH_HEAD"], { cwd: tmpDir, timeout: 1e4 });
+        const { stdout } = await execFileAsync("git", ["rev-parse", "HEAD"], {
           cwd: tmpDir,
-          encoding: "utf8",
           timeout: 1e4
-        }).trim();
+        });
+        const actualSha = stdout.trim();
         fs.rmSync(path.join(tmpDir, ".git"), { recursive: true, force: true });
         const finalDest = this.shaDir(srcDir, actualSha);
         if (fs.existsSync(finalDest)) {
@@ -130,10 +125,21 @@ class PluginCache {
           if (!subdir.startsWith(path.resolve(tmpDir) + path.sep) || !fs.existsSync(subdir)) {
             throw new Error(`Plugin subdirectory not found: ${source.path}`);
           }
-          fs.renameSync(subdir, finalDest);
+          try {
+            fs.renameSync(subdir, finalDest);
+          } catch (error) {
+            if (!fs.existsSync(finalDest))
+              throw error;
+          }
           fs.rmSync(tmpDir, { recursive: true, force: true });
         } else {
-          fs.renameSync(tmpDir, finalDest);
+          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 };
@@ -357,7 +363,10 @@ class PluginDataManager {
 // src/core/plugin-lifecycle.ts
 import fs3 from "node:fs";
 import path3 from "node:path";
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile2);
+
 class PluginLifecycle {
   dataManager;
   constructor() {
@@ -373,9 +382,8 @@ class PluginLifecycle {
         const pkg = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf8"));
         const deps = { ...pkg.dependencies, ...pkg.devDependencies };
         if (Object.keys(deps).length > 0) {
-          execFileSync2("npm", ["install", "--production"], {
+          await execFileAsync2("npm", ["install", "--production", "--ignore-scripts"], {
             cwd: pluginRoot,
-            stdio: "pipe",
             timeout: 120000
           });
         }
@@ -384,8 +392,7 @@ class PluginLifecycle {
     const reqPath = path3.join(pluginRoot, "requirements.txt");
     if (fs3.existsSync(reqPath)) {
       try {
-        execFileSync2("pip", ["install", "-r", reqPath], {
-          stdio: "pipe",
+        await execFileAsync2("pip", ["install", "-r", reqPath], {
           timeout: 120000
         });
       } catch {}
@@ -450,10 +457,7 @@ function parseSource(source) {
       original: source
     };
   }
-  return {
-    type: "git",
-    original: source
-  };
+  throw new Error(`Unrecognized plugin source: ${source}`);
 }
 
 // src/core/plugin-parse.ts
@@ -462,7 +466,8 @@ import path4 from "node:path";
 import { z } from "zod";
 var CLAUDE_PLUGIN_JSON_REL = path4.join(".claude-plugin", "plugin.json");
 var CODEX_PLUGIN_JSON_REL = path4.join(".codex-plugin", "plugin.json");
-var MCP_JSON_REL = ".mcp.json";
+var AGENT_PLUGIN_JSON_REL = "plugin.json";
+var MCP_JSON_RELS = ["mcp.json", ".mcp.json"];
 var HOOKS_JSON_REL = path4.join("hooks", "hooks.json");
 var SKILLS_DIR = "skills";
 var COMMANDS_DIR = "commands";
@@ -498,7 +503,7 @@ var manifestSchema = z.object({
   }).passthrough().optional()
 }).passthrough();
 function manifestPath(pluginRoot) {
-  for (const rel of [CLAUDE_PLUGIN_JSON_REL, CODEX_PLUGIN_JSON_REL]) {
+  for (const rel of [AGENT_PLUGIN_JSON_REL, CLAUDE_PLUGIN_JSON_REL, CODEX_PLUGIN_JSON_REL]) {
     const candidate = path4.join(pluginRoot, rel);
     if (fs4.existsSync(candidate))
       return candidate;
@@ -687,7 +692,7 @@ function discoverHooks(pluginRoot, raw) {
 }
 function discoverMcpServers(pluginRoot, raw) {
   const declared = typeof raw?.mcpServers === "string" ? raw.mcpServers : undefined;
-  const mcpPath = declared ? resolveWithinRoot(pluginRoot, declared) : path4.join(pluginRoot, MCP_JSON_REL);
+  const mcpPath = declared ? resolveWithinRoot(pluginRoot, declared) : MCP_JSON_RELS.map((rel) => path4.join(pluginRoot, rel)).find(fs4.existsSync) ?? null;
   if (!mcpPath || !fs4.existsSync(mcpPath))
     return [];
   try {
@@ -724,7 +729,7 @@ function hasManifest(pluginRoot) {
   return manifestPath(pluginRoot) !== null;
 }
 function resolvePluginVars(value, pluginRoot, dataDir) {
-  return value.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginRoot).replace(/\$\{DATA\}/g, dataDir).replace(/\$\{CLAUDE_PROJECT_DIR\}/g, pluginRoot);
+  return value.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginRoot).replace(/\$\{CLAUDE_PLUGIN_DATA\}/g, dataDir).replace(/\$\{MCPX_PLUGIN_ROOT\}/g, pluginRoot).replace(/\$\{MCPX_PLUGIN_DATA\}/g, dataDir).replace(/\$\{DATA\}/g, dataDir).replace(/\$\{CLAUDE_PROJECT_DIR\}/g, pluginRoot);
 }
 
 // src/core/config-store.ts
@@ -997,7 +1002,7 @@ function detectManagedEntryDrift(managedIndex, clientId, entryName, existingValu
 // src/adapters/claude.ts
 import fs8 from "node:fs";
 import path8 from "node:path";
-import { z as z2 } from "zod";
+import { z as z4 } from "zod";
 
 // src/core/plugin-projections.ts
 import fs6 from "node:fs";
@@ -1021,6 +1026,17 @@ function saveOwnership(targetDir, manifest) {
 }
 function recordOwned(targetDir, pluginId, paths) {
   const manifest = loadOwnership(targetDir);
+  const previous = manifest.plugins[pluginId]?.paths ?? [];
+  const next = new Set(paths);
+  for (const stale of previous) {
+    if (next.has(stale))
+      continue;
+    const stalePath = path6.join(targetDir, stale);
+    try {
+      assertWithinBase(targetDir, stalePath);
+      fs6.rmSync(stalePath, { recursive: true, force: true });
+    } catch {}
+  }
   manifest.plugins[pluginId] = {
     pluginId,
     paths,
@@ -1043,6 +1059,7 @@ function prunePluginProjections(targetDir, pluginId) {
   for (const p of paths) {
     const fullPath = path6.join(targetDir, p);
     try {
+      assertWithinBase(targetDir, fullPath);
       if (fs6.existsSync(fullPath)) {
         fs6.rmSync(fullPath, { recursive: true, force: true });
       }
@@ -1099,6 +1116,7 @@ function syncClaude(plugins) {
       continue;
     }
     const targetDir = path6.join(targetBase, plugin.pluginName);
+    assertWithinBase(targetBase, targetDir);
     ensureDir(targetDir);
     const mcpJsonSrc = path6.join(plugin.pluginRoot, ".mcp.json");
     const mcpJsonDest = path6.join(targetDir, ".mcp.json");
@@ -1125,226 +1143,70 @@ function syncClaudeDesktop(plugins) {
     unsupported
   };
 }
-function syncCodex(plugins) {
-  const targetBase = path6.join(homeDir(), ".codex", "skills");
+function syncNamespacedComponents(config, plugins) {
   const projectedDirs = [];
-  const unsupported = ["hooks", "agents"];
   const errors = [];
-  for (const plugin of plugins) {
-    if (!plugin.enabled)
-      continue;
-    if (plugin.components.skills && isComponentApproved(plugin, "skills")) {
-      ensureDir(targetBase);
-      const owned = [];
-      for (const skill of plugin.skills) {
-        try {
-          const targetDir = path6.join(targetBase, nsName(plugin.pluginName, skill.id));
-          assertWithinBase(targetBase, targetDir);
-          ensureDir(targetDir);
-          copyFileOrDir(skill.path, path6.join(targetDir, "SKILL.md"));
-          owned.push(nsName(plugin.pluginName, skill.id));
-          projectedDirs.push(targetDir);
-        } catch (error) {
-          errors.push(`${plugin.pluginName}/${skill.id}: ${error.message}`);
-        }
-      }
-      recordOwned(targetBase, plugin.pluginId, owned);
-    }
-  }
-  return {
-    clientId: "codex",
-    status: "SYNCED",
-    projectedDirs,
-    unsupported,
-    ...errors.length > 0 ? { error: errors.join("; ") } : {}
-  };
-}
-function syncCursor(plugins) {
-  const skillsBase = path6.join(homeDir(), ".cursor", "skills");
-  const commandsBase = path6.join(homeDir(), ".cursor", "commands");
-  const projectedDirs = [];
-  const unsupported = ["hooks", "agents"];
-  const errors = [];
-  for (const plugin of plugins) {
-    if (!plugin.enabled)
-      continue;
-    const ownedSkills = [];
-    const ownedCommands = [];
-    if (plugin.components.skills && isComponentApproved(plugin, "skills")) {
-      ensureDir(skillsBase);
-      for (const skill of plugin.skills) {
-        try {
-          const targetDir = path6.join(skillsBase, nsName(plugin.pluginName, skill.id));
-          assertWithinBase(skillsBase, targetDir);
-          ensureDir(targetDir);
-          copyFileOrDir(skill.path, path6.join(targetDir, "SKILL.md"));
-          ownedSkills.push(nsName(plugin.pluginName, skill.id));
-          projectedDirs.push(targetDir);
-        } catch (error) {
-          errors.push(`${plugin.pluginName}/${skill.id}: ${error.message}`);
-        }
-      }
-    }
-    if (plugin.components.commands && isComponentApproved(plugin, "commands")) {
-      ensureDir(commandsBase);
-      for (const cmd of plugin.commands) {
-        try {
-          const targetPath = path6.join(commandsBase, `${nsName(plugin.pluginName, cmd.id)}.md`);
-          assertWithinBase(commandsBase, targetPath);
-          copyFileOrDir(cmd.path, targetPath);
-          ownedCommands.push(`${nsName(plugin.pluginName, cmd.id)}.md`);
-          projectedDirs.push(targetPath);
-        } catch (error) {
-          errors.push(`${plugin.pluginName}/${cmd.id}: ${error.message}`);
-        }
+  const syncSkills = (plugin) => {
+    if (!config.skillsBase)
+      return;
+    if (!plugin.components.skills || !isComponentApproved(plugin, "skills")) {
+      if (fs6.existsSync(config.skillsBase)) {
+        recordOwned(config.skillsBase, plugin.pluginId, []);
       }
+      return;
     }
-    if (ownedSkills.length > 0)
-      recordOwned(skillsBase, plugin.pluginId, ownedSkills);
-    if (ownedCommands.length > 0)
-      recordOwned(commandsBase, plugin.pluginId, ownedCommands);
-  }
-  return {
-    clientId: "cursor",
-    status: "SYNCED",
-    projectedDirs,
-    unsupported,
-    ...errors.length > 0 ? { error: errors.join("; ") } : {}
-  };
-}
-function syncVsCode(plugins) {
-  const skillsBase = path6.join(homeDir(), ".copilot", "skills");
-  const projectedDirs = [];
-  const unsupported = ["hooks", "agents"];
-  const errors = [];
-  for (const plugin of plugins) {
-    if (!plugin.enabled)
-      continue;
-    if (plugin.components.skills && isComponentApproved(plugin, "skills")) {
-      ensureDir(skillsBase);
-      const owned = [];
-      for (const skill of plugin.skills) {
-        try {
-          const targetDir = path6.join(skillsBase, nsName(plugin.pluginName, skill.id));
-          assertWithinBase(skillsBase, targetDir);
-          ensureDir(targetDir);
-          copyFileOrDir(skill.path, path6.join(targetDir, "SKILL.md"));
-          owned.push(nsName(plugin.pluginName, skill.id));
-          projectedDirs.push(targetDir);
-        } catch (error) {
-          errors.push(`${plugin.pluginName}/${skill.id}: ${error.message}`);
-        }
+    ensureDir(config.skillsBase);
+    const owned = [];
+    for (const skill of plugin.skills) {
+      try {
+        const name = nsName(plugin.pluginName, skill.id);
+        const targetDir = path6.join(config.skillsBase, name);
+        assertWithinBase(config.skillsBase, targetDir);
+        ensureDir(targetDir);
+        copyFileOrDir(skill.path, path6.join(targetDir, "SKILL.md"));
+        owned.push(name);
+        projectedDirs.push(targetDir);
+      } catch (error) {
+        errors.push(`${plugin.pluginName}/${skill.id}: ${error.message}`);
       }
-      recordOwned(skillsBase, plugin.pluginId, owned);
     }
-  }
-  return {
-    clientId: "vscode",
-    status: "SYNCED",
-    projectedDirs,
-    unsupported,
-    ...errors.length > 0 ? { error: errors.join("; ") } : {}
+    recordOwned(config.skillsBase, plugin.pluginId, owned);
   };
-}
-function syncQwen(plugins) {
-  const targetBase = path6.join(homeDir(), ".qwen", "skills");
-  const projectedDirs = [];
-  const unsupported = ["hooks", "agents", "commands"];
-  const errors = [];
-  for (const plugin of plugins) {
-    if (!plugin.enabled)
-      continue;
-    if (plugin.components.skills && isComponentApproved(plugin, "skills")) {
-      ensureDir(targetBase);
-      const owned = [];
-      for (const skill of plugin.skills) {
-        try {
-          const targetDir = path6.join(targetBase, nsName(plugin.pluginName, skill.id));
-          assertWithinBase(targetBase, targetDir);
-          ensureDir(targetDir);
-          copyFileOrDir(skill.path, path6.join(targetDir, "SKILL.md"));
-          owned.push(nsName(plugin.pluginName, skill.id));
-          projectedDirs.push(targetDir);
-        } catch (error) {
-          errors.push(`${plugin.pluginName}/${skill.id}: ${error.message}`);
-        }
+  const syncCommands = (plugin) => {
+    if (!config.commandsBase)
+      return;
+    if (!plugin.components.commands || !isComponentApproved(plugin, "commands")) {
+      if (fs6.existsSync(config.commandsBase)) {
+        recordOwned(config.commandsBase, plugin.pluginId, []);
       }
-      recordOwned(targetBase, plugin.pluginId, owned);
+      return;
     }
-  }
-  return {
-    clientId: "qwen",
-    status: "SYNCED",
-    projectedDirs,
-    unsupported,
-    ...errors.length > 0 ? { error: errors.join("; ") } : {}
-  };
-}
-function syncCline(plugins) {
-  const targetBase = path6.join(homeDir(), ".config", "cline", "skills");
-  const projectedDirs = [];
-  const unsupported = ["hooks", "agents", "commands"];
-  const errors = [];
-  for (const plugin of plugins) {
-    if (!plugin.enabled)
-      continue;
-    if (plugin.components.skills && isComponentApproved(plugin, "skills")) {
-      ensureDir(targetBase);
-      const owned = [];
-      for (const skill of plugin.skills) {
-        try {
-          const targetDir = path6.join(targetBase, nsName(plugin.pluginName, skill.id));
-          assertWithinBase(targetBase, targetDir);
-          ensureDir(targetDir);
-          copyFileOrDir(skill.path, path6.join(targetDir, "SKILL.md"));
-          owned.push(nsName(plugin.pluginName, skill.id));
-          projectedDirs.push(targetDir);
-        } catch (error) {
-          errors.push(`${plugin.pluginName}/${skill.id}: ${error.message}`);
-        }
+    ensureDir(config.commandsBase);
+    const owned = [];
+    for (const command of plugin.commands) {
+      try {
+        const targetPath = path6.join(config.commandsBase, `${nsName(plugin.pluginName, command.id)}.md`);
+        assertWithinBase(config.commandsBase, targetPath);
+        copyFileOrDir(command.path, targetPath);
+        owned.push(path6.basename(targetPath));
+        projectedDirs.push(targetPath);
+      } catch (error) {
+        errors.push(`${plugin.pluginName}/${command.id}: ${error.message}`);
       }
-      recordOwned(targetBase, plugin.pluginId, owned);
     }
-  }
-  return {
-    clientId: "cline",
-    status: "SYNCED",
-    projectedDirs,
-    unsupported,
-    ...errors.length > 0 ? { error: errors.join("; ") } : {}
+    recordOwned(config.commandsBase, plugin.pluginId, owned);
   };
-}
-function syncKiro(plugins) {
-  const targetBase = path6.join(homeDir(), ".kiro", "skills");
-  const projectedDirs = [];
-  const unsupported = ["hooks", "agents", "commands"];
-  const errors = [];
   for (const plugin of plugins) {
     if (!plugin.enabled)
       continue;
-    if (plugin.components.skills && isComponentApproved(plugin, "skills")) {
-      ensureDir(targetBase);
-      const owned = [];
-      for (const skill of plugin.skills) {
-        try {
-          const targetDir = path6.join(targetBase, nsName(plugin.pluginName, skill.id));
-          assertWithinBase(targetBase, targetDir);
-          ensureDir(targetDir);
-          copyFileOrDir(skill.path, path6.join(targetDir, "SKILL.md"));
-          owned.push(nsName(plugin.pluginName, skill.id));
-          projectedDirs.push(targetDir);
-        } catch (error) {
-          errors.push(`${plugin.pluginName}/${skill.id}: ${error.message}`);
-        }
-      }
-      recordOwned(targetBase, plugin.pluginId, owned);
-    }
+    syncSkills(plugin);
+    syncCommands(plugin);
   }
   return {
-    clientId: "kiro",
+    clientId: config.clientId,
     status: "SYNCED",
     projectedDirs,
-    unsupported,
+    unsupported: config.unsupported,
     ...errors.length > 0 ? { error: errors.join("; ") } : {}
   };
 }
@@ -1361,12 +1223,12 @@ function syncPluginsToClient(clientId, plugins) {
   const syncMap = {
     claude: syncClaude,
     "claude-desktop": syncClaudeDesktop,
-    codex: syncCodex,
-    cursor: syncCursor,
-    vscode: syncVsCode,
-    qwen: syncQwen,
-    cline: syncCline,
-    kiro: syncKiro,
+    codex: (plugins2) => syncNamespacedComponents({ clientId: "codex", skillsBase: path6.join(homeDir(), ".codex", "skills"), unsupported: ["hooks", "agents"] }, plugins2),
+    cursor: (plugins2) => syncNamespacedComponents({ clientId: "cursor", skillsBase: path6.join(homeDir(), ".cursor", "skills"), commandsBase: path6.join(homeDir(), ".cursor", "commands"), unsupported: ["hooks", "agents"] }, plugins2),
+    vscode: (plugins2) => syncNamespacedComponents({ clientId: "vscode", skillsBase: path6.join(homeDir(), ".copilot", "skills"), unsupported: ["hooks", "agents"] }, plugins2),
+    qwen: (plugins2) => syncNamespacedComponents({ clientId: "qwen", skillsBase: path6.join(homeDir(), ".qwen", "skills"), unsupported: ["hooks", "agents", "commands"] }, plugins2),
+    cline: (plugins2) => syncNamespacedComponents({ clientId: "cline", skillsBase: path6.join(homeDir(), ".config", "cline", "skills"), unsupported: ["hooks", "agents", "commands"] }, plugins2),
+    kiro: (plugins2) => syncNamespacedComponents({ clientId: "kiro", skillsBase: path6.join(homeDir(), ".kiro", "skills"), unsupported: ["hooks", "agents", "commands"] }, plugins2),
     opencode: syncOpenCode
   };
   const syncFn = syncMap[clientId];
@@ -1377,7 +1239,7 @@ function syncPluginsToClient(clientId, plugins) {
     claude: path6.join(homeDir(), ".claude", "skills"),
     "claude-desktop": "",
     codex: path6.join(homeDir(), ".codex", "skills"),
-    cursor: path6.join(homeDir(), ".cursor"),
+    cursor: path6.join(homeDir(), ".cursor", "skills"),
     vscode: path6.join(homeDir(), ".copilot", "skills"),
     qwen: path6.join(homeDir(), ".qwen", "skills"),
     cline: path6.join(homeDir(), ".config", "cline", "skills"),
@@ -1388,6 +1250,9 @@ function syncPluginsToClient(clientId, plugins) {
   if (target) {
     const enabledIds = plugins.filter((p) => p.enabled).map((p) => p.pluginId);
     pruneUnlistedPlugins(target, enabledIds);
+    if (clientId === "cursor") {
+      pruneUnlistedPlugins(path6.join(homeDir(), ".cursor", "commands"), enabledIds);
+    }
   }
   return syncFn(plugins);
 }
@@ -1427,18 +1292,53 @@ function copyFileOrDir(src, dest, errors) {
 // src/core/skill-projections.ts
 import fs7 from "node:fs";
 import path7 from "node:path";
+import { z as z3 } from "zod";
+
+// src/core/identifiers.ts
+import { z as z2 } from "zod";
+var skillIdSchema = z2.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/skill-projections.ts
 var OWNERSHIP_MANIFEST2 = "mcpx-skills.json";
+var ownershipSchema = z3.object({
+  version: z3.literal(1),
+  paths: z3.array(z3.string())
+});
+function assertWithinBase2(base, target) {
+  const resolvedBase = path7.resolve(base);
+  const resolvedTarget = path7.resolve(target);
+  if (resolvedTarget !== resolvedBase && !resolvedTarget.startsWith(resolvedBase + path7.sep)) {
+    throw new Error(`Refusing to access path outside projection base: ${target}`);
+  }
+}
 function loadOwnership2(targetDir) {
   const manifestPath2 = path7.join(targetDir, OWNERSHIP_MANIFEST2);
   if (!fs7.existsSync(manifestPath2)) {
     return { version: 1, paths: [] };
   }
   try {
-    return JSON.parse(fs7.readFileSync(manifestPath2, "utf8"));
+    const parsed = ownershipSchema.safeParse(JSON.parse(fs7.readFileSync(manifestPath2, "utf8")));
+    if (parsed.success)
+      return parsed.data;
   } catch {
     console.error(`[mcpx] Warning: corrupt ownership manifest at ${manifestPath2}, resetting`);
     return { version: 1, paths: [] };
   }
+  return { version: 1, paths: [] };
 }
 function saveOwnership2(targetDir, manifest) {
   ensureDir(targetDir);
@@ -1451,11 +1351,13 @@ function projectSkillsToDir(targetDir, skills, layout) {
     if (!newPaths.has(ownedPath)) {
       const fullPath = path7.join(targetDir, ownedPath);
       try {
+        assertWithinBase2(targetDir, fullPath);
         if (fs7.existsSync(fullPath)) {
           fs7.rmSync(fullPath, { recursive: true, force: true });
         }
         if (layout === "dir") {
           const dirPath = path7.join(targetDir, path7.dirname(ownedPath));
+          assertWithinBase2(targetDir, dirPath);
           try {
             const remaining = fs7.readdirSync(dirPath);
             if (remaining.length === 0) {
@@ -1469,7 +1371,9 @@ function projectSkillsToDir(targetDir, skills, layout) {
     }
   }
   for (const skill of skills) {
+    validateSkillId(skill.id);
     const filePath = layout === "dir" ? path7.join(targetDir, skill.id, "SKILL.md") : path7.join(targetDir, `${skill.id}.md`);
+    assertWithinBase2(targetDir, filePath);
     ensureDir(path7.dirname(filePath));
     fs7.writeFileSync(filePath, skill.content, "utf-8");
   }
@@ -1493,16 +1397,16 @@ function syncProjectDisabledArray(project, managedNames, disabledForThisProject)
     delete project.disabledMcpServers;
   }
 }
-var stringMapSchema = z2.record(z2.string(), z2.string());
-var claudeEntrySchema = z2.object({
-  type: z2.string().optional(),
-  url: z2.string().min(1).optional(),
+var stringMapSchema = z4.record(z4.string(), z4.string());
+var claudeEntrySchema = z4.object({
+  type: z4.string().optional(),
+  url: z4.string().min(1).optional(),
   headers: stringMapSchema.optional(),
-  command: z2.string().min(1).optional(),
-  args: z2.array(z2.string()).optional(),
+  command: z4.string().min(1).optional(),
+  args: z4.array(z4.string()).optional(),
   env: stringMapSchema.optional(),
-  cwd: z2.string().min(1).optional(),
-  disabled: z2.boolean().optional()
+  cwd: z4.string().min(1).optional(),
+  disabled: z4.boolean().optional()
 }).passthrough();
 
 class ClaudeAdapter {
@@ -1643,29 +1547,29 @@ class ClaudeAdapter {
 }
 
 // src/adapters/claude-desktop.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import path9 from "node:path";
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 
 // src/version.ts
 var APP_VERSION = "0.1.3";
 
 // src/adapters/claude-desktop.ts
-var stringMapSchema2 = z3.record(z3.string(), z3.string());
-var claudeDesktopEntrySchema = z3.object({
-  type: z3.string().optional(),
-  url: z3.string().min(1).optional(),
+var stringMapSchema2 = z5.record(z5.string(), z5.string());
+var claudeDesktopEntrySchema = z5.object({
+  type: z5.string().optional(),
+  url: z5.string().min(1).optional(),
   headers: stringMapSchema2.optional(),
-  command: z3.string().min(1).optional(),
-  args: z3.array(z3.string()).optional(),
+  command: z5.string().min(1).optional(),
+  args: z5.array(z5.string()).optional(),
   env: stringMapSchema2.optional(),
-  cwd: z3.string().min(1).optional(),
-  disabled: z3.boolean().optional()
+  cwd: z5.string().min(1).optional(),
+  disabled: z5.boolean().optional()
 }).passthrough();
 function buildProxyEntry(entry) {
   const upstreamName = entry.name.replace(/ \(mcpx\)$/, "");
   try {
-    const mcpxPath = execFileSync3("which", ["mcpx"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const mcpxPath = execFileSync("which", ["mcpx"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
     if (mcpxPath)
       return { command: mcpxPath, args: ["proxy", upstreamName] };
   } catch {}
@@ -1793,22 +1697,22 @@ class ClaudeDesktopAdapter {
 import path10 from "node:path";
 import fs9 from "node:fs";
 import { parse, stringify } from "@iarna/toml";
-import { z as z4 } from "zod";
-var stringMapSchema3 = z4.preprocess((value) => {
+import { z as z6 } from "zod";
+var stringMapSchema3 = z6.preprocess((value) => {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return value;
   }
   return Object.fromEntries(Object.entries(value));
-}, z4.record(z4.string(), z4.string()));
-var codexEntrySchema = z4.object({
-  enabled: z4.boolean().optional(),
-  url: z4.string().min(1).optional(),
+}, z6.record(z6.string(), z6.string()));
+var codexEntrySchema = z6.object({
+  enabled: z6.boolean().optional(),
+  url: z6.string().min(1).optional(),
   headers: stringMapSchema3.optional(),
   http_headers: stringMapSchema3.optional(),
-  command: z4.string().min(1).optional(),
-  args: z4.array(z4.string()).optional(),
+  command: z6.string().min(1).optional(),
+  args: z6.array(z6.string()).optional(),
   env: stringMapSchema3.optional(),
-  cwd: z4.string().min(1).optional()
+  cwd: z6.string().min(1).optional()
 }).passthrough();
 
 class CodexAdapter {
@@ -1923,17 +1827,17 @@ class CodexAdapter {
 
 // src/adapters/cursor.ts
 import path11 from "node:path";
-import { z as z5 } from "zod";
-var stringMapSchema4 = z5.record(z5.string(), z5.string());
-var cursorEntrySchema = z5.object({
-  type: z5.string().optional(),
-  url: z5.string().min(1).optional(),
+import { z as z7 } from "zod";
+var stringMapSchema4 = z7.record(z7.string(), z7.string());
+var cursorEntrySchema = z7.object({
+  type: z7.string().optional(),
+  url: z7.string().min(1).optional(),
   headers: stringMapSchema4.optional(),
-  command: z5.string().min(1).optional(),
-  args: z5.array(z5.string()).optional(),
+  command: z7.string().min(1).optional(),
+  args: z7.array(z7.string()).optional(),
   env: stringMapSchema4.optional(),
-  cwd: z5.string().min(1).optional(),
-  disabled: z5.boolean().optional()
+  cwd: z7.string().min(1).optional(),
+  disabled: z7.boolean().optional()
 }).passthrough();
 
 class CursorAdapter {
@@ -2054,19 +1958,19 @@ class CursorAdapter {
 // src/adapters/cline.ts
 import path12 from "node:path";
 import fs10 from "node:fs";
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 var HTTP_TRANSPORT_TYPES = new Set(["http", "sse", "streamableHttp"]);
-var stringMapSchema5 = z6.record(z6.string(), z6.string());
-var clineEntrySchema = z6.object({
-  type: z6.string().optional(),
-  transportType: z6.string().optional(),
-  url: z6.string().min(1).optional(),
+var stringMapSchema5 = z8.record(z8.string(), z8.string());
+var clineEntrySchema = z8.object({
+  type: z8.string().optional(),
+  transportType: z8.string().optional(),
+  url: z8.string().min(1).optional(),
   headers: stringMapSchema5.optional(),
-  command: z6.string().min(1).optional(),
-  args: z6.array(z6.string()).optional(),
+  command: z8.string().min(1).optional(),
+  args: z8.array(z8.string()).optional(),
   env: stringMapSchema5.optional(),
-  cwd: z6.string().min(1).optional(),
-  disabled: z6.boolean().optional()
+  cwd: z8.string().min(1).optional(),
+  disabled: z8.boolean().optional()
 }).passthrough();
 function getCandidatePaths() {
   if (process.platform === "linux") {
@@ -2215,17 +2119,17 @@ class ClineAdapter {
 
 // src/adapters/kiro.ts
 import path13 from "node:path";
-import { z as z7 } from "zod";
-var stringMapSchema6 = z7.record(z7.string(), z7.string());
-var kiroEntrySchema = z7.object({
-  type: z7.string().optional(),
-  url: z7.string().min(1).optional(),
+import { z as z9 } from "zod";
+var stringMapSchema6 = z9.record(z9.string(), z9.string());
+var kiroEntrySchema = z9.object({
+  type: z9.string().optional(),
+  url: z9.string().min(1).optional(),
   headers: stringMapSchema6.optional(),
-  command: z7.string().min(1).optional(),
-  args: z7.array(z7.string()).optional(),
+  command: z9.string().min(1).optional(),
+  args: z9.array(z9.string()).optional(),
   env: stringMapSchema6.optional(),
-  cwd: z7.string().min(1).optional(),
-  disabled: z7.boolean().optional()
+  cwd: z9.string().min(1).optional(),
+  disabled: z9.boolean().optional()
 }).passthrough();
 
 class KiroAdapter {
@@ -2342,18 +2246,18 @@ class KiroAdapter {
 
 // src/adapters/opencode.ts
 import path14 from "node:path";
-import { z as z8 } from "zod";
-var stringMapSchema7 = z8.record(z8.string(), z8.string());
-var openCodeEntrySchema = z8.object({
-  type: z8.string().optional(),
-  url: z8.string().min(1).optional(),
+import { z as z10 } from "zod";
+var stringMapSchema7 = z10.record(z10.string(), z10.string());
+var openCodeEntrySchema = z10.object({
+  type: z10.string().optional(),
+  url: z10.string().min(1).optional(),
   headers: stringMapSchema7.optional(),
-  command: z8.union([z8.string().min(1), z8.array(z8.string())]).optional(),
-  args: z8.array(z8.string()).optional(),
+  command: z10.union([z10.string().min(1), z10.array(z10.string())]).optional(),
+  args: z10.array(z10.string()).optional(),
   env: stringMapSchema7.optional(),
   environment: stringMapSchema7.optional(),
-  cwd: z8.string().min(1).optional(),
-  enabled: z8.boolean().optional()
+  cwd: z10.string().min(1).optional(),
+  enabled: z10.boolean().optional()
 }).passthrough();
 
 class OpenCodeAdapter {
@@ -2480,17 +2384,17 @@ class OpenCodeAdapter {
 
 // src/adapters/vscode.ts
 import path15 from "node:path";
-import { z as z9 } from "zod";
-var stringMapSchema8 = z9.record(z9.string(), z9.string());
-var vscodeEntrySchema = z9.object({
-  type: z9.string().optional(),
-  url: z9.string().min(1).optional(),
+import { z as z11 } from "zod";
+var stringMapSchema8 = z11.record(z11.string(), z11.string());
+var vscodeEntrySchema = z11.object({
+  type: z11.string().optional(),
+  url: z11.string().min(1).optional(),
   headers: stringMapSchema8.optional(),
-  command: z9.string().min(1).optional(),
-  args: z9.array(z9.string()).optional(),
+  command: z11.string().min(1).optional(),
+  args: z11.array(z11.string()).optional(),
   env: stringMapSchema8.optional(),
-  cwd: z9.string().min(1).optional(),
-  disabled: z9.boolean().optional()
+  cwd: z11.string().min(1).optional(),
+  disabled: z11.boolean().optional()
 }).passthrough();
 
 class VsCodeAdapter {
@@ -2616,17 +2520,17 @@ class VsCodeAdapter {
 
 // src/adapters/qwen.ts
 import path16 from "node:path";
-import { z as z10 } from "zod";
-var stringMapSchema9 = z10.record(z10.string(), z10.string());
-var qwenEntrySchema = z10.object({
-  httpUrl: z10.string().min(1).optional(),
-  url: z10.string().min(1).optional(),
+import { z as z12 } from "zod";
+var stringMapSchema9 = z12.record(z12.string(), z12.string());
+var qwenEntrySchema = z12.object({
+  httpUrl: z12.string().min(1).optional(),
+  url: z12.string().min(1).optional(),
   headers: stringMapSchema9.optional(),
-  command: z10.string().min(1).optional(),
-  args: z10.array(z10.string()).optional(),
+  command: z12.string().min(1).optional(),
+  args: z12.array(z12.string()).optional(),
   env: stringMapSchema9.optional(),
-  cwd: z10.string().min(1).optional(),
-  disabled: z10.boolean().optional()
+  cwd: z12.string().min(1).optional(),
+  disabled: z12.boolean().optional()
 }).passthrough();
 
 class QwenAdapter {
@@ -2757,18 +2661,18 @@ class QwenAdapter {
 // src/adapters/openclaw.ts
 import fs11 from "node:fs";
 import path17 from "node:path";
-import { z as z11 } from "zod";
-var stringMapSchema10 = z11.record(z11.string(), z11.string());
-var openclawEntrySchema = z11.object({
-  url: z11.string().min(1).optional(),
-  transport: z11.string().optional(),
+import { z as z13 } from "zod";
+var stringMapSchema10 = z13.record(z13.string(), z13.string());
+var openclawEntrySchema = z13.object({
+  url: z13.string().min(1).optional(),
+  transport: z13.string().optional(),
   headers: stringMapSchema10.optional(),
-  command: z11.string().min(1).optional(),
-  args: z11.array(z11.string()).optional(),
+  command: z13.string().min(1).optional(),
+  args: z13.array(z13.string()).optional(),
   env: stringMapSchema10.optional(),
-  cwd: z11.string().min(1).optional(),
-  workingDirectory: z11.string().min(1).optional(),
-  auth: z11.unknown().optional()
+  cwd: z13.string().min(1).optional(),
+  workingDirectory: z13.string().min(1).optional(),
+  auth: z13.unknown().optional()
 }).passthrough();
 
 class OpenClawAdapter {
@@ -2908,18 +2812,18 @@ class OpenClawAdapter {
 import fs12 from "node:fs";
 import path18 from "node:path";
 import YAML from "yaml";
-import { z as z12 } from "zod";
-var stringMapSchema11 = z12.record(z12.string(), z12.string());
-var hermesEntrySchema = z12.object({
-  url: z12.string().min(1).optional(),
+import { z as z14 } from "zod";
+var stringMapSchema11 = z14.record(z14.string(), z14.string());
+var hermesEntrySchema = z14.object({
+  url: z14.string().min(1).optional(),
   headers: stringMapSchema11.optional(),
-  command: z12.string().min(1).optional(),
-  args: z12.array(z12.string()).optional(),
+  command: z14.string().min(1).optional(),
+  args: z14.array(z14.string()).optional(),
   env: stringMapSchema11.optional(),
-  auth: z12.unknown().optional(),
-  enabled: z12.boolean().optional(),
-  timeout: z12.number().optional(),
-  tools: z12.array(z12.string()).optional()
+  auth: z14.unknown().optional(),
+  enabled: z14.boolean().optional(),
+  timeout: z14.number().optional(),
+  tools: z14.array(z14.string()).optional()
 }).passthrough();
 
 class HermesAdapter {
@@ -3084,13 +2988,18 @@ function listSkills() {
   for (const file of files) {
     if (file.endsWith(".md")) {
       const id = path19.basename(file, ".md");
-      const content = fs13.readFileSync(path19.join(skillsDir, file), "utf-8");
-      skills.push({ id, content });
+      try {
+        const content = fs13.readFileSync(path19.join(skillsDir, file), "utf-8");
+        skills.push({ id, content });
+      } catch {
+        console.error(`[mcpx] Warning: could not read skill ${file}`);
+      }
     }
   }
   return skills;
 }
 function getSkill(id) {
+  validateSkillId(id);
   const skillsDir = getSkillsDir();
   const filePath = path19.join(skillsDir, `${id}.md`);
   if (!fs13.existsSync(filePath)) {
@@ -3100,12 +3009,14 @@ function getSkill(id) {
   return { id, content };
 }
 function saveSkill(id, content) {
+  validateSkillId(id);
   const skillsDir = getSkillsDir();
   ensureDir(skillsDir);
   const filePath = path19.join(skillsDir, `${id}.md`);
   fs13.writeFileSync(filePath, content, "utf-8");
 }
 function deleteSkill(id) {
+  validateSkillId(id);
   const skillsDir = getSkillsDir();
   const filePath = path19.join(skillsDir, `${id}.md`);
   if (fs13.existsSync(filePath)) {
@@ -3464,7 +3375,7 @@ class PluginManager {
   }
   async installResolvedPlugin(source, options, sourceLabel = source.original) {
     const info = await this.inspectResolvedSource(source, sourceLabel);
-    const pluginName = options?.name || info.manifest?.name || path21.basename(info.root);
+    const pluginName = normalizePluginName(options?.name || info.manifest?.name || path21.basename(info.root));
     const pluginId = `${pluginName}@${info.sha.slice(0, 8)}`;
     const dataDir = path21.join(getPluginDataRoot(), pluginId);
     ensureDir(dataDir);
@@ -3518,7 +3429,7 @@ class PluginManager {
       for (const mcp of discovered.mcpServers) {
         const nsName2 = `${pluginName}__${mcp.id}`;
         const approved = plugin.approvals?.mcpServers !== false;
-        config.servers[nsName2] = mcp.transport === "http" && mcp.url ? { transport: "http", url: mcp.url, enabled: enabled && approved } : {
+        config.servers[nsName2] = mcp.transport === "http" && mcp.url ? { transport: "http", url: new URL(mcp.url).toString(), enabled: enabled && approved } : {
           transport: "stdio",
           command: "npx",
           args: ["-y", "@kwonye/mcpx@latest", "plugin-host", pluginId, mcp.id],
@@ -3549,7 +3460,7 @@ class PluginManager {
     const currentSnapshot = loadConfig(this.configPath).plugins?.[pluginId];
     if (!currentSnapshot)
       throw new Error(`Plugin ${pluginId} not found`);
-    const pluginName = info.manifest?.name || currentSnapshot.name;
+    const pluginName = normalizePluginName(info.manifest?.name || currentSnapshot.name);
     let updatedPlugin;
     await mutateConfig((config) => {
       if (!config.plugins)
@@ -3565,17 +3476,18 @@ class PluginManager {
       current.root = info.root;
       current.discovered = info.components;
       current.serverNames = info.components.mcpServers.map((s) => `${pluginName}__${s.id}`);
-      const approved = current.approvals?.mcpServers !== false;
+      const requiresApproval = !current.marketplace && info.components.mcpServers.length > 0;
+      const approved = !requiresApproval && current.approvals?.mcpServers !== false;
       for (const mcp of info.components.mcpServers) {
         const nsName2 = `${pluginName}__${mcp.id}`;
-        config.servers[nsName2] = mcp.transport === "http" && mcp.url ? { transport: "http", url: mcp.url, enabled: current.enabled && approved } : {
+        config.servers[nsName2] = mcp.transport === "http" && mcp.url ? { transport: "http", url: new URL(mcp.url).toString(), enabled: current.enabled && approved } : {
           transport: "stdio",
           command: "npx",
           args: ["-y", "@kwonye/mcpx@latest", "plugin-host", pluginId, mcp.id],
           enabled: current.enabled && approved
         };
       }
-      current.approvals = {};
+      current.approvals = requiresApproval ? { mcpServers: false } : {};
       if (sourceFingerprint && current.marketplace)
         current.marketplace.sourceFingerprint = sourceFingerprint;
       delete current.updateError;
@@ -3620,6 +3532,11 @@ class PluginManager {
       if (!plugin)
         throw new Error(`Plugin ${pluginId} not found`);
       plugin.enabled = true;
+      for (const name of plugin.serverNames) {
+        const server = config.servers[name];
+        if (server)
+          server.enabled = plugin.approvals?.mcpServers !== false;
+      }
     }, this.configPath);
     const syncConfig = loadConfig(this.configPath);
     const summary = syncAllClients(syncConfig, this.secrets);
@@ -3635,6 +3552,11 @@ class PluginManager {
       if (!plugin)
         throw new Error(`Plugin ${pluginId} not found`);
       plugin.enabled = false;
+      for (const name of plugin.serverNames) {
+        const server = config.servers[name];
+        if (server)
+          server.enabled = false;
+      }
     }, this.configPath);
     const syncConfig = loadConfig(this.configPath);
     const summary = syncAllClients(syncConfig, this.secrets);
@@ -3678,10 +3600,11 @@ class PluginManager {
     const config = loadConfig(this.configPath);
     if (!config.plugins)
       throw new Error(`Plugin ${pluginId} not found`);
-    const plugin = config.plugins[pluginId];
+    const resolvedId = resolvePluginId(config, pluginId);
+    const plugin = config.plugins[resolvedId];
     if (!plugin)
       throw new Error(`Plugin ${pluginId} not found`);
-    await this.lifecycle.prepareDependencies(pluginId, plugin.root);
+    await this.lifecycle.prepareDependencies(resolvedId, plugin.root);
   }
 }
 async function inspectPlugin(source) {
@@ -3697,7 +3620,7 @@ async function updatePlugin(nameOrId) {
   const config = loadConfig(manager["configPath"]);
   const id = resolvePluginId(config, nameOrId);
   if (config.plugins?.[id]?.marketplace) {
-    const { updateMarketplaceInstalledPlugin } = await import("./marketplace-pwabb3ea.js");
+    const { updateMarketplaceInstalledPlugin } = await import("./marketplace-zem0m4mw.js");
     return updateMarketplaceInstalledPlugin(id);
   }
   return manager.updatePlugin(id);